widevine-partner/android
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge changes I37d6d7aa,I9e8624dd,I96c2015a,I0b755962

Browse Source 
* changes:
  Replace scoped_ptr With std::unique_ptr
  Replace shared_ptr With std::shared_ptr
  Replace UniquePtr with std::unique_ptr
  override, Don't OVERRIDE
This commit is contained in:
John Bruce
2018-11-16 18:08:02 +00:00
committed by Android (Google) Code Review
parent 49906026b7 b182a7445e
commit 218aa76560
48 changed files with 141 additions and 848 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
libwvdrmengine/cdm/core/include/cdm_engine.h
View File

@@ -19,7 +19,6 @@
#include "lock.h"
#include "metrics_collections.h"
#include "oemcrypto_adapter.h"
#include "scoped_ptr.h"
#include "service_certificate.h"
#include "wv_cdm_constants.h"
#include "wv_cdm_types.h"
@@ -325,7 +324,7 @@ class CdmEngine {
CdmSessionMap session_map_;
CdmReleaseKeySetMap release_key_sets_;
scoped_ptr<CertificateProvisioning> cert_provisioning_;
std::unique_ptr<CertificateProvisioning> cert_provisioning_;
SecurityLevel cert_provisioning_requested_security_level_;
FileSystem* file_system_;
Clock clock_;
@@ -334,8 +333,8 @@ class CdmEngine {
static bool seeded_;
// usage related variables
scoped_ptr<CdmSession> usage_session_;
scoped_ptr<UsagePropertySet> usage_property_set_;
std::unique_ptr<CdmSession> usage_session_;
std::unique_ptr<UsagePropertySet> usage_property_set_;
int64_t last_usage_information_update_time_;
// Protect release_key_sets_ from non-thread-safe operations.

10
libwvdrmengine/cdm/core/include/cdm_session.h
View File

@@ -5,6 +5,7 @@
#ifndef WVCDM_CORE_CDM_SESSION_H_
#define WVCDM_CORE_CDM_SESSION_H_
#include <memory>
#include <set>
#include <string>
#include <vector>
@@ -18,7 +19,6 @@
#include "metrics_collections.h"
#include "oemcrypto_adapter.h"
#include "policy_engine.h"
#include "scoped_ptr.h"
#include "timer_metric.h"
#include "wv_cdm_types.h"
@@ -228,10 +228,10 @@ class CdmSession {
bool closed_; // Session closed, but final shared_ptr has not been released.
CdmSessionId session_id_;
FileSystem* file_system_;
scoped_ptr<CdmLicense> license_parser_;
scoped_ptr<CryptoSession> crypto_session_;
scoped_ptr<PolicyEngine> policy_engine_;
scoped_ptr<DeviceFiles> file_handle_;
std::unique_ptr<CdmLicense> license_parser_;
std::unique_ptr<CryptoSession> crypto_session_;
std::unique_ptr<PolicyEngine> policy_engine_;
std::unique_ptr<DeviceFiles> file_handle_;
bool license_received_;
bool is_offline_;
bool is_release_;

9
libwvdrmengine/cdm/core/include/cdm_session_map.h
View File

@@ -12,12 +12,11 @@
#include "cdm_session.h"
#include "disallow_copy_and_assign.h"
#include "lock.h"
#include "shared_ptr.h"
#include "wv_cdm_types.h"
namespace wvcdm {
typedef std::list<shared_ptr<CdmSession> > CdmSessionList;
typedef std::list<std::shared_ptr<CdmSession> > CdmSessionList;
// TODO(rfrias): Concurrency protection for this class has moved to CdmEngine.
// Add it back when locks to control access to session usage and destruction
@@ -40,16 +39,16 @@ class CdmSessionMap {
size_t Size() const { return sessions_.size(); }
bool FindSession(const CdmSessionId& id,
shared_ptr<CdmSession>* session);
std::shared_ptr<CdmSession>* session);
void GetSessionList(CdmSessionList& sessions);
private:
typedef std::map<CdmSessionId, shared_ptr<CdmSession> >
typedef std::map<CdmSessionId, std::shared_ptr<CdmSession> >
CdmIdToSessionMap;
bool FindSessionNoLock(const CdmSessionId& session_id,
shared_ptr<CdmSession>* session);
std::shared_ptr<CdmSession>* session);
CdmIdToSessionMap sessions_;

6
libwvdrmengine/cdm/core/include/certificate_provisioning.h
View File

@@ -5,6 +5,7 @@
#ifndef WVCDM_CORE_CERTIFICATE_PROVISIONING_H_
#define WVCDM_CORE_CERTIFICATE_PROVISIONING_H_
#include <memory>
#include <string>
#include "crypto_session.h"
@@ -12,7 +13,6 @@
#include "license_protocol.pb.h"
#include "metrics_collections.h"
#include "oemcrypto_adapter.h"
#include "scoped_ptr.h"
#include "service_certificate.h"
#include "wv_cdm_types.h"
@@ -53,9 +53,9 @@ class CertificateProvisioning {
video_widevine::SignedProvisioningMessage::ProtocolVersion
GetProtocolVersion();
scoped_ptr<CryptoSession> crypto_session_;
std::unique_ptr<CryptoSession> crypto_session_;
CdmCertificateType cert_type_;
scoped_ptr<ServiceCertificate> service_certificate_;
std::unique_ptr<ServiceCertificate> service_certificate_;
CORE_DISALLOW_COPY_AND_ASSIGN(CertificateProvisioning);
};

15
libwvdrmengine/cdm/core/include/content_key_session.h
View File

@@ -7,7 +7,6 @@
#include "key_session.h"
#include "metrics_collections.h"
#include "override.h"
#include "timer_metric.h"
namespace wvcdm {
@@ -21,14 +20,14 @@ class ContentKeySession : public KeySession {
cipher_mode_(kCipherModeCtr) {}
virtual ~ContentKeySession() {}
virtual KeySessionType Type() OVERRIDE { return kDefault; }
virtual KeySessionType Type() override { return kDefault; }
// Generate Derived Keys for ContentKeySession
virtual bool GenerateDerivedKeys(const std::string& message) OVERRIDE;
virtual bool GenerateDerivedKeys(const std::string& message) override;
// Generate Derived Keys (from session key) for ContentKeySession
virtual bool GenerateDerivedKeys(const std::string& message,
const std::string& session_key) OVERRIDE;
const std::string& session_key) override;
// Load Keys for ContentKeySession
virtual OEMCryptoResult LoadKeys(const std::string& message,
@@ -38,22 +37,22 @@ class ContentKeySession : public KeySession {
const std::vector<CryptoKey>& keys,
const std::string& provider_session_token,
CdmCipherMode* cipher_mode,
const std::string& srm_requirement) OVERRIDE;
const std::string& srm_requirement) override;
virtual OEMCryptoResult LoadEntitledContentKeys(
const std::vector<CryptoKey>&) OVERRIDE {
const std::vector<CryptoKey>&) override {
return OEMCrypto_ERROR_INVALID_CONTEXT;
}
// Select Key for ContentKeySession
virtual OEMCryptoResult SelectKey(const std::string& key_id,
CdmCipherMode cipher_mode) OVERRIDE;
CdmCipherMode cipher_mode) override;
// Decrypt for ContentKeySession
virtual OEMCryptoResult Decrypt(
const CdmDecryptionParameters& params,
OEMCrypto_DestBufferDesc& buffer_descriptor,
OEMCrypto_CENCEncryptPatternDesc& pattern_descriptor) OVERRIDE;
OEMCrypto_CENCEncryptPatternDesc& pattern_descriptor) override;
protected:
virtual OEMCryptoResult LoadKeysAsLicenseType(

6
libwvdrmengine/cdm/core/include/crypto_session.h
View File

@@ -6,6 +6,7 @@
#define WVCDM_CORE_CRYPTO_SESSION_H_
#include <map>
#include <memory>
#include <string>
#include <vector>
@@ -15,7 +16,6 @@
#include "lock.h"
#include "metrics_collections.h"
#include "oemcrypto_adapter.h"
#include "scoped_ptr.h"
#include "timer_metric.h"
#include "wv_cdm_types.h"
@@ -295,7 +295,7 @@ class CryptoSession {
SubLicenseSessionMap sub_license_oec_sessions_;
// Used for sub license sessions.
std::string wrapped_key_;
scoped_ptr<KeySession> key_session_;
std::unique_ptr<KeySession> key_session_;
OEMCryptoBufferType destination_buffer_type_;
bool is_destination_buffer_type_valid_;
@@ -313,7 +313,7 @@ class CryptoSession {
CdmCipherMode cipher_mode_;
uint32_t api_version_;
static scoped_ptr<CryptoSessionFactory> factory_;
static std::unique_ptr<CryptoSessionFactory> factory_;
CORE_DISALLOW_COPY_AND_ASSIGN(CryptoSession);
};

1
libwvdrmengine/cdm/core/include/device_files.h
View File

@@ -13,7 +13,6 @@
#include "device_files.pb.h"
#include "disallow_copy_and_assign.h"
#include "scoped_ptr.h"
#include "wv_cdm_types.h"
#if defined(UNIT_TEST)

7
libwvdrmengine/cdm/core/include/entitlement_key_session.h
View File

@@ -12,7 +12,6 @@
#include "content_key_session.h"
#include "crypto_key.h"
#include "metrics_collections.h"
#include "override.h"
namespace wvcdm {
@@ -32,11 +31,11 @@ class EntitlementKeySession : public ContentKeySession {
const std::vector<CryptoKey>& keys,
const std::string& provider_session_token,
CdmCipherMode* cipher_mode,
const std::string& srm_requirement) OVERRIDE;
const std::string& srm_requirement) override;
virtual OEMCryptoResult LoadEntitledContentKeys(
const std::vector<CryptoKey>& keys) OVERRIDE;
const std::vector<CryptoKey>& keys) override;
virtual OEMCryptoResult SelectKey(const std::string& key_id,
CdmCipherMode cipher_mode) OVERRIDE;
CdmCipherMode cipher_mode) override;
private:
// The object returned by this function contains raw pointers to the passed-in

6
libwvdrmengine/cdm/core/include/license.h
View File

@@ -5,12 +5,12 @@
#ifndef WVCDM_CORE_LICENSE_H_
#define WVCDM_CORE_LICENSE_H_
#include <memory>
#include <set>
#include "disallow_copy_and_assign.h"
#include "initialization_data.h"
#include "license_protocol.pb.h"
#include "scoped_ptr.h"
#include "service_certificate.h"
#include "wv_cdm_types.h"
@@ -121,7 +121,7 @@ class CdmLicense {
CdmClientTokenType client_token_type_;
std::string device_id_;
const CdmSessionId session_id_;
scoped_ptr<InitializationData> stored_init_data_;
std::unique_ptr<InitializationData> stored_init_data_;
bool initialized_;
std::set<KeyId> loaded_keys_;
std::string provider_session_token_;
@@ -135,7 +135,7 @@ class CdmLicense {
// Used for certificate based licensing
CdmKeyMessage key_request_;
scoped_ptr<Clock> clock_;
std::unique_ptr<Clock> clock_;
// For testing
// CdmLicense takes ownership of the clock.

20
libwvdrmengine/cdm/core/include/override.h
View File

@@ -1,20 +0,0 @@
// Copyright 2018 Google LLC. All Rights Reserved. This file and proprietary
// source code may only be used and distributed under the Widevine Master
// License Agreement.
// TODO: Import to core/, use everywhere.
#ifndef WVCDM_CDM_OVERRIDE_H_
#define WVCDM_CDM_OVERRIDE_H_
#define GCC_HAS_OVERRIDE ( \
(__GNUC__ > 4) || \
(__GNUC__ == 4 && __GNUC_MINOR__ >= 7) \
)
#if !defined(DISABLE_OVERRIDE_KEYWORD) && \
(defined(COMPILER_MSVC) || defined(__clang__) || GCC_HAS_OVERRIDE)
#define OVERRIDE override
#else
#define OVERRIDE
#endif
#endif // WVCDM_CDM_OVERRIDE_H_

6
libwvdrmengine/cdm/core/include/policy_engine.h
View File

@@ -6,12 +6,12 @@
#define WVCDM_CORE_POLICY_ENGINE_H_
#include <map>
#include <memory>
#include <string>
#include "disallow_copy_and_assign.h"
#include "license_key_status.h"
#include "license_protocol.pb.h"
#include "scoped_ptr.h"
#include "wv_cdm_types.h"
namespace wvcdm {
@@ -212,14 +212,14 @@ class PolicyEngine {
// Keys associated with license - holds allowed usage, usage constraints,
// and current status (CdmKeyStatus)
scoped_ptr<LicenseKeys> license_keys_;
std::unique_ptr<LicenseKeys> license_keys_;
// Device checks
int64_t next_device_check_;
uint32_t current_resolution_;
CryptoSession* crypto_session_;
scoped_ptr<Clock> clock_;
std::unique_ptr<Clock> clock_;
CORE_DISALLOW_COPY_AND_ASSIGN(PolicyEngine);
};

4
libwvdrmengine/cdm/core/include/properties.h
View File

@@ -6,12 +6,12 @@
#define WVCDM_CORE_PROPERTIES_H_
#include <map>
#include <memory>
#include <string>
#include "cdm_client_property_set.h"
#include "disallow_copy_and_assign.h"
#include "lock.h"
#include "scoped_ptr.h"
#include "wv_cdm_types.h"
#if defined(UNIT_TEST)
@@ -115,7 +115,7 @@ class Properties {
static bool use_certificates_as_identification_;
static bool provisioning_messages_are_binary_;
static bool allow_service_certificate_requests_;
static scoped_ptr<CdmClientPropertySetMap> session_property_set_;
static std::unique_ptr<CdmClientPropertySetMap> session_property_set_;
CORE_DISALLOW_COPY_AND_ASSIGN(Properties);
};

67
libwvdrmengine/cdm/core/include/scoped_ptr.h
View File

@@ -1,67 +0,0 @@
// Copyright 2018 Google LLC. All Rights Reserved. This file and proprietary
// source code may only be used and distributed under the Widevine Master
// License Agreement.
//
// A simple and partial implementation of scoped_ptr class.
// The implementation is copied from gtest/include/gtest/internal/gtest-port.h.
//
#ifndef WVCDM_CORE_SCOPED_PTR_H_
#define WVCDM_CORE_SCOPED_PTR_H_
#include "disallow_copy_and_assign.h"
namespace wvcdm {
// A scoped_ptr<T> is like a T*, except that the destructor of scoped_ptr<T>
// automatically deletes the pointer it holds (if any).
// That is, scoped_ptr<T> owns the T object that it points to.
// Like a T*, a scoped_ptr<T> may hold either NULL or a pointer to a T object.
// Also like T*, scoped_ptr<T> is thread-compatible, and once you
// dereference it, you get the thread safety guarantees of T.
//
// The size of scoped_ptr is small. On most compilers, sizeof(scoped_ptr<T>)
// == sizeof(T*).
//
// Current implementation targets having a strict subset of C++11's
// unique_ptr<> features. Known deficiencies include not supporting move-only
// deleteres, function pointers as deleters, and deleters with reference
// types.
// This implementation of scoped_ptr is PARTIAL, e.g. it does not support move,
// custom deleter etc.
template <typename T>
class scoped_ptr {
public:
typedef T element_type;
explicit scoped_ptr(T* p = NULL) : ptr_(p) {}
~scoped_ptr() { reset(); }
T& operator*() const { return *ptr_; }
T* operator->() const { return ptr_; }
T* get() const { return ptr_; }
T* release() {
T* const ptr = ptr_;
ptr_ = NULL;
return ptr;
}
void reset(T* p = NULL) {
if (p != ptr_) {
if (sizeof(T) > 0) { // Makes sure T is a complete type.
delete ptr_;
}
ptr_ = p;
}
}
private:
T* ptr_;
CORE_DISALLOW_COPY_AND_ASSIGN(scoped_ptr);
};
} // namespace wvcdm
#endif // WVCDM_CORE_SCOPED_PTR_H_

3
libwvdrmengine/cdm/core/include/service_certificate.h
View File

@@ -18,7 +18,6 @@
#include "disallow_copy_and_assign.h"
#include "license_protocol.pb.h"
#include "privacy_crypto.h"
#include "scoped_ptr.h"
#include "wv_cdm_types.h"
namespace wvcdm {
@@ -79,7 +78,7 @@ class ServiceCertificate {
std::string provider_id_;
// Public key.
scoped_ptr<RsaPublicKey> public_key_;
std::unique_ptr<RsaPublicKey> public_key_;
CORE_DISALLOW_COPY_AND_ASSIGN(ServiceCertificate);
};

209
libwvdrmengine/cdm/core/include/shared_ptr.h
View File

@@ -1,209 +0,0 @@
// Copyright 2018 Google LLC. All Rights Reserved. This file and proprietary
// source code may only be used and distributed under the Widevine Master
// License Agreement.
//
// from google3/util/gtl/shared_ptr.h
// from protobuf/src/google/protobuf/stubs/shared_ptr.h
#ifndef WVCDM_CORE_SHARED_PTR_H__
#define WVCDM_CORE_SHARED_PTR_H__
#include <algorithm> // for swap
#include <stddef.h>
#include <memory>
#include "lock.h"
#include "wv_cdm_types.h"
namespace wvcdm {
extern Lock shared_ptr_ref_count_lock_;
} // namespace wvcdm
namespace {
bool Barrier_AtomicIncrement(volatile uint32_t* ptr, uint32_t value) {
*ptr += value;
return *ptr;
}
bool NoBarrier_AtomicIncrement(volatile uint32_t* ptr, uint32_t value) {
*ptr += value;
return *ptr;
}
inline bool RefCountDec(volatile uint32_t *ptr) {
wvcdm::AutoLock auto_lock(wvcdm::shared_ptr_ref_count_lock_);
return Barrier_AtomicIncrement(ptr, -1) != 0;
}
inline void RefCountInc(volatile uint32_t *ptr) {
wvcdm::AutoLock auto_lock(wvcdm::shared_ptr_ref_count_lock_);
NoBarrier_AtomicIncrement(ptr, 1);
}
} // namespace
namespace wvcdm {
template <typename T> class shared_ptr;
// This class is an internal implementation detail for shared_ptr. If two
// shared_ptrs point to the same object, they also share a control block.
// An "empty" shared_pointer refers to NULL and also has a NULL control block.
// It contains all of the state that's needed for reference counting or any
// other kind of resource management. In this implementation the control block
// consists of a single reference count (the number of shared_ptrs that
// share ownership of the object).
class SharedPtrControlBlock {
template <typename T> friend class shared_ptr;
private:
SharedPtrControlBlock() : refcount_(1) {}
uint32_t refcount_;
};
// Forward declaration. The class is defined below.
template <typename T> class enable_shared_from_this;
template <typename T>
class shared_ptr {
public:
typedef T element_type;
shared_ptr() : ptr_(NULL), control_block_(NULL) {}
explicit shared_ptr(T* ptr)
: ptr_(ptr),
control_block_(ptr != NULL ? new SharedPtrControlBlock : NULL) {
}
// Copy constructor: makes this object a copy of ptr, and increments
// the reference count.
template <typename U>
shared_ptr(const shared_ptr<U>& ptr)
: ptr_(NULL),
control_block_(NULL) {
Initialize(ptr);
}
// Need non-templated version to prevent the compiler-generated default
shared_ptr(const shared_ptr<T>& ptr)
: ptr_(NULL),
control_block_(NULL) {
Initialize(ptr);
}
// Assignment operator. Replaces the existing shared_ptr with ptr.
// Increment ptr's reference count and decrement the one being replaced.
template <typename U>
shared_ptr<T>& operator=(const shared_ptr<U>& ptr) {
if (ptr_ != ptr.ptr_) {
shared_ptr<T> me(ptr); // will hold our previous state to be destroyed.
swap(me);
}
return *this;
}
// Need non-templated version to prevent the compiler-generated default
shared_ptr<T>& operator=(const shared_ptr<T>& ptr) {
if (ptr_ != ptr.ptr_) {
shared_ptr<T> me(ptr); // will hold our previous state to be destroyed.
swap(me);
}
return *this;
}
~shared_ptr() {
if (ptr_ != NULL) {
if (!RefCountDec(&control_block_->refcount_)) {
delete ptr_;
delete control_block_;
}
}
}
// Replaces underlying raw pointer with the one passed in. The reference
// count is set to one (or zero if the pointer is NULL) for the pointer
// being passed in and decremented for the one being replaced.
//
// If you have a compilation error with this code, make sure you aren't
// passing NULL, nullptr, or 0 to this function. Call reset without an
// argument to reset to a null ptr.
template <typename Y>
void reset(Y* p) {
if (p != ptr_) {
shared_ptr<T> tmp(p);
tmp.swap(*this);
}
}
void reset() {
reset(static_cast<T*>(NULL));
}
// Exchanges the contents of this with the contents of r. This function
// supports more efficient swapping since it eliminates the need for a
// temporary shared_ptr object.
void swap(shared_ptr<T>& r) {
using std::swap; // http://go/using-std-swap
swap(ptr_, r.ptr_);
swap(control_block_, r.control_block_);
}
// The following function is useful for gaining access to the underlying
// pointer when a shared_ptr remains in scope so the reference-count is
// known to be > 0 (e.g. for parameter passing).
T* get() const {
return ptr_;
}
T& operator*() const {
return *ptr_;
}
T* operator->() const {
return ptr_;
}
long use_count() const {
return control_block_ ? control_block_->refcount_ : 1;
}
bool unique() const {
return use_count() == 1;
}
private:
// If r is non-empty, initialize *this to share ownership with r,
// increasing the underlying reference count.
// If r is empty, *this remains empty.
// Requires: this is empty, namely this->ptr_ == NULL.
template <typename U>
void Initialize(const shared_ptr<U>& r) {
// This performs a static_cast on r.ptr_ to U*, which is a no-op since it
// is already a U*. So initialization here requires that r.ptr_ is
// implicitly convertible to T*.
InitializeWithStaticCast<U>(r);
}
// Initializes *this as described in Initialize, but additionally performs a
// static_cast from r.ptr_ (V*) to U*.
// NOTE(gfc): We'd need a more general form to support const_pointer_cast and
// dynamic_pointer_cast, but those operations are sufficiently discouraged
// that supporting static_pointer_cast is sufficient.
template <typename U, typename V>
void InitializeWithStaticCast(const shared_ptr<V>& r) {
if (r.control_block_ != NULL) {
RefCountInc(&r.control_block_->refcount_);
ptr_ = static_cast<U*>(r.ptr_);
control_block_ = r.control_block_;
}
}
T* ptr_;
SharedPtrControlBlock* control_block_;
};
} // namespace wvcdm
#endif // WVCDM_CORE_SHARED_PTR_H__

8
libwvdrmengine/cdm/core/include/usage_table_header.h
View File

@@ -5,6 +5,7 @@
#ifndef WVCDM_CORE_USAGE_TABLE_HEADER_H_
#define WVCDM_CORE_USAGE_TABLE_HEADER_H_
#include <memory>
#include <string>
#include <vector>
@@ -14,7 +15,6 @@
#include "file_store.h"
#include "lock.h"
#include "metrics_collections.h"
#include "scoped_ptr.h"
#include "wv_cdm_types.h"
namespace wvcdm {
@@ -100,8 +100,8 @@ class UsageTableHeader {
// This handle and file system is only to be used when accessing
// usage_table_header. Usage entries should use the file system provided
// by CdmSession.
scoped_ptr<DeviceFiles> file_handle_;
scoped_ptr<FileSystem> file_system_;
std::unique_ptr<DeviceFiles> file_handle_;
std::unique_ptr<FileSystem> file_system_;
CdmSecurityLevel security_level_;
SecurityLevel requested_security_level_;
@@ -131,7 +131,7 @@ class UsageTableHeader {
}
// Test related data members
scoped_ptr<CryptoSession> test_crypto_session_;
std::unique_ptr<CryptoSession> test_crypto_session_;
CORE_DISALLOW_COPY_AND_ASSIGN(UsageTableHeader);
};

68
libwvdrmengine/cdm/core/src/cdm_engine.cpp
View File

@@ -5,10 +5,11 @@
#include "cdm_engine.h"
#include <assert.h>
#include <list>
#include <stdlib.h>
#include <iostream>
#include <list>
#include <memory>
#include <sstream>
#include "cdm_session.h"
@@ -30,8 +31,6 @@ const size_t kUsageReportsPerRequest = 1;
namespace wvcdm {
Lock shared_ptr_ref_count_lock_;
class UsagePropertySet : public CdmClientPropertySet {
public:
UsagePropertySet() {}
@@ -61,11 +60,12 @@ class UsagePropertySet : public CdmClientPropertySet {
bool CdmEngine::seeded_ = false;
CdmEngine::CdmEngine(FileSystem* file_system, const std::string& spoid)
: cert_provisioning_(NULL),
: cert_provisioning_(),
cert_provisioning_requested_security_level_(kLevelDefault),
file_system_(file_system),
spoid_(spoid),
usage_session_(NULL),
usage_session_(),
usage_property_set_(),
last_usage_information_update_time_(0) {
assert(file_system);
if (!seeded_) {
@@ -127,7 +127,7 @@ CdmResponseType CdmEngine::OpenSession(
CloseExpiredReleaseSessions();
scoped_ptr<CdmSession> new_session(new CdmSession(file_system_,
std::unique_ptr<CdmSession> new_session(new CdmSession(file_system_,
metrics_.AddSession()));
CdmResponseType sts = new_session->Init(property_set, forced_session_id,
event_listener);
@@ -261,7 +261,7 @@ CdmResponseType CdmEngine::GenerateKeyRequest(
id = iter->second.first;
}
shared_ptr<CdmSession> session;
std::shared_ptr<CdmSession> session;
if (!session_map_.FindSession(id, &session)) {
LOGE("CdmEngine::GenerateKeyRequest: session_id not found = %s",
id.c_str());
@@ -337,7 +337,7 @@ CdmResponseType CdmEngine::AddKey(const CdmSessionId& session_id,
id = iter->second.first;
}
shared_ptr<CdmSession> session;
std::shared_ptr<CdmSession> session;
if (!session_map_.FindSession(id, &session)) {
LOGE("CdmEngine::AddKey: session id not found = %s", id.c_str());
return SESSION_NOT_FOUND_3;
@@ -381,7 +381,7 @@ CdmResponseType CdmEngine::RestoreKey(const CdmSessionId& session_id,
return EMPTY_KEYSET_ID_ENG_4;
}
shared_ptr<CdmSession> session;
std::shared_ptr<CdmSession> session;
if (!session_map_.FindSession(session_id, &session)) {
LOGE("CdmEngine::RestoreKey: session_id not found = %s ",
session_id.c_str());
@@ -404,7 +404,7 @@ CdmResponseType CdmEngine::RestoreKey(const CdmSessionId& session_id,
CdmResponseType CdmEngine::RemoveKeys(const CdmSessionId& session_id) {
LOGI("CdmEngine::RemoveKeys");
shared_ptr<CdmSession> session;
std::shared_ptr<CdmSession> session;
if (!session_map_.FindSession(session_id, &session)) {
LOGE("CdmEngine::RemoveKeys: session_id not found = %s",
session_id.c_str());
@@ -419,7 +419,7 @@ CdmResponseType CdmEngine::RemoveKeys(const CdmSessionId& session_id) {
CdmResponseType CdmEngine::RemoveLicense(const CdmSessionId& session_id) {
LOGI("CdmEngine::RemoveLicense");
shared_ptr<CdmSession> session;
std::shared_ptr<CdmSession> session;
if (!session_map_.FindSession(session_id, &session)) {
LOGE("session_id not found = %s", session_id.c_str());
return SESSION_NOT_FOUND_19;
@@ -432,7 +432,7 @@ CdmResponseType CdmEngine::GenerateRenewalRequest(
const CdmSessionId& session_id, CdmKeyRequest* key_request) {
LOGI("CdmEngine::GenerateRenewalRequest");
shared_ptr<CdmSession> session;
std::shared_ptr<CdmSession> session;
if (!session_map_.FindSession(session_id, &session)) {
LOGE("CdmEngine::GenerateRenewalRequest: session_id not found = %s",
session_id.c_str());
@@ -461,7 +461,7 @@ CdmResponseType CdmEngine::RenewKey(const CdmSessionId& session_id,
const CdmKeyResponse& key_data) {
LOGI("CdmEngine::RenewKey");
shared_ptr<CdmSession> session;
std::shared_ptr<CdmSession> session;
if (!session_map_.FindSession(session_id, &session)) {
LOGE("CdmEngine::RenewKey: session_id not found = %s", session_id.c_str());
return SESSION_NOT_FOUND_7;
@@ -492,7 +492,7 @@ CdmResponseType CdmEngine::QueryStatus(SecurityLevel security_level,
const std::string& query_token,
std::string* query_response) {
LOGI("CdmEngine::QueryStatus");
scoped_ptr<CryptoSession> crypto_session(
std::unique_ptr<CryptoSession> crypto_session(
CryptoSession::MakeCryptoSession(metrics_.GetCryptoMetrics()));
CdmResponseType status;
M_TIME(
@@ -653,7 +653,7 @@ CdmResponseType CdmEngine::QueryStatus(SecurityLevel security_level,
CdmResponseType CdmEngine::QuerySessionStatus(const CdmSessionId& session_id,
CdmQueryMap* query_response) {
LOGI("CdmEngine::QuerySessionStatus");
shared_ptr<CdmSession> session;
std::shared_ptr<CdmSession> session;
if (!session_map_.FindSession(session_id, &session)) {
LOGE("CdmEngine::QuerySessionStatus: session_id not found = %s",
session_id.c_str());
@@ -664,7 +664,7 @@ CdmResponseType CdmEngine::QuerySessionStatus(const CdmSessionId& session_id,
bool CdmEngine::IsReleaseSession(const CdmSessionId& session_id) {
LOGI("CdmEngine::IsReleaseSession");
shared_ptr<CdmSession> session;
std::shared_ptr<CdmSession> session;
if (!session_map_.FindSession(session_id, &session)) {
LOGE("CdmEngine::IsReleaseSession: session_id not found = %s",
session_id.c_str());
@@ -675,7 +675,7 @@ bool CdmEngine::IsReleaseSession(const CdmSessionId& session_id) {
bool CdmEngine::IsOfflineSession(const CdmSessionId& session_id) {
LOGI("CdmEngine::IsOfflineSession");
shared_ptr<CdmSession> session;
std::shared_ptr<CdmSession> session;
if (!session_map_.FindSession(session_id, &session)) {
LOGE("CdmEngine::IsOfflineSession: session_id not found = %s",
session_id.c_str());
@@ -687,7 +687,7 @@ bool CdmEngine::IsOfflineSession(const CdmSessionId& session_id) {
CdmResponseType CdmEngine::QueryKeyStatus(const CdmSessionId& session_id,
CdmQueryMap* query_response) {
LOGI("CdmEngine::QueryKeyStatus");
shared_ptr<CdmSession> session;
std::shared_ptr<CdmSession> session;
if (!session_map_.FindSession(session_id, &session)) {
LOGE("CdmEngine::QueryKeyStatus: session_id not found = %s",
session_id.c_str());
@@ -704,7 +704,7 @@ CdmResponseType CdmEngine::QueryKeyAllowedUsage(const CdmSessionId& session_id,
LOGE("CdmEngine::QueryKeyAllowedUsage: no response destination");
return PARAMETER_NULL;
}
shared_ptr<CdmSession> session;
std::shared_ptr<CdmSession> session;
if (!session_map_.FindSession(session_id, &session)) {
LOGE("CdmEngine::QueryKeyAllowedUsage: session_id not found = %s",
session_id.c_str());
@@ -755,7 +755,7 @@ CdmResponseType CdmEngine::QueryKeyAllowedUsage(const std::string& key_id,
CdmResponseType CdmEngine::QueryOemCryptoSessionId(
const CdmSessionId& session_id, CdmQueryMap* query_response) {
LOGI("CdmEngine::QueryOemCryptoSessionId");
shared_ptr<CdmSession> session;
std::shared_ptr<CdmSession> session;
if (!session_map_.FindSession(session_id, &session)) {
LOGE("CdmEngine::QueryOemCryptoSessionId: session_id not found = %s",
session_id.c_str());
@@ -834,7 +834,7 @@ CdmResponseType CdmEngine::HandleProvisioningResponse(
if (NULL == cert_provisioning_.get()) {
// Certificate provisioning object has been released. Check if a concurrent
// provisioning attempt has succeeded before declaring failure.
scoped_ptr<CryptoSession> crypto_session(
std::unique_ptr<CryptoSession> crypto_session(
CryptoSession::MakeCryptoSession(metrics_.GetCryptoMetrics()));
CdmResponseType status;
M_TIME(
@@ -890,7 +890,7 @@ bool CdmEngine::IsProvisioned(CdmSecurityLevel security_level) {
CdmResponseType CdmEngine::Unprovision(CdmSecurityLevel security_level) {
// Devices with baked-in DRM certs cannot be reprovisioned and therefore must
// not be unprovisioned.
scoped_ptr<CryptoSession> crypto_session(
std::unique_ptr<CryptoSession> crypto_session(
CryptoSession::MakeCryptoSession(metrics_.GetCryptoMetrics()));
CdmClientTokenType token_type = kClientTokenUninitialized;
CdmResponseType res = crypto_session->GetProvisioningMethod(
@@ -924,7 +924,7 @@ CdmResponseType CdmEngine::Unprovision(CdmSecurityLevel security_level) {
}
CdmResponseType CdmEngine::DeleteUsageTable(CdmSecurityLevel security_level) {
scoped_ptr<CryptoSession> crypto_session(
std::unique_ptr<CryptoSession> crypto_session(
CryptoSession::MakeCryptoSession(metrics_.GetCryptoMetrics()));
CdmResponseType status;
M_TIME(
@@ -1007,7 +1007,7 @@ CdmResponseType CdmEngine::DeleteUsageRecord(const std::string& app_id,
}
// Got provider token. Remove from OEMCrypto.
scoped_ptr<CryptoSession> crypto_session(
std::unique_ptr<CryptoSession> crypto_session(
CryptoSession::MakeCryptoSession(metrics_.GetCryptoMetrics()));
CdmResponseType status = crypto_session->Open(
security_level == kSecurityLevelL3 ? kLevel3 : kLevelDefault);
@@ -1216,7 +1216,7 @@ CdmResponseType CdmEngine::RemoveAllUsageInfo(
}
// Got at least one provider token. Remove from OEMCrypto.
scoped_ptr<CryptoSession> crypto_session(
std::unique_ptr<CryptoSession> crypto_session(
CryptoSession::MakeCryptoSession(metrics_.GetCryptoMetrics()));
CdmResponseType status = crypto_session->Open(
security_level == kSecurityLevelL3 ? kLevel3 : kLevelDefault);
@@ -1370,7 +1370,7 @@ CdmResponseType CdmEngine::RemoveUsageInfo(
handle.DeleteUsageInfo(
DeviceFiles::GetUsageInfoFileName(app_id),
provider_session_token);
scoped_ptr<CryptoSession> crypto_session(
std::unique_ptr<CryptoSession> crypto_session(
CryptoSession::MakeCryptoSession(metrics_.GetCryptoMetrics()));
status = crypto_session->Open(
static_cast<CdmSecurityLevel>(j) == kSecurityLevelL3
@@ -1424,7 +1424,7 @@ CdmResponseType CdmEngine::LoadUsageSession(const CdmKeySetId& key_set_id,
return EMPTY_KEYSET_ID_ENG_5;
}
shared_ptr<CdmSession> session;
std::shared_ptr<CdmSession> session;
if (!session_map_.FindSession(key_set_id, &session)) {
LOGE("CdmEngine::LoadUsageSession: session_id not found = %s ",
key_set_id.c_str());
@@ -1510,7 +1510,7 @@ CdmResponseType CdmEngine::Decrypt(const CdmSessionId& session_id,
}
AutoLock lock(session_map_lock_);
shared_ptr<CdmSession> session;
std::shared_ptr<CdmSession> session;
if (session_id.empty()) {
CdmSessionList sessions;
session_map_.GetSessionList(sessions);
@@ -1551,7 +1551,7 @@ CdmResponseType CdmEngine::GenericEncrypt(
LOGE("CdmEngine::GenericEncrypt: no out_buffer provided");
return PARAMETER_NULL;
}
shared_ptr<CdmSession> session;
std::shared_ptr<CdmSession> session;
if (!session_map_.FindSession(session_id, &session)) {
LOGE("CdmEngine::GenericEncrypt: session_id not found = %s ",
session_id.c_str());
@@ -1569,7 +1569,7 @@ CdmResponseType CdmEngine::GenericDecrypt(
LOGE("CdmEngine::GenericDecrypt: no out_buffer provided");
return PARAMETER_NULL;
}
shared_ptr<CdmSession> session;
std::shared_ptr<CdmSession> session;
if (!session_map_.FindSession(session_id, &session)) {
LOGE("CdmEngine::GenericDecrypt: session_id not found = %s ",
session_id.c_str());
@@ -1586,7 +1586,7 @@ CdmResponseType CdmEngine::GenericSign(
LOGE("CdmEngine::GenericSign: no signature buffer provided");
return PARAMETER_NULL;
}
shared_ptr<CdmSession> session;
std::shared_ptr<CdmSession> session;
if (!session_map_.FindSession(session_id, &session)) {
LOGE("CdmEngine::GenericSign: session_id not found = %s ",
session_id.c_str());
@@ -1599,7 +1599,7 @@ CdmResponseType CdmEngine::GenericVerify(
const std::string& session_id, const std::string& message,
const std::string& key_id, CdmSigningAlgorithm algorithm,
const std::string& signature) {
shared_ptr<CdmSession> session;
std::shared_ptr<CdmSession> session;
if (!session_map_.FindSession(session_id, &session)) {
LOGE("CdmEngine::GenericVerify: session_id not found = %s ",
session_id.c_str());
@@ -1660,7 +1660,7 @@ bool CdmEngine::FindSessionForKey(const KeyId& key_id,
bool CdmEngine::NotifyResolution(const CdmSessionId& session_id, uint32_t width,
uint32_t height) {
shared_ptr<CdmSession> session;
std::shared_ptr<CdmSession> session;
if (session_map_.FindSession(session_id, &session)) {
session->NotifyResolution(width, height);
return true;
@@ -1808,7 +1808,7 @@ void CdmEngine::DeleteAllUsageReportsUponFactoryReset() {
if (!file_system_->Exists(device_base_path_level1) &&
!file_system_->Exists(device_base_path_level3)) {
scoped_ptr<CryptoSession> crypto_session(
std::unique_ptr<CryptoSession> crypto_session(
CryptoSession::MakeCryptoSession(metrics_.GetCryptoMetrics()));
CdmResponseType status;
M_TIME(

6
libwvdrmengine/cdm/core/src/cdm_session_map.cpp
View File

@@ -29,7 +29,7 @@ void CdmSessionMap::Add(const std::string& id, CdmSession* session) {
}
bool CdmSessionMap::CloseSession(const std::string& id) {
shared_ptr<CdmSession> session;
std::shared_ptr<CdmSession> session;
if (!FindSessionNoLock(id, &session)) {
return false;
}
@@ -43,12 +43,12 @@ bool CdmSessionMap::Exists(const std::string& id) {
}
bool CdmSessionMap::FindSession(const CdmSessionId& id,
shared_ptr<CdmSession>* session) {
std::shared_ptr<CdmSession>* session) {
return FindSessionNoLock(id, session);
}
bool CdmSessionMap::FindSessionNoLock(const CdmSessionId& session_id,
shared_ptr<CdmSession>* session) {
std::shared_ptr<CdmSession>* session) {
CdmIdToSessionMap::iterator iter = sessions_.find(session_id);
if (iter == sessions_.end()) {
return false;

3
libwvdrmengine/cdm/core/src/crypto_session.cpp
View File

@@ -2577,7 +2577,8 @@ void CryptoSession::IncrementIV(uint64_t increase_by,
// The factory will either be set by WvCdmTestBase, or a default factory is
// created on the first call to MakeCryptoSession.
scoped_ptr<CryptoSessionFactory> CryptoSession::factory_(NULL);
std::unique_ptr<CryptoSessionFactory> CryptoSession::factory_ =
std::unique_ptr<CryptoSessionFactory>();
CryptoSession* CryptoSession::MakeCryptoSession(
metrics::CryptoMetrics* crypto_metrics) {

4
libwvdrmengine/cdm/core/src/oemcrypto_adapter_dynamic.cpp
View File

@@ -20,6 +20,7 @@
#include <iostream>
#include <map>
#include <memory>
#include <string>
#include "file_store.h"
@@ -28,7 +29,6 @@
#include "log.h"
#include "metrics_collections.h"
#include "properties.h"
#include "scoped_ptr.h"
#include "wv_cdm_constants.h"
using namespace wvoec3;
@@ -938,7 +938,7 @@ class Adapter {
}
};
static wvcdm::scoped_ptr<Adapter> gAdapter;
static std::unique_ptr<Adapter> gAdapter;
} // namespace
namespace wvcdm {

2
libwvdrmengine/cdm/core/src/properties.cpp
View File

@@ -16,7 +16,7 @@ bool Properties::oem_crypto_use_fifo_;
bool Properties::oem_crypto_use_userspace_buffers_;
bool Properties::provisioning_messages_are_binary_;
bool Properties::allow_service_certificate_requests_;
scoped_ptr<CdmClientPropertySetMap> Properties::session_property_set_;
std::unique_ptr<CdmClientPropertySetMap> Properties::session_property_set_;
bool Properties::AddSessionPropertySet(
const CdmSessionId& session_id, CdmClientPropertySet* property_set) {

8
libwvdrmengine/cdm/core/src/usage_table_header.cpp
View File

@@ -282,7 +282,7 @@ CdmResponseType UsageTableHeader::MoveEntry(
// crypto_session points to an object whose scope is this method or a test
// object whose scope is the lifetime of this class
scoped_ptr<CryptoSession> scoped_crypto_session;
std::unique_ptr<CryptoSession> scoped_crypto_session;
CryptoSession* crypto_session = test_crypto_session_.get();
if (crypto_session == NULL) {
scoped_crypto_session.reset((CryptoSession::MakeCryptoSession(metrics)));
@@ -476,7 +476,7 @@ CdmResponseType UsageTableHeader::Shrink(
// crypto_session points to an object whose scope is this method or a test
// object whose scope is the lifetime of this class
scoped_ptr<CryptoSession> scoped_crypto_session;
std::unique_ptr<CryptoSession> scoped_crypto_session;
CryptoSession* crypto_session = test_crypto_session_.get();
if (crypto_session == NULL) {
scoped_crypto_session.reset((CryptoSession::MakeCryptoSession(metrics)));
@@ -549,7 +549,7 @@ bool UsageTableHeader::UpgradeLicensesFromUsageTable(
if (provider_session_token.empty()) continue;
scoped_ptr<CryptoSession> crypto_session(
std::unique_ptr<CryptoSession> crypto_session(
CryptoSession::MakeCryptoSession(metrics));
CdmResponseType status = crypto_session->Open(requested_security_level_);
@@ -632,7 +632,7 @@ bool UsageTableHeader::UpgradeUsageInfoFromUsageTable(
continue;
}
scoped_ptr<CryptoSession> crypto_session(
std::unique_ptr<CryptoSession> crypto_session(
CryptoSession::MakeCryptoSession(metrics));
CdmResponseType status = crypto_session->Open(requested_security_level_);

1
libwvdrmengine/cdm/core/test/cdm_engine_test.cpp
View File

@@ -21,7 +21,6 @@
#include "metrics.pb.h"
#include "OEMCryptoCENC.h"
#include "properties.h"
#include "scoped_ptr.h"
#include "string_conversions.h"
#include "test_base.h"
#include "test_printers.h"

6
libwvdrmengine/cdm/core/test/cdm_session_unittest.cpp
View File

@@ -2,13 +2,15 @@
// source code may only be used and distributed under the Widevine Master
// License Agreement.
#include <memory>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include "cdm_session.h"
#include "crypto_key.h"
#include "metrics.pb.h"
#include "properties.h"
#include "scoped_ptr.h"
#include "service_certificate.h"
#include "string_conversions.h"
#include "test_base.h"
@@ -191,7 +193,7 @@ class CdmSessionTest : public WvCdmTestBase {
}
metrics::SessionMetrics metrics_;
scoped_ptr<CdmSession> cdm_session_;
std::unique_ptr<CdmSession> cdm_session_;
MockCdmLicense* license_parser_;
metrics::CryptoMetrics crypto_metrics_;
NiceMock<MockCryptoSession>* crypto_session_;

6
libwvdrmengine/cdm/core/test/crypto_session_unittest.cpp
View File

@@ -3,6 +3,7 @@
// License Agreement.
#include <arpa/inet.h>
#include <memory>
#include <string>
#include <gtest/gtest.h>
@@ -14,7 +15,6 @@
#include "log.h"
#include "metrics.pb.h"
#include "metrics_collections.h"
#include "scoped_ptr.h"
#include "test_base.h"
#include "test_printers.h"
#include "wv_cdm_types.h"
@@ -282,7 +282,7 @@ class CryptoSessionMetricsTest : public WvCdmTestBase {
TEST_F(CryptoSessionMetricsTest, OpenSessionValidMetrics) {
metrics::CryptoMetrics crypto_metrics;
scoped_ptr<CryptoSession> session(
std::unique_ptr<CryptoSession> session(
CryptoSession::MakeCryptoSession(&crypto_metrics));
session->Open(wvcdm::kLevelDefault);
// Exercise a method that will touch a metric.
@@ -340,7 +340,7 @@ TEST_F(CryptoSessionMetricsTest, OpenSessionValidMetrics) {
TEST_F(CryptoSessionMetricsTest, GetProvisioningTokenValidMetrics) {
metrics::CryptoMetrics crypto_metrics;
scoped_ptr<CryptoSession> session(
std::unique_ptr<CryptoSession> session(
CryptoSession::MakeCryptoSession(&crypto_metrics));
ASSERT_EQ(NO_ERROR, session->Open(wvcdm::kLevelDefault));

1
libwvdrmengine/cdm/core/test/generic_crypto_unittest.cpp
View File

@@ -20,7 +20,6 @@
#include "oemcrypto_session_tests_helper.h"
#include "oemcrypto_types.h"
#include "properties.h"
#include "scoped_ptr.h"
#include "string_conversions.h"
#include "test_base.h"
#include "test_printers.h"

6
libwvdrmengine/cdm/core/test/http_socket_test.cpp
View File

@@ -3,10 +3,12 @@
// License Agreement.
#include <errno.h>
#include <memory>
#include <gtest/gtest.h>
#include "http_socket.h"
#include "log.h"
#include "scoped_ptr.h"
#include "string_conversions.h"
#include "url_request.h"
@@ -90,7 +92,7 @@ class HttpSocketTest : public testing::Test {
return true;
}
scoped_ptr<HttpSocket> socket_;
std::unique_ptr<HttpSocket> socket_;
std::string domain_name_;
std::string resource_path_;
};

5
libwvdrmengine/cdm/core/test/policy_engine_constraints_unittest.cpp
View File

@@ -2,6 +2,8 @@
// source code may only be used and distributed under the Widevine Master
// License Agreement.
#include <memory>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
@@ -10,7 +12,6 @@
#include "metrics_collections.h"
#include "policy_engine.h"
#include "mock_clock.h"
#include "scoped_ptr.h"
#include "test_base.h"
#include "test_printers.h"
#include "wv_cdm_event_listener.h"
@@ -215,7 +216,7 @@ class PolicyEngineConstraintsTest : public WvCdmTestBase {
expected_has_new_usable_key));
}
scoped_ptr<PolicyEngine> policy_engine_;
std::unique_ptr<PolicyEngine> policy_engine_;
MockClock* mock_clock_;
int64_t current_time_;
metrics::CryptoMetrics dummy_metrics_;

4
libwvdrmengine/cdm/core/test/policy_engine_unittest.cpp
View File

@@ -5,6 +5,7 @@
#include <limits.h>
#include <algorithm>
#include <memory>
#include <sstream>
#include <gmock/gmock.h>
@@ -13,7 +14,6 @@
#include "license.h"
#include "mock_clock.h"
#include "policy_engine.h"
#include "scoped_ptr.h"
#include "test_base.h"
#include "test_printers.h"
#include "wv_cdm_event_listener.h"
@@ -185,7 +185,7 @@ class PolicyEngineTest : public WvCdmTestBase {
NiceMock<HdcpOnlyMockCryptoSession> crypto_session_;
StrictMock<MockCdmEventListener> mock_event_listener_;
MockClock* mock_clock_;
scoped_ptr<PolicyEngine> policy_engine_;
std::unique_ptr<PolicyEngine> policy_engine_;
License license_;
MockFunction<void(int i)> check_;
};

130
libwvdrmengine/cdm/core/test/shared_ptr_test.cpp
View File

@@ -1,130 +0,0 @@
// Copyright 2018 Google LLC. All Rights Reserved. This file and proprietary
// source code may only be used and distributed under the Widevine Master
// License Agreement.
#include <string>
#include <errno.h>
#include <getopt.h>
#include <gtest/gtest.h>
#include "shared_ptr.h"
#include "log.h"
namespace wvcdm {
class SharedPtrTest : public testing::Test {
public:
static void NoteDeletion() {
deletions++;
}
class Dummy {
public:
explicit Dummy(int v) : value_(v) { exists_ = true; }
~Dummy() {
NoteDeletion();
exists_ = false;
}
bool exists() { return exists_; }
int getValue() { return value_; }
void setValue(int v) { value_ = v; }
private:
bool exists_;
int value_;
};
static void ExpectedDeletions(int count) {
ASSERT_TRUE(deletions == count);
deletions = 0;
}
virtual void SetUpTest() {
deletions = 0;
}
virtual void TearDownTest() {
deletions = 0;
}
private:
static int deletions;
};
int SharedPtrTest::deletions = 0;
TEST_F(SharedPtrTest, NullSingletonCreate) {
shared_ptr<Dummy> sd1;
ASSERT_TRUE(sd1.unique());
ASSERT_TRUE(sd1.get() == NULL);
ExpectedDeletions(0);
}
TEST_F(SharedPtrTest, SingletonCreate) {
{
Dummy* d1 = new Dummy(42);
shared_ptr<Dummy> sd1(d1);
ASSERT_TRUE(sd1.unique());
ASSERT_TRUE(sd1.get() == d1);
ASSERT_TRUE(sd1->getValue() == 42);
}
ExpectedDeletions(1);
}
TEST_F(SharedPtrTest, ResetToNull) {
Dummy* d1 = new Dummy(42);
shared_ptr<Dummy> sd1(d1);
ASSERT_TRUE(sd1->getValue() == 42);
sd1.reset();
ExpectedDeletions(1);
ASSERT_TRUE(sd1.get() == NULL);
}
TEST_F(SharedPtrTest, SharedCreate) {
{
Dummy* d1 = new Dummy(42);
shared_ptr<Dummy> sd1(d1);
{
shared_ptr<Dummy> sd2(sd1);
ASSERT_FALSE(sd1.unique());
ASSERT_TRUE(sd1.get() == d1);
ASSERT_TRUE(sd2.get() == d1);
ASSERT_TRUE(sd1.use_count() == 2);
}
ExpectedDeletions(0);
ASSERT_TRUE(sd1.use_count() == 1);
}
ExpectedDeletions(1);
}
TEST_F(SharedPtrTest, SharedInstance) {
Dummy* d1 = new Dummy(42);
{
shared_ptr<Dummy> sd1(d1);
{
shared_ptr<Dummy> sd2(sd1);
ASSERT_FALSE(sd1.unique());
ASSERT_TRUE(sd1.get() == d1);
ASSERT_TRUE(sd2.get() == d1);
sd2->setValue(55);
ASSERT_TRUE(sd1.use_count() == 2);
}
ExpectedDeletions(0);
ASSERT_TRUE(sd1.use_count() == 1);
ASSERT_TRUE(sd1->getValue() == 55);
}
ExpectedDeletions(1);
}
TEST_F(SharedPtrTest, Reset) {
{
Dummy* d1 = new Dummy(42);
Dummy* d2 = new Dummy(96);
shared_ptr<Dummy> sd1(d1);
sd1.reset(d2);
ExpectedDeletions(1);
ASSERT_TRUE(sd1->getValue() == 96);
}
ExpectedDeletions(1);
}
} // namespace wvcdm

229
libwvdrmengine/cdm/include/UniquePtr.h
View File

@@ -1,229 +0,0 @@
/*
* Copyright (C) 2010 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef UNIQUE_PTR_H_included
#define UNIQUE_PTR_H_included
#include <cstdlib> // For NULL.
// Default deleter for pointer types.
template <typename T>
struct DefaultDelete {
enum { type_must_be_complete = sizeof(T) };
DefaultDelete() {}
void operator()(T* p) const {
delete p;
}
};
// Default deleter for array types.
template <typename T>
struct DefaultDelete<T[]> {
enum { type_must_be_complete = sizeof(T) };
void operator()(T* p) const {
delete[] p;
}
};
// A smart pointer that deletes the given pointer on destruction.
// Equivalent to C++0x's std::unique_ptr (a combination of boost::scoped_ptr
// and boost::scoped_array).
// Named to be in keeping with Android style but also to avoid
// collision with any other implementation, until we can switch over
// to unique_ptr.
// Use thus:
// UniquePtr<C> c(new C);
template <typename T, typename D = DefaultDelete<T> >
class UniquePtr {
public:
// Construct a new UniquePtr, taking ownership of the given raw pointer.
explicit UniquePtr(T* ptr = NULL) : mPtr(ptr) {
}
~UniquePtr() {
reset();
}
// Accessors.
T& operator*() const { return *mPtr; }
T* operator->() const { return mPtr; }
T* get() const { return mPtr; }
// Returns the raw pointer and hands over ownership to the caller.
// The pointer will not be deleted by UniquePtr.
T* release() __attribute__((warn_unused_result)) {
T* result = mPtr;
mPtr = NULL;
return result;
}
// Takes ownership of the given raw pointer.
// If this smart pointer previously owned a different raw pointer, that
// raw pointer will be freed.
void reset(T* ptr = NULL) {
if (ptr != mPtr) {
D()(mPtr);
mPtr = ptr;
}
}
private:
// The raw pointer.
T* mPtr;
// Comparing unique pointers is probably a mistake, since they're unique.
template <typename T2> bool operator==(const UniquePtr<T2>& p) const;
template <typename T2> bool operator!=(const UniquePtr<T2>& p) const;
UniquePtr(const UniquePtr&) = delete;
UniquePtr & operator=(const UniquePtr&) = delete;
};
// Partial specialization for array types. Like std::unique_ptr, this removes
// operator* and operator-> but adds operator[].
template <typename T, typename D>
class UniquePtr<T[], D> {
public:
explicit UniquePtr(T* ptr = NULL) : mPtr(ptr) {
}
~UniquePtr() {
reset();
}
T& operator[](size_t i) const {
return mPtr[i];
}
T* get() const { return mPtr; }
T* release() __attribute__((warn_unused_result)) {
T* result = mPtr;
mPtr = NULL;
return result;
}
void reset(T* ptr = NULL) {
if (ptr != mPtr) {
D()(mPtr);
mPtr = ptr;
}
}
private:
T* mPtr;
UniquePtr(const UniquePtr&) = delete;
UniquePtr & operator=(const UniquePtr&) = delete;
};
#if UNIQUE_PTR_TESTS
// Run these tests with:
// g++ -g -DUNIQUE_PTR_TESTS -x c++ UniquePtr.h && ./a.out
#include <stdio.h>
static void assert(bool b) {
if (!b) {
fprintf(stderr, "FAIL\n");
abort();
}
fprintf(stderr, "OK\n");
}
static int cCount = 0;
struct C {
C() { ++cCount; }
~C() { --cCount; }
};
static bool freed = false;
struct Freer {
void operator()(int* p) {
assert(*p == 123);
free(p);
freed = true;
}
};
int main(int argc, char* argv[]) {
//
// UniquePtr<T> tests...
//
// Can we free a single object?
{
UniquePtr<C> c(new C);
assert(cCount == 1);
}
assert(cCount == 0);
// Does release work?
C* rawC;
{
UniquePtr<C> c(new C);
assert(cCount == 1);
rawC = c.release();
}
assert(cCount == 1);
delete rawC;
// Does reset work?
{
UniquePtr<C> c(new C);
assert(cCount == 1);
c.reset(new C);
assert(cCount == 1);
}
assert(cCount == 0);
//
// UniquePtr<T[]> tests...
//
// Can we free an array?
{
UniquePtr<C[]> cs(new C[4]);
assert(cCount == 4);
}
assert(cCount == 0);
// Does release work?
{
UniquePtr<C[]> c(new C[4]);
assert(cCount == 4);
rawC = c.release();
}
assert(cCount == 4);
delete[] rawC;
// Does reset work?
{
UniquePtr<C[]> c(new C[4]);
assert(cCount == 4);
c.reset(new C[2]);
assert(cCount == 2);
}
assert(cCount == 0);
//
// Custom deleter tests...
//
assert(!freed);
{
UniquePtr<int, Freer> i(reinterpret_cast<int*>(malloc(sizeof(int))));
*i = 123;
}
assert(freed);
return 0;
}
#endif
#endif // UNIQUE_PTR_H_included

4
libwvdrmengine/cdm/include/wv_content_decryption_module.h
View File

@@ -6,8 +6,8 @@
#define CDM_BASE_WV_CONTENT_DECRYPTION_MODULE_H_
#include <map>
#include <memory>
#include <UniquePtr.h>
#include <utils/RefBase.h>
#include "cdm_identifier.h"
@@ -144,7 +144,7 @@ class WvContentDecryptionModule : public android::RefBase, public TimerHandler {
CdmInfo();
FileSystem file_system;
UniquePtr<CdmEngine> cdm_engine;
std::unique_ptr<CdmEngine> cdm_engine;
};
// Finds the CdmEngine instance for the given identifier, creating one if

1
libwvdrmengine/cdm/metrics/include/event_metric.h
View File

@@ -17,7 +17,6 @@
#include "log.h"
#include "metrics.pb.h"
#include "pow2bucket.h"
#include "shared_ptr.h"
namespace wvcdm {
namespace metrics {

1
libwvdrmengine/cdm/metrics/test/counter_metric_unittest.cpp
View File

@@ -6,7 +6,6 @@
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include "scoped_ptr.h"
#include "string_conversions.h"
using drm_metrics::TestMetrics;

1
libwvdrmengine/cdm/metrics/test/event_metric_unittest.cpp
View File

@@ -6,7 +6,6 @@
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include "scoped_ptr.h"
#include "string_conversions.h"
using drm_metrics::TestMetrics;

12
libwvdrmengine/cdm/metrics/test/value_metric_unittest.cpp
View File

@@ -2,6 +2,7 @@
//
// Unit tests for ValueMetric.
#include <memory>
#include <string>
#include "value_metric.h"
@@ -9,7 +10,6 @@
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include "metrics.pb.h"
#include "scoped_ptr.h"
namespace wvcdm {
namespace metrics {
@@ -18,7 +18,7 @@ TEST(ValueMetricTest, StringValue) {
ValueMetric<std::string> metric;
metric.Record("foo");
wvcdm::scoped_ptr<drm_metrics::ValueMetric> metric_proto(metric.ToProto());
std::unique_ptr<drm_metrics::ValueMetric> metric_proto(metric.ToProto());
ASSERT_EQ("foo", metric_proto->string_value());
ASSERT_FALSE(metric_proto->has_error_code());
}
@@ -27,7 +27,7 @@ TEST(ValueMetricTest, DoubleValue) {
ValueMetric<double> metric;
metric.Record(42.0);
wvcdm::scoped_ptr<drm_metrics::ValueMetric> metric_proto(metric.ToProto());
std::unique_ptr<drm_metrics::ValueMetric> metric_proto(metric.ToProto());
ASSERT_EQ(42.0, metric_proto->double_value());
ASSERT_FALSE(metric_proto->has_error_code());
}
@@ -36,7 +36,7 @@ TEST(ValueMetricTest, Int32Value) {
ValueMetric<int32_t> metric;
metric.Record(42);
wvcdm::scoped_ptr<drm_metrics::ValueMetric> metric_proto(metric.ToProto());
std::unique_ptr<drm_metrics::ValueMetric> metric_proto(metric.ToProto());
ASSERT_EQ(42, metric_proto->int_value());
ASSERT_FALSE(metric_proto->has_error_code());
}
@@ -45,7 +45,7 @@ TEST(ValueMetricTest, Int64Value) {
ValueMetric<int64_t> metric;
metric.Record(42);
wvcdm::scoped_ptr<drm_metrics::ValueMetric> metric_proto(metric.ToProto());
std::unique_ptr<drm_metrics::ValueMetric> metric_proto(metric.ToProto());
ASSERT_EQ(42, metric_proto->int_value());
ASSERT_FALSE(metric_proto->has_error_code());
}
@@ -55,7 +55,7 @@ TEST(ValueMetricTest, SetError) {
metric.Record(42);
metric.SetError(7);
wvcdm::scoped_ptr<drm_metrics::ValueMetric> metric_proto(metric.ToProto());
std::unique_ptr<drm_metrics::ValueMetric> metric_proto(metric.ToProto());
ASSERT_EQ(7, metric_proto->error_code());
ASSERT_FALSE(metric_proto->has_int_value());
}

4
libwvdrmengine/cdm/test/Android.mk
View File

@@ -107,10 +107,6 @@ test_name := service_certificate_unittest
test_src_dir := ../core/test
include $(LOCAL_PATH)/unit-test.mk
test_name := shared_ptr_test
test_src_dir := ../core/test
include $(LOCAL_PATH)/unit-test.mk
test_name := timer_unittest
test_src_dir := .
include $(LOCAL_PATH)/unit-test.mk