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

Replace scoped_ptr With std::unique_ptr

Browse Source 
(This is a merge of http://go/wvgerrit/65782)

We have had our own scoped_ptr implementation that is used throughout
the codebase. Now that we support C++11, we can replace these with
std::unique_ptr.

Doing this replacement exposed a few places where the two were not
interchangeable. OEMCrypto Ref was doing some unsafe things with passing
scoped_ptrs to functions and has been updated to use move semantics. And
a few constructors were explicitly constructing a scoped_ptr with NULL,
which is ambiguous with std::unique_ptr. These have been replaced with
default constructor calls.

Bug: 111851141
Test: CE CDM Unit Tests
Test: Android Unit Tests
Change-Id: I37d6d7aad4906709381c74f0c5439f826d2be768
This commit is contained in:
John W. Bruce
2018-11-14 10:49:53 -08:00
parent fb4d53bae6
commit b182a7445e
35 changed files with 100 additions and 208 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_;

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);
};

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)

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.

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);
};

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);
};

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

@@ -60,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_) {
@@ -126,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);
@@ -491,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(
@@ -833,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(
@@ -889,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(
@@ -923,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(
@@ -1006,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);
@@ -1215,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);
@@ -1369,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
@@ -1807,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(

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_;
};