Refactor WvCdmEventListener and some cleanups

Bug: 19771437

It is a merge of below CLs from Widevine CDM repo:

Clean up CdmSession and PolicyEngine testing injection
https://widevine-internal-review.googlesource.com/#/c/13700

Refactor WvCdmEventListener handling
https://widevine-internal-review.googlesource.com/#/c/13702

Change-Id: I356b90000c056113d394926862b859aab380d305

libwvdrmengine/cdm/core/include/cdm_engine.h

@@ -32,11 +32,13 @@ class CdmEngine {
   // Session related methods
   virtual CdmResponseType OpenSession(const CdmKeySystem& key_system,
                                       const CdmClientPropertySet* property_set,
+                                      WvCdmEventListener* event_listener,
                                       CdmSessionId* session_id);
   virtual CdmResponseType CloseSession(const CdmSessionId& session_id);
 
   virtual CdmResponseType OpenKeySetSession(
-      const CdmKeySetId& key_set_id, const CdmClientPropertySet* property_set);
+      const CdmKeySetId& key_set_id, const CdmClientPropertySet* property_set,
+      WvCdmEventListener* event_listener);
   virtual CdmResponseType CloseKeySetSession(const CdmKeySetId& key_set_id);
 
   // License related methods
@@ -138,25 +140,17 @@ class CdmEngine {
   virtual bool IsKeyLoaded(const KeyId& key_id);
   virtual bool FindSessionForKey(const KeyId& key_id, CdmSessionId* sessionId);
 
-  // Event listener related methods.
-
-  // We assume that the WvCdmEventListener is asynchronous -- i.e. an event
-  // should be dispatched to another thread which actually does the work. In
-  // particular, if a synchronous listener calls OpenSession or CloseSession,
-  // the thread will dead lock.
-  // Returns false if listener already attached.
-  virtual bool AttachEventListener(const CdmSessionId& session_id,
-                                   WvCdmEventListener* listener);
-  // Returns true if listener was detached.
-  virtual bool DetachEventListener(const CdmSessionId& session_id,
-                                   WvCdmEventListener* listener);
-
   // Used for notifying the Max-Res Engine of resolution changes
   virtual void NotifyResolution(const CdmSessionId& session_id, uint32_t width,
                                 uint32_t height);
 
   // Timer expiration method. This method is not re-entrant -- there can be
   // only one timer.
+  // This method triggers appropriate event callbacks from |event_listener_|,
+  // which is assumed to be asynchronous -- i.e. an event should be dispatched
+  // to another thread which does the actual work. In particular, if a
+  // synchronous listener calls OpenSession or CloseSession, the thread will
+  // dead lock.
   virtual void OnTimerEvent();
 
  private:

libwvdrmengine/cdm/core/include/cdm_session.h

@@ -21,7 +21,8 @@ class WvCdmEventListener;
 
 class CdmSession {
  public:
-  explicit CdmSession(const CdmClientPropertySet* cdm_client_property_set);
+  CdmSession(const CdmClientPropertySet* cdm_client_property_set,
+             WvCdmEventListener* event_listener);
   virtual ~CdmSession();
 
   virtual CdmResponseType Init();
@@ -74,10 +75,6 @@ class CdmSession {
 
   virtual bool IsKeyLoaded(const KeyId& key_id);
 
-  // See comments for CdmEngine::AttachEventListener/DetachEventListener.
-  virtual bool AttachEventListener(WvCdmEventListener* listener);
-  virtual bool DetachEventListener(WvCdmEventListener* listener);
-
   // Used for notifying the Policy Engine of resolution changes
   virtual void NotifyResolution(uint32_t width, uint32_t height);
 
@@ -112,10 +109,7 @@ class CdmSession {
   bool DeleteLicense();
 
  private:
-  // Internal constructor
-  void Create(CdmLicense* license_parser, CryptoSession* crypto_session,
-              PolicyEngine* policy_engine, DeviceFiles* file_handle,
-              const CdmClientPropertySet* cdm_client_property_set);
+  friend class CdmSessionTest;
 
   // Generate unique ID for each new session.
   CdmSessionId GenerateSessionId();
@@ -123,9 +117,17 @@ class CdmSession {
 
   CdmResponseType StoreLicense();
   bool StoreLicense(DeviceFiles::LicenseState state);
+
+  // These setters are for testing only. Takes ownership of the pointers.
+  void set_license_parser(CdmLicense* license_parser);
+  void set_crypto_session(CryptoSession* crypto_session);
+  void set_policy_engine(PolicyEngine* policy_engine);
+  void set_file_handle(DeviceFiles* file_handle);
+
   // instance variables
   bool initialized_;
   CdmSessionId session_id_;
+  WvCdmEventListener* event_listener_;
   scoped_ptr<CdmLicense> license_parser_;
   scoped_ptr<CryptoSession> crypto_session_;
   scoped_ptr<PolicyEngine> policy_engine_;
@@ -156,18 +158,6 @@ class CdmSession {
   // license type release and offline related information
   CdmKeySetId key_set_id_;
 
-  std::set<WvCdmEventListener*> listeners_;
-
-  // For testing only
-  // Takes ownership of license_parser, crypto_session, policy_engine
-  // and device_files
-  CdmSession(CdmLicense* license_parser, CryptoSession* crypto_session,
-             PolicyEngine* policy_engine, DeviceFiles* file_handle,
-             const CdmClientPropertySet* cdm_client_property_set);
-#if defined(UNIT_TEST)
-  friend class CdmSessionTest;
-#endif
-
   CORE_DISALLOW_COPY_AND_ASSIGN(CdmSession);
 };
 

libwvdrmengine/cdm/core/include/policy_engine.h

@@ -7,6 +7,7 @@
 
 #include "license_protocol.pb.h"
 #include "max_res_engine.h"
+#include "scoped_ptr.h"
 #include "wv_cdm_types.h"
 
 namespace wvcdm {
@@ -15,7 +16,6 @@ using video_widevine_server::sdk::LicenseIdentification;
 
 class Clock;
 class CryptoSession;
-class PolicyEngineTest;
 
 // This acts as an oracle that basically says "Yes(true) you may still decrypt
 // or no(false) you may not decrypt this data anymore."
@@ -78,6 +78,8 @@ class PolicyEngine {
   bool IsLicenseForFuture() { return license_state_ == kLicenseStatePending; }
 
  private:
+  friend class PolicyEngineTest;
+
   typedef enum {
     kLicenseStateInitial,
     kLicenseStatePending,  // if license is issued for sometime in the future
@@ -87,8 +89,6 @@ class PolicyEngine {
     kLicenseStateExpired
   } LicenseState;
 
-  void Init(Clock* clock);
-
   int64_t GetLicenseDurationRemaining(int64_t current_time);
   int64_t GetPlaybackDurationRemaining(int64_t current_time);
 
@@ -98,6 +98,9 @@ class PolicyEngine {
 
   void UpdateRenewalRequest(int64_t current_time);
 
+  // These setters are for testing only. Takes ownership of the pointers.
+  void set_clock(Clock* clock);
+
   LicenseState license_state_;
   bool can_decrypt_;
 
@@ -124,11 +127,7 @@ class PolicyEngine {
   int64_t policy_max_duration_seconds_;
 
   MaxResEngine max_res_engine_;
-  Clock* clock_;
-
-  // For testing
-  friend class PolicyEngineTest;
-  PolicyEngine(CryptoSession* crypto_session, Clock* clock);
+  scoped_ptr<Clock> clock_;
 
   CORE_DISALLOW_COPY_AND_ASSIGN(PolicyEngine);
 };

libwvdrmengine/cdm/core/include/wv_cdm_event_listener.h

@@ -8,9 +8,6 @@
 namespace wvcdm {
 
 // Listener for events from the Content Decryption Module.
-// The caller of the CDM API must provide an implementation for OnEvent
-// and signal its intent by using the Attach/DetachEventListener methods
-// in the WvContentDecryptionModule class.
 class WvCdmEventListener {
  public:
   WvCdmEventListener() {}

libwvdrmengine/cdm/core/src/cdm_engine.cpp

@@ -76,6 +76,7 @@ CdmEngine::~CdmEngine() {
 
 CdmResponseType CdmEngine::OpenSession(const CdmKeySystem& key_system,
                                        const CdmClientPropertySet* property_set,
+                                       WvCdmEventListener* event_listener,
                                        CdmSessionId* session_id) {
   LOGI("CdmEngine::OpenSession");
 
@@ -89,7 +90,8 @@ CdmResponseType CdmEngine::OpenSession(const CdmKeySystem& key_system,
     return KEY_ERROR;
   }
 
-  scoped_ptr<CdmSession> new_session(new CdmSession(property_set));
+  scoped_ptr<CdmSession> new_session(
+      new CdmSession(property_set, event_listener));
   if (new_session->session_id().empty()) {
     LOGE("CdmEngine::OpenSession: failure to generate session ID");
     return UNKNOWN_ERROR;
@@ -112,7 +114,8 @@ CdmResponseType CdmEngine::OpenSession(const CdmKeySystem& key_system,
 }
 
 CdmResponseType CdmEngine::OpenKeySetSession(
-    const CdmKeySetId& key_set_id, const CdmClientPropertySet* property_set) {
+    const CdmKeySetId& key_set_id, const CdmClientPropertySet* property_set,
+    WvCdmEventListener* event_listener) {
   LOGI("CdmEngine::OpenKeySetSession");
 
   if (key_set_id.empty()) {
@@ -121,7 +124,8 @@ CdmResponseType CdmEngine::OpenKeySetSession(
   }
 
   CdmSessionId session_id;
-  CdmResponseType sts = OpenSession(KEY_SYSTEM, property_set, &session_id);
+  CdmResponseType sts =
+      OpenSession(KEY_SYSTEM, property_set, event_listener, &session_id);
 
   if (sts != NO_ERROR) return sts;
 
@@ -587,7 +591,7 @@ CdmResponseType CdmEngine::GetUsageInfo(const std::string& app_id,
   }
   usage_property_set_->set_security_level(kLevelDefault);
   usage_property_set_->set_app_id(app_id);
-  usage_session_.reset(new CdmSession(usage_property_set_.get()));
+  usage_session_.reset(new CdmSession(usage_property_set_.get(), NULL));
   CdmResponseType status = usage_session_->Init();
   if (NO_ERROR != status) {
     LOGE("CdmEngine::GetUsageInfo: session init error");
@@ -605,7 +609,7 @@ CdmResponseType CdmEngine::GetUsageInfo(const std::string& app_id,
                                 &license_response)) {
     usage_property_set_->set_security_level(kLevel3);
     usage_property_set_->set_app_id(app_id);
-    usage_session_.reset(new CdmSession(usage_property_set_.get()));
+    usage_session_.reset(new CdmSession(usage_property_set_.get(), NULL));
     status = usage_session_->Init();
     if (NO_ERROR != status) {
       LOGE("CdmEngine::GetUsageInfo: session init error");
@@ -673,7 +677,7 @@ CdmResponseType CdmEngine::GetUsageInfo(const std::string& app_id,
   usage_property_set_->set_security_level(requested_security_level);
   usage_property_set_->set_app_id(app_id);
 
-  usage_session_.reset(new CdmSession(usage_property_set_.get()));
+  usage_session_.reset(new CdmSession(usage_property_set_.get(), NULL));
 
   CdmResponseType status = usage_session_->Init();
   if (NO_ERROR != status) {
@@ -856,26 +860,6 @@ bool CdmEngine::FindSessionForKey(const KeyId& key_id,
   return false;
 }
 
-bool CdmEngine::AttachEventListener(const CdmSessionId& session_id,
-                                    WvCdmEventListener* listener) {
-  CdmSessionMap::iterator iter = sessions_.find(session_id);
-  if (iter == sessions_.end()) {
-    return false;
-  }
-
-  return iter->second->AttachEventListener(listener);
-}
-
-bool CdmEngine::DetachEventListener(const CdmSessionId& session_id,
-                                    WvCdmEventListener* listener) {
-  CdmSessionMap::iterator iter = sessions_.find(session_id);
-  if (iter == sessions_.end()) {
-    return false;
-  }
-
-  return iter->second->DetachEventListener(listener);
-}
-
 void CdmEngine::NotifyResolution(const CdmSessionId& session_id, uint32_t width,
                                  uint32_t height) {
   CdmSessionMap::iterator iter = sessions_.find(session_id);

libwvdrmengine/cdm/core/src/cdm_session.cpp

@@ -23,68 +23,32 @@ const size_t kKeySetIdLength = 14;
 
 namespace wvcdm {
 
-typedef std::set<WvCdmEventListener*>::iterator CdmEventListenerIter;
-
-CdmSession::CdmSession(const CdmClientPropertySet* cdm_client_property_set) {
-  CryptoSession* crypto_session = new CryptoSession();
-  Create(new CdmLicense(), crypto_session, new PolicyEngine(crypto_session),
-         new DeviceFiles(), cdm_client_property_set);
-}
-
-CdmSession::CdmSession(CdmLicense* license_parser,
-                       CryptoSession* crypto_session,
-                       PolicyEngine* policy_engine, DeviceFiles* file_handle,
-                       const CdmClientPropertySet* cdm_client_property_set) {
-  Create(license_parser, crypto_session, policy_engine, file_handle,
-         cdm_client_property_set);
-}
-
-void CdmSession::Create(CdmLicense* license_parser,
-                        CryptoSession* crypto_session,
-                        PolicyEngine* policy_engine, DeviceFiles* file_handle,
-                        const CdmClientPropertySet* cdm_client_property_set) {
-  // Just return on failures. Failures will be signaled in Init.
-  if (NULL == license_parser) {
-    LOGE("CdmSession::Create: License parser not provided");
-    return;
-  }
-  if (NULL == crypto_session) {
-    LOGE("CdmSession::Create: Crypto session not provided");
-    return;
-  }
-  if (NULL == policy_engine) {
-    LOGE("CdmSession::Create: Policy engine not provided");
-    return;
-  }
-  if (NULL == file_handle) {
-    LOGE("CdmSession::Create: Device files not provided");
-    return;
-  }
-  initialized_ = false;
-  session_id_ = GenerateSessionId();
-  license_parser_.reset(license_parser);
-  crypto_session_.reset(crypto_session);
-  file_handle_.reset(file_handle);
-  policy_engine_.reset(policy_engine);
-  license_received_ = false;
-  is_offline_ = false;
-  is_release_ = false;
-  is_initial_usage_update_ = true;
-  is_usage_update_needed_ = false;
-  is_initial_decryption_ = true;
-  has_decrypted_since_last_report_ = false;
-  requested_security_level_ = kLevelDefault;
-  if (NULL != cdm_client_property_set) {
-    if (QUERY_VALUE_SECURITY_LEVEL_L3.compare(
-            cdm_client_property_set->security_level()) == 0) {
+CdmSession::CdmSession(const CdmClientPropertySet* cdm_client_property_set,
+                       WvCdmEventListener* event_listener)
+    : initialized_(false),
+      session_id_(GenerateSessionId()),
+      event_listener_(event_listener),
+      license_parser_(new CdmLicense),
+      crypto_session_(new CryptoSession),
+      policy_engine_(new PolicyEngine(crypto_session_.get())),
+      file_handle_(new DeviceFiles),
+      license_received_(false),
+      is_offline_(false),
+      is_release_(false),
+      security_level_(kSecurityLevelUninitialized),
+      requested_security_level_(kLevelDefault),
+      is_initial_decryption_(true),
+      has_decrypted_since_last_report_(false),
+      is_initial_usage_update_(true),
+      is_usage_update_needed_(false) {
+  if (cdm_client_property_set) {
+    if (cdm_client_property_set->security_level() ==
+        QUERY_VALUE_SECURITY_LEVEL_L3) {
       requested_security_level_ = kLevel3;
+      security_level_ = kSecurityLevelL3;
     }
     Properties::AddSessionPropertySet(session_id_, cdm_client_property_set);
   }
-  security_level_ =
-      GetRequestedSecurityLevel() == kLevel3 ? kSecurityLevelL3
-                                             : kSecurityLevelUninitialized;
-  app_id_.clear();
 }
 
 CdmSession::~CdmSession() { Properties::RemoveSessionPropertySet(session_id_); }
@@ -546,15 +510,6 @@ bool CdmSession::DeleteLicense() {
   }
 }
 
-bool CdmSession::AttachEventListener(WvCdmEventListener* listener) {
-  std::pair<CdmEventListenerIter, bool> result = listeners_.insert(listener);
-  return result.second;
-}
-
-bool CdmSession::DetachEventListener(WvCdmEventListener* listener) {
-  return (listeners_.erase(listener) == 1);
-}
-
 void CdmSession::NotifyResolution(uint32_t width, uint32_t height) {
   policy_engine_->NotifyResolution(width, height);
 }
@@ -573,19 +528,14 @@ void CdmSession::OnTimerEvent(bool update_usage) {
   policy_engine_->OnTimerEvent(&event_occurred, &event);
 
   if (event_occurred) {
-    for (CdmEventListenerIter iter = listeners_.begin();
-         iter != listeners_.end(); ++iter) {
-      (*iter)->OnEvent(session_id_, event);
-    }
+    if (event_listener_) event_listener_->OnEvent(session_id_, event);
   }
 }
 
 void CdmSession::OnKeyReleaseEvent(const CdmKeySetId& key_set_id) {
   if (key_set_id_ == key_set_id) {
-    for (CdmEventListenerIter iter = listeners_.begin();
-         iter != listeners_.end(); ++iter) {
-      (*iter)->OnEvent(session_id_, LICENSE_EXPIRED_EVENT);
-    }
+    if (event_listener_)
+      event_listener_->OnEvent(session_id_, LICENSE_EXPIRED_EVENT);
   }
 }
 
@@ -610,4 +560,20 @@ CdmResponseType CdmSession::ReleaseCrypto() {
   return NO_ERROR;
 }
 
+void CdmSession::set_license_parser(CdmLicense* license_parser) {
+  license_parser_.reset(license_parser);
+}
+
+void CdmSession::set_crypto_session(CryptoSession* crypto_session) {
+  crypto_session_.reset(crypto_session);
+}
+
+void CdmSession::set_policy_engine(PolicyEngine* policy_engine) {
+  policy_engine_.reset(policy_engine);
+}
+
+void CdmSession::set_file_handle(DeviceFiles* file_handle) {
+  file_handle_.reset(file_handle);
+}
+
 }  // namespace wvcdm

libwvdrmengine/cdm/core/src/policy_engine.cpp

@@ -17,29 +17,17 @@
 namespace wvcdm {
 
 PolicyEngine::PolicyEngine(CryptoSession* crypto_session)
-    : max_res_engine_(crypto_session) {
-  Init(new Clock());
-}
+    : license_state_(kLicenseStateInitial),
+      can_decrypt_(false),
+      license_start_time_(0),
+      playback_start_time_(0),
+      last_playback_time_(0),
+      next_renewal_time_(0),
+      policy_max_duration_seconds_(0),
+      max_res_engine_(crypto_session),
+      clock_(new Clock) {}
 
-PolicyEngine::PolicyEngine(CryptoSession* crypto_session, Clock* clock)
-    : max_res_engine_(crypto_session) {
-  Init(clock);
-}
-
-PolicyEngine::~PolicyEngine() {
-  if (clock_) delete clock_;
-}
-
-void PolicyEngine::Init(Clock* clock) {
-  license_state_ = kLicenseStateInitial;
-  can_decrypt_ = false;
-  license_start_time_ = 0;
-  playback_start_time_ = 0;
-  last_playback_time_ = 0;
-  next_renewal_time_ = 0;
-  policy_max_duration_seconds_ = 0;
-  clock_ = clock;
-}
+PolicyEngine::~PolicyEngine() {}
 
 bool PolicyEngine::CanDecrypt(const KeyId& key_id) {
   return can_decrypt_ && max_res_engine_.CanDecrypt(key_id);
@@ -316,4 +304,6 @@ bool PolicyEngine::IsRenewalRetryIntervalExpired(int64_t current_time) {
          next_renewal_time_ <= current_time;
 }
 
+void PolicyEngine::set_clock(Clock* clock) { clock_.reset(clock); }
+
 }  // wvcdm

libwvdrmengine/cdm/core/test/cdm_engine_test.cpp

@@ -47,10 +47,10 @@ class WvCdmEngineTest : public testing::Test {
  public:
   virtual void SetUp() {
     CdmResponseType status =
-        cdm_engine_.OpenSession(g_key_system, NULL, &session_id_);
+        cdm_engine_.OpenSession(g_key_system, NULL, NULL, &session_id_);
     if (status == NEED_PROVISIONING) {
       Provision();
-      status = cdm_engine_.OpenSession(g_key_system, NULL, &session_id_);
+      status = cdm_engine_.OpenSession(g_key_system, NULL, NULL, &session_id_);
     }
     ASSERT_EQ(NO_ERROR, status);
     ASSERT_NE("", session_id_) << "Could not open CDM session.";

libwvdrmengine/cdm/core/test/cdm_session_unittest.cpp

@@ -5,6 +5,7 @@
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include "properties.h"
+#include "scoped_ptr.h"
 #include "string_conversions.h"
 #include "test_printers.h"
 
@@ -126,25 +127,19 @@ class MockCdmLicense : public CdmLicense {
 class CdmSessionTest : public ::testing::Test {
  protected:
   virtual void SetUp() {
+    cdm_session_.reset(new CdmSession(NULL, NULL));
+    // Inject testing mocks.
     license_parser_ = new MockCdmLicense();
+    cdm_session_->set_license_parser(license_parser_);
     crypto_session_ = new MockCryptoSession();
+    cdm_session_->set_crypto_session(crypto_session_);
     policy_engine_ = new MockPolicyEngine();
+    cdm_session_->set_policy_engine(policy_engine_);
     file_handle_ = new MockDeviceFiles();
+    cdm_session_->set_file_handle(file_handle_);
   }
 
-  virtual void TearDown() {
-    if (cdm_session_) delete cdm_session_;
-  }
-
-  void CreateSession() { CreateSession(NULL); }
-
-  void CreateSession(const CdmClientPropertySet* cdm_client_property_set) {
-    cdm_session_ =
-        new CdmSession(license_parser_, crypto_session_, policy_engine_,
-                       file_handle_, cdm_client_property_set);
-  }
-
-  CdmSession* cdm_session_;
+  scoped_ptr<CdmSession> cdm_session_;
   MockCdmLicense* license_parser_;
   MockCryptoSession* crypto_session_;
   MockPolicyEngine* policy_engine_;
@@ -173,7 +168,6 @@ TEST_F(CdmSessionTest, InitWithCertificate) {
 
   Properties::set_use_certificates_as_identification(true);
 
-  CreateSession();
   ASSERT_EQ(NO_ERROR, cdm_session_->Init());
 }
 
@@ -195,7 +189,6 @@ TEST_F(CdmSessionTest, InitWithKeybox) {
 
   Properties::set_use_certificates_as_identification(false);
 
-  CreateSession();
   ASSERT_EQ(NO_ERROR, cdm_session_->Init());
 }
 
@@ -221,7 +214,6 @@ TEST_F(CdmSessionTest, ReInitFail) {
 
   Properties::set_use_certificates_as_identification(true);
 
-  CreateSession();
   ASSERT_EQ(NO_ERROR, cdm_session_->Init());
   ASSERT_EQ(UNKNOWN_ERROR, cdm_session_->Init());
 }
@@ -233,7 +225,6 @@ TEST_F(CdmSessionTest, InitFailCryptoError) {
 
   Properties::set_use_certificates_as_identification(true);
 
-  CreateSession();
   ASSERT_EQ(UNKNOWN_ERROR, cdm_session_->Init());
 }
 
@@ -252,7 +243,6 @@ TEST_F(CdmSessionTest, InitNeedsProvisioning) {
 
   Properties::set_use_certificates_as_identification(true);
 
-  CreateSession();
   ASSERT_EQ(NEED_PROVISIONING, cdm_session_->Init());
 }
 

libwvdrmengine/cdm/core/test/policy_engine_unittest.cpp

@@ -10,6 +10,7 @@
 #include "license.h"
 #include "mock_clock.h"
 #include "policy_engine.h"
+#include "scoped_ptr.h"
 #include "test_printers.h"
 #include "wv_cdm_constants.h"
 
@@ -58,8 +59,10 @@ using ::testing::AtLeast;
 class PolicyEngineTest : public ::testing::Test {
  protected:
   virtual void SetUp() {
+    policy_engine_.reset(new PolicyEngine(NULL));
+    // Inject testing clock.
     mock_clock_ = new MockClock();
-    policy_engine_ = new PolicyEngine(NULL, mock_clock_);
+    policy_engine_->set_clock(mock_clock_);
 
     license_.set_license_start_time(kLicenseStartTime);
 
@@ -85,13 +88,6 @@ class PolicyEngineTest : public ::testing::Test {
     policy->set_renew_with_usage(false);
   }
 
-  virtual void TearDown() {
-    delete policy_engine_;
-    // Done by policy engine: delete mock_clock_;
-    policy_engine_ = NULL;
-    mock_clock_ = NULL;
-  }
-
   int64_t GetMinOfRentalPlaybackLicenseDurations() {
     const License_Policy& policy = license_.policy();
     int64_t rental_duration = policy.rental_duration_seconds();
@@ -105,7 +101,7 @@ class PolicyEngineTest : public ::testing::Test {
   }
 
   MockClock* mock_clock_;
-  PolicyEngine* policy_engine_;
+  scoped_ptr<PolicyEngine> policy_engine_;
   License license_;
 };