diff --git a/libwvdrmengine/cdm/test/cdm_extended_duration_test.cpp b/libwvdrmengine/cdm/test/cdm_extended_duration_test.cpp
index 336290c3..49b30c65 100644
--- a/libwvdrmengine/cdm/test/cdm_extended_duration_test.cpp
+++ b/libwvdrmengine/cdm/test/cdm_extended_duration_test.cpp
@@ -249,7 +249,8 @@ class TestWvCdmClientPropertySet : public CdmClientPropertySet {
 
 class WvCdmExtendedDurationTest : public WvCdmTestBase {
  public:
-  WvCdmExtendedDurationTest() {}
+  WvCdmExtendedDurationTest()
+      : decryptor_(new wvcdm::WvContentDecryptionModule()) {}
   ~WvCdmExtendedDurationTest() {}
 
  protected:
@@ -276,7 +277,7 @@ class WvCdmExtendedDurationTest : public WvCdmTestBase {
     CdmAppParameterMap app_parameters;
     CdmKeyRequest key_request;
 
-    *response = decryptor_.GenerateKeyRequest(
+    *response = decryptor_->GenerateKeyRequest(
                     session_id_, key_set_id_, "video/mp4", init_data,
                     license_type, app_parameters, NULL,
                     kDefaultCdmIdentifier, &key_request);
@@ -296,7 +297,7 @@ class WvCdmExtendedDurationTest : public WvCdmTestBase {
 
     CdmKeyRequest key_request;
 
-    EXPECT_EQ(KEY_MESSAGE, decryptor_.GenerateKeyRequest(
+    EXPECT_EQ(KEY_MESSAGE, decryptor_->GenerateKeyRequest(
                                session_id_, key_set_id_, "video/mp4", init_data,
                                license_type, app_parameters, NULL,
                                kDefaultCdmIdentifier, &key_request));
@@ -316,7 +317,7 @@ class WvCdmExtendedDurationTest : public WvCdmTestBase {
     CdmAppParameterMap app_parameters;
     CdmKeyRequest key_request;
 
-    EXPECT_EQ(expected_response, decryptor_.GenerateKeyRequest(
+    EXPECT_EQ(expected_response, decryptor_->GenerateKeyRequest(
                                session_id, key_set_id, "video/mp4", init_data,
                                kLicenseTypeRelease, app_parameters, NULL,
                                kDefaultCdmIdentifier, &key_request));
@@ -422,7 +423,7 @@ class WvCdmExtendedDurationTest : public WvCdmTestBase {
                                 CdmResponseType* status) {
     std::string resp = GetKeyRequestResponse(server_url, client_auth);
     CdmResponseType sts =
-        decryptor_.AddKey(session_id_, resp, &key_set_id_);
+        decryptor_->AddKey(session_id_, resp, &key_set_id_);
 
     if (status == NULL) {
       EXPECT_EQ(KEY_ADDED, sts);
@@ -433,17 +434,17 @@ class WvCdmExtendedDurationTest : public WvCdmTestBase {
 
   void Unprovision() {
     EXPECT_EQ(NO_ERROR,
-              decryptor_.Unprovision(kSecurityLevelL1, kDefaultCdmIdentifier));
+              decryptor_->Unprovision(kSecurityLevelL1, kDefaultCdmIdentifier));
     EXPECT_EQ(NO_ERROR,
-              decryptor_.Unprovision(kSecurityLevelL3, kDefaultCdmIdentifier));
+              decryptor_->Unprovision(kSecurityLevelL3, kDefaultCdmIdentifier));
   }
 
   void Provision() {
-    CdmResponseType status = decryptor_.OpenSession(
+    CdmResponseType status = decryptor_->OpenSession(
         config_.key_system(), NULL, kDefaultCdmIdentifier, NULL, &session_id_);
     switch (status) {
       case NO_ERROR:
-        decryptor_.CloseSession(session_id_);
+        decryptor_->CloseSession(session_id_);
         return;
       case NEED_PROVISIONING:
         break;
@@ -456,7 +457,7 @@ class WvCdmExtendedDurationTest : public WvCdmTestBase {
     CdmCertificateType cert_type = kCertificateWidevine;
     std::string cert_authority, cert, wrapped_key;
 
-    status = decryptor_.GetProvisioningRequest(
+    status = decryptor_->GetProvisioningRequest(
         cert_type, cert_authority, kDefaultCdmIdentifier,
         kEmptyServiceCertificate, &key_msg_, &provisioning_server_url);
     EXPECT_EQ(NO_ERROR, status);
@@ -467,11 +468,11 @@ class WvCdmExtendedDurationTest : public WvCdmTestBase {
         GetCertRequestResponse(config_.provisioning_server());
     EXPECT_NE(0, static_cast<int>(response.size()));
     EXPECT_EQ(NO_ERROR,
-        decryptor_.HandleProvisioningResponse(kDefaultCdmIdentifier, response,
+        decryptor_->HandleProvisioningResponse(kDefaultCdmIdentifier, response,
                                               &cert, &wrapped_key));
     EXPECT_EQ(0, static_cast<int>(cert.size()));
     EXPECT_EQ(0, static_cast<int>(wrapped_key.size()));
-    decryptor_.CloseSession(session_id_);
+    decryptor_->CloseSession(session_id_);
     return;
   }
 
@@ -642,7 +643,7 @@ class WvCdmExtendedDurationTest : public WvCdmTestBase {
                       int64_t* license_duration_remaining,
                       int64_t* playback_duration_remaining) {
     CdmQueryMap query_info;
-    EXPECT_EQ(NO_ERROR, decryptor_.QueryKeyStatus(session_id_, &query_info));
+    EXPECT_EQ(NO_ERROR, decryptor_->QueryKeyStatus(session_id_, &query_info));
 
     EXPECT_THAT(query_info, Contains(Pair(QUERY_KEY_LICENSE_TYPE,
                                           streaming ? QUERY_VALUE_STREAMING
@@ -670,7 +671,7 @@ class WvCdmExtendedDurationTest : public WvCdmTestBase {
   uint32_t QueryStatus(SecurityLevel security_level, const std::string& key) {
     std::string str;
     EXPECT_EQ(wvcdm::NO_ERROR,
-              decryptor_.QueryStatus(security_level, key, &str));
+              decryptor_->QueryStatus(security_level, key, &str));
 
     std::istringstream ss(str);
     uint32_t value;
@@ -681,14 +682,14 @@ class WvCdmExtendedDurationTest : public WvCdmTestBase {
   }
 
   std::string GetSecurityLevel(TestWvCdmClientPropertySet* property_set) {
-    decryptor_.OpenSession(config_.key_system(), property_set,
-                           kDefaultCdmIdentifier, NULL, &session_id_);
+    decryptor_->OpenSession(config_.key_system(), property_set,
+                            kDefaultCdmIdentifier, NULL, &session_id_);
     CdmQueryMap query_info;
     EXPECT_EQ(NO_ERROR,
-              decryptor_.QuerySessionStatus(session_id_, &query_info));
+              decryptor_->QuerySessionStatus(session_id_, &query_info));
     CdmQueryMap::iterator itr = query_info.find(QUERY_KEY_SECURITY_LEVEL);
     EXPECT_TRUE(itr != query_info.end());
-    decryptor_.CloseSession(session_id_);
+    decryptor_->CloseSession(session_id_);
     return itr->second;
   }
 
@@ -708,11 +709,10 @@ class WvCdmExtendedDurationTest : public WvCdmTestBase {
   class CloseSessionThread : public android::Thread {
    public:
      CloseSessionThread() :
-         Thread(false),
-         wv_content_decryption_module_(NULL) {}
+         Thread(false) {}
      ~CloseSessionThread() {}
 
-     bool Start(WvContentDecryptionModule* decryptor,
+     bool Start(const android::sp<wvcdm::WvContentDecryptionModule>& decryptor,
                 const CdmSessionId& session_id,
                 uint32_t time_in_msecs) {
        wv_content_decryption_module_ = decryptor;
@@ -736,13 +736,13 @@ class WvCdmExtendedDurationTest : public WvCdmTestBase {
       return false;
     }
 
-    WvContentDecryptionModule* wv_content_decryption_module_;
+    android::sp<wvcdm::WvContentDecryptionModule> wv_content_decryption_module_;
     CdmSessionId sess_id_;
     struct timespec delay_;
     CORE_DISALLOW_COPY_AND_ASSIGN(CloseSessionThread);
   };
 
-  WvContentDecryptionModule decryptor_;
+  android::sp<wvcdm::WvContentDecryptionModule> decryptor_;
   CdmKeyMessage key_msg_;
   CdmKeyResponse key_response_;
   CdmSessionId session_id_;
@@ -752,8 +752,8 @@ class WvCdmExtendedDurationTest : public WvCdmTestBase {
 
 TEST_F(WvCdmExtendedDurationTest, VerifyLicenseRequestTest) {
   Provision();
-  decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                         NULL, &session_id_);
+  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
+                          NULL, &session_id_);
   GenerateKeyRequest(binary_key_id(), kLicenseTypeStreaming);
 
   EXPECT_TRUE(!key_msg_.empty());
@@ -816,13 +816,13 @@ TEST_F(WvCdmExtendedDurationTest, VerifyLicenseRequestTest) {
   EXPECT_EQ(video_widevine::VERSION_2_1, license_request.protocol_version());
   EXPECT_TRUE(license_request.has_key_control_nonce());
 
-  decryptor_.CloseSession(session_id_);
+  decryptor_->CloseSession(session_id_);
 }
 
 TEST_F(WvCdmExtendedDurationTest, VerifyLicenseRenewalTest) {
   Provision();
-  decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                         NULL, &session_id_);
+  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
+                          NULL, &session_id_);
   GenerateKeyRequest(binary_key_id(), kLicenseTypeStreaming);
   VerifyKeyRequestResponse(config_.license_server(), config_.client_auth(),
                            false);
@@ -892,7 +892,7 @@ TEST_F(WvCdmExtendedDurationTest, VerifyLicenseRenewalTest) {
   EXPECT_EQ(video_widevine::VERSION_2_1, license_renewal.protocol_version());
   EXPECT_TRUE(license_renewal.has_key_control_nonce());
 
-  decryptor_.CloseSession(session_id_);
+  decryptor_->CloseSession(session_id_);
 }
 
 TEST_F(WvCdmExtendedDurationTest, DecryptionCloseSessionConcurrencyTest) {
@@ -901,24 +901,24 @@ TEST_F(WvCdmExtendedDurationTest, DecryptionCloseSessionConcurrencyTest) {
 
   // Leave session open to avoid CDM termination
   CdmSessionId session_id;
-  decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                         NULL, &session_id);
+  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
+                          NULL, &session_id);
 
   // Retrieve offline license
-  decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                         NULL, &session_id_);
+  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
+                          NULL, &session_id_);
   GenerateKeyRequest(kOfflineClip2PstInitData, kLicenseTypeOffline);
   VerifyKeyRequestResponse(config_.license_server(), config_.client_auth(),
                            false);
 
   EXPECT_FALSE(key_set_id_.empty());
 
-  decryptor_.CloseSession(session_id_);
+  decryptor_->CloseSession(session_id_);
 
   for (uint32_t j = 0; j < 500; ++j) {
-    decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                           NULL, &session_id_);
-    EXPECT_EQ(KEY_ADDED, decryptor_.RestoreKey(session_id_, key_set_id_));
+    decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
+                            NULL, &session_id_);
+    EXPECT_EQ(KEY_ADDED, decryptor_->RestoreKey(session_id_, key_set_id_));
 
     CdmResponseType status = NO_ERROR;
     struct timespec decrypt_delay;
@@ -926,7 +926,7 @@ TEST_F(WvCdmExtendedDurationTest, DecryptionCloseSessionConcurrencyTest) {
     decrypt_delay.tv_nsec = 10000000ll;  // 10 ms
 
     CloseSessionThread* thread = new CloseSessionThread();
-    thread->Start(&decryptor_, session_id_, 500 /* 500 ms */);
+    thread->Start(decryptor_, session_id_, 500 /* 500 ms */);
     thread = NULL;
 
     while (status == NO_ERROR) {
@@ -946,8 +946,8 @@ TEST_F(WvCdmExtendedDurationTest, DecryptionCloseSessionConcurrencyTest) {
         decryption_parameters.is_encrypted = (data + i)->is_encrypted;
         decryption_parameters.is_secure = (data + i)->is_secure;
         decryption_parameters.subsample_flags = (data + i)->subsample_flags;
-        status = decryptor_.Decrypt(session_id_, (data + i)->validate_key_id,
-                                    decryption_parameters);
+        status = decryptor_->Decrypt(session_id_, (data + i)->validate_key_id,
+                                     decryption_parameters);
 
         switch (status) {
           case SESSION_NOT_FOUND_FOR_DECRYPT:
@@ -964,7 +964,7 @@ TEST_F(WvCdmExtendedDurationTest, DecryptionCloseSessionConcurrencyTest) {
       }
     }
   }
-  decryptor_.CloseSession(session_id);
+  decryptor_->CloseSession(session_id);
 }
 
 // TODO(rfrias): Rewite this test when OEMCrypto v13 is the minimum version
@@ -984,8 +984,8 @@ TEST_F(WvCdmExtendedDurationTest, DISABLED_UsageOverflowTest) {
       DeviceFiles::GetUsageInfoFileName(""), &provider_session_tokens));
 
   for (size_t i = 0; i < kMaxUsageTableSize + 100; ++i) {
-    decryptor_.OpenSession(config_.key_system(), property_set,
-                           kDefaultCdmIdentifier, NULL, &session_id_);
+    decryptor_->OpenSession(config_.key_system(), property_set,
+                            kDefaultCdmIdentifier, NULL, &session_id_);
     std::string key_id = a2bs_hex(
         "000000427073736800000000"                  // blob size and pssh
         "EDEF8BA979D64ACEA3C827DCD51D21ED00000022"  // Widevine system id
@@ -995,13 +995,13 @@ TEST_F(WvCdmExtendedDurationTest, DISABLED_UsageOverflowTest) {
     GenerateKeyRequest(key_id, kLicenseTypeStreaming);
     VerifyKeyRequestResponse(config_.license_server(), config_.client_auth(),
                              false);
-    decryptor_.CloseSession(session_id_);
+    decryptor_->CloseSession(session_id_);
   }
 
   CdmUsageInfo usage_info;
   CdmUsageInfoReleaseMessage release_msg;
   CdmResponseType status =
-      decryptor_.GetUsageInfo("", kDefaultCdmIdentifier, &usage_info);
+      decryptor_->GetUsageInfo("", kDefaultCdmIdentifier, &usage_info);
   EXPECT_EQ(usage_info.empty() ? NO_ERROR : KEY_MESSAGE, status);
   int error_count = 0;
   while (usage_info.size() > 0) {
@@ -1009,12 +1009,12 @@ TEST_F(WvCdmExtendedDurationTest, DISABLED_UsageOverflowTest) {
       release_msg = GetUsageInfoResponse(config_.license_server(),
                                          config_.client_auth(), usage_info[i]);
       EXPECT_EQ(NO_ERROR,
-                decryptor_.ReleaseUsageInfo(release_msg, kDefaultCdmIdentifier))
+                decryptor_->ReleaseUsageInfo(release_msg, kDefaultCdmIdentifier))
           << i << "/" << usage_info.size() << " (err " << (error_count++) << ")"
           << release_msg;
     }
     ASSERT_LE(error_count, 100);  // Give up after 100 failures.
-    status = decryptor_.GetUsageInfo("", kDefaultCdmIdentifier, &usage_info);
+    status = decryptor_->GetUsageInfo("", kDefaultCdmIdentifier, &usage_info);
     switch (status) {
       case KEY_MESSAGE:
         EXPECT_FALSE(usage_info.empty());
@@ -1038,7 +1038,7 @@ TEST_F(WvCdmExtendedDurationTest, AutomatedOfflineSessionReleaseOnTimerEvent) {
 
   // Leave session open to run the CDM timer
   CdmSessionId streaming_session_id;
-  decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
+  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
                          NULL, &streaming_session_id);
 
   // override default settings unless configured through the command line
@@ -1049,21 +1049,21 @@ TEST_F(WvCdmExtendedDurationTest, AutomatedOfflineSessionReleaseOnTimerEvent) {
   uint32_t initial_open_sessions =
       QueryStatus(kLevelDefault, wvcdm::QUERY_KEY_NUMBER_OF_OPEN_SESSIONS);
 
-  decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
+  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
                          NULL, &session_id_);
   GenerateKeyRequest(kOfflineClip4, kLicenseTypeOffline);
   VerifyKeyRequestResponse(kUatLicenseServer, client_auth, false);
 
   EXPECT_FALSE(key_set_id_.empty());
-  decryptor_.CloseSession(session_id_);
+  decryptor_->CloseSession(session_id_);
   CdmKeySetId key_set_id = key_set_id_;
 
   session_id_.clear();
   key_set_id_.clear();
-  decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
+  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
                          NULL, &session_id_);
-  EXPECT_EQ(wvcdm::KEY_ADDED, decryptor_.RestoreKey(session_id_, key_set_id));
-  decryptor_.CloseSession(session_id_);
+  EXPECT_EQ(wvcdm::KEY_ADDED, decryptor_->RestoreKey(session_id_, key_set_id));
+  decryptor_->CloseSession(session_id_);
 
   session_id_.clear();
   GenerateKeyRelease(key_set_id);
@@ -1084,7 +1084,7 @@ TEST_F(WvCdmExtendedDurationTest, AutomatedOfflineSessionReleaseOnTimerEvent) {
   GenerateKeyRelease(key_set_id);
   key_set_id_ = key_set_id;
   VerifyKeyRequestResponse(kUatLicenseServer, client_auth, false);
-  decryptor_.CloseSession(streaming_session_id);
+  decryptor_->CloseSession(streaming_session_id);
 }
 
 // This test verifies that sessions allocated internally during key release
@@ -1102,33 +1102,33 @@ TEST_F(WvCdmExtendedDurationTest, AutomatedOfflineSessionReleaseOnOpenSession) {
   uint32_t initial_open_sessions =
       QueryStatus(kLevelDefault, wvcdm::QUERY_KEY_NUMBER_OF_OPEN_SESSIONS);
 
-  decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                         NULL, &session_id_);
+  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
+                          NULL, &session_id_);
   GenerateKeyRequest(kOfflineClip4, kLicenseTypeOffline);
   VerifyKeyRequestResponse(kUatLicenseServer, client_auth, false);
 
   EXPECT_FALSE(key_set_id_.empty());
-  decryptor_.CloseSession(session_id_);
+  decryptor_->CloseSession(session_id_);
   CdmKeySetId key_set_id = key_set_id_;
 
   session_id_.clear();
   key_set_id_.clear();
-  decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                         NULL, &session_id_);
-  EXPECT_EQ(wvcdm::KEY_ADDED, decryptor_.RestoreKey(session_id_, key_set_id));
-  decryptor_.CloseSession(session_id_);
+  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
+                          NULL, &session_id_);
+  EXPECT_EQ(wvcdm::KEY_ADDED, decryptor_->RestoreKey(session_id_, key_set_id));
+  decryptor_->CloseSession(session_id_);
 
   session_id_.clear();
   GenerateKeyRelease(key_set_id);
 
-  decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                         NULL, &session_id_);
+  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
+                          NULL, &session_id_);
 
   EXPECT_GT(
       QueryStatus(kLevelDefault, wvcdm::QUERY_KEY_NUMBER_OF_OPEN_SESSIONS),
       initial_open_sessions);
 
-  decryptor_.CloseSession(session_id_);
+  decryptor_->CloseSession(session_id_);
 
   EXPECT_GT(
       QueryStatus(kLevelDefault, wvcdm::QUERY_KEY_NUMBER_OF_OPEN_SESSIONS),
@@ -1140,14 +1140,14 @@ TEST_F(WvCdmExtendedDurationTest, AutomatedOfflineSessionReleaseOnOpenSession) {
       QueryStatus(kLevelDefault, wvcdm::QUERY_KEY_NUMBER_OF_OPEN_SESSIONS),
       initial_open_sessions);
 
-  decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                         NULL, &session_id_);
+  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
+                          NULL, &session_id_);
 
   EXPECT_GT(
       QueryStatus(kLevelDefault, wvcdm::QUERY_KEY_NUMBER_OF_OPEN_SESSIONS),
       initial_open_sessions);
 
-  decryptor_.CloseSession(session_id_);
+  decryptor_->CloseSession(session_id_);
 
   EXPECT_EQ(
       QueryStatus(kLevelDefault, wvcdm::QUERY_KEY_NUMBER_OF_OPEN_SESSIONS),
@@ -1184,13 +1184,13 @@ TEST_F(WvCdmExtendedDurationTest, DISABLED_AutomatedOfflineSessionReleaseTest) {
 
   std::set<std::string> key_set_id_map;
   for (uint32_t i = 0; i < num_key_set_ids; ++i) {
-    decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
+    decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
                            NULL, &session_id_);
     GenerateKeyRequest(kOfflineClip4, kLicenseTypeOffline);
     VerifyKeyRequestResponse(kUatLicenseServer, client_auth, false);
 
     EXPECT_FALSE(key_set_id_.empty());
-    decryptor_.CloseSession(session_id_);
+    decryptor_->CloseSession(session_id_);
     key_set_id_map.insert(key_set_id_);
   }
 
@@ -1198,10 +1198,10 @@ TEST_F(WvCdmExtendedDurationTest, DISABLED_AutomatedOfflineSessionReleaseTest) {
   for (iter = key_set_id_map.begin(); iter != key_set_id_map.end(); ++iter) {
     session_id_.clear();
     key_set_id_.clear();
-    decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
+    decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
                            NULL, &session_id_);
-    EXPECT_EQ(wvcdm::KEY_ADDED, decryptor_.RestoreKey(session_id_, *iter));
-    decryptor_.CloseSession(session_id_);
+    EXPECT_EQ(wvcdm::KEY_ADDED, decryptor_->RestoreKey(session_id_, *iter));
+    decryptor_->CloseSession(session_id_);
   }
 
   for (iter = key_set_id_map.begin(); iter != key_set_id_map.end(); ++iter) {
@@ -1241,7 +1241,7 @@ TEST_P(WvCdmStreamingNoPstTest, UsageTest) {
   Unprovision();
   Provision();
 
-  decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
+  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
                          NULL, &session_id_);
   GenerateKeyRequest(binary_key_id(), kLicenseTypeStreaming);
   VerifyKeyRequestResponse(config_.license_server(), config_.client_auth(),
@@ -1272,7 +1272,7 @@ TEST_P(WvCdmStreamingNoPstTest, UsageTest) {
       decryption_parameters.is_secure = (data + i)->is_secure;
       decryption_parameters.subsample_flags = (data + i)->subsample_flags;
       EXPECT_EQ(NO_ERROR,
-                decryptor_.Decrypt(session_id_, (data + i)->validate_key_id,
+                decryptor_->Decrypt(session_id_, (data + i)->validate_key_id,
                                    decryption_parameters));
 
       EXPECT_EQ((data + i)->decrypt_data, decrypt_buffer);
@@ -1304,7 +1304,7 @@ TEST_P(WvCdmStreamingNoPstTest, UsageTest) {
   EXPECT_NEAR(initial_playback_duration_remaining - playback_duration_remaining,
               expected_seconds_since_initial_playback, kClockTolerance);
 
-  decryptor_.CloseSession(session_id_);
+  decryptor_->CloseSession(session_id_);
 }
 
 INSTANTIATE_TEST_CASE_P(Cdm, WvCdmStreamingNoPstTest,
@@ -1317,8 +1317,8 @@ TEST_P(WvCdmStreamingPstTest, UsageTest) {
   Unprovision();
   Provision();
 
-  decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                         NULL, &session_id_);
+  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
+                          NULL, &session_id_);
   GenerateKeyRequest(kStreamingClip8PstInitData, kLicenseTypeStreaming);
   VerifyKeyRequestResponse(config_.license_server(), config_.client_auth(),
                            false);
@@ -1348,8 +1348,8 @@ TEST_P(WvCdmStreamingPstTest, UsageTest) {
       decryption_parameters.is_secure = (data + i)->is_secure;
       decryption_parameters.subsample_flags = (data + i)->subsample_flags;
       EXPECT_EQ(NO_ERROR,
-                decryptor_.Decrypt(session_id_, (data + i)->validate_key_id,
-                                   decryption_parameters));
+                decryptor_->Decrypt(session_id_, (data + i)->validate_key_id,
+                                    decryption_parameters));
 
       EXPECT_EQ((data + i)->decrypt_data, decrypt_buffer);
     }
@@ -1371,7 +1371,7 @@ TEST_P(WvCdmStreamingPstTest, UsageTest) {
   EXPECT_NEAR(initial_playback_duration_remaining - playback_duration_remaining,
               expected_seconds_since_initial_playback, kClockTolerance);
 
-  decryptor_.CloseSession(session_id_);
+  decryptor_->CloseSession(session_id_);
 }
 
 INSTANTIATE_TEST_CASE_P(Cdm, WvCdmStreamingPstTest, ::testing::Values(0, 1, 2));
@@ -1384,7 +1384,7 @@ TEST_P(WvCdmStreamingUsageReportTest, UsageTest) {
   Unprovision();
   Provision();
 
-  decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
+  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
                          NULL, &session_id_);
   GenerateKeyRequest(kStreamingClip8PstInitData, kLicenseTypeStreaming);
   VerifyKeyRequestResponse(config_.license_server(), config_.client_auth(),
@@ -1415,8 +1415,8 @@ TEST_P(WvCdmStreamingUsageReportTest, UsageTest) {
       decryption_parameters.is_secure = (data + i)->is_secure;
       decryption_parameters.subsample_flags = (data + i)->subsample_flags;
       EXPECT_EQ(NO_ERROR,
-                decryptor_.Decrypt(session_id_, (data + i)->validate_key_id,
-                                   decryption_parameters));
+                decryptor_->Decrypt(session_id_, (data + i)->validate_key_id,
+                                    decryption_parameters));
 
       EXPECT_EQ((data + i)->decrypt_data, decrypt_buffer);
     }
@@ -1438,13 +1438,13 @@ TEST_P(WvCdmStreamingUsageReportTest, UsageTest) {
   EXPECT_NEAR(initial_playback_duration_remaining - playback_duration_remaining,
               expected_seconds_since_initial_playback, kClockTolerance);
 
-  decryptor_.CloseSession(session_id_);
+  decryptor_->CloseSession(session_id_);
 
   // Create usage report and validate
   CdmUsageInfo usage_info;
   CdmUsageInfoReleaseMessage release_msg;
   CdmResponseType status =
-      decryptor_.GetUsageInfo("", kDefaultCdmIdentifier, &usage_info);
+      decryptor_->GetUsageInfo("", kDefaultCdmIdentifier, &usage_info);
   EXPECT_EQ(usage_info.empty() ? NO_ERROR : KEY_MESSAGE, status);
   int error_count = 0;
   while (usage_info.size() > 0) {
@@ -1457,12 +1457,12 @@ TEST_P(WvCdmStreamingUsageReportTest, UsageTest) {
       release_msg = GetUsageInfoResponse(config_.license_server(),
                                          config_.client_auth(), usage_info[i]);
       EXPECT_EQ(NO_ERROR,
-                decryptor_.ReleaseUsageInfo(release_msg, kDefaultCdmIdentifier))
+                decryptor_->ReleaseUsageInfo(release_msg, kDefaultCdmIdentifier))
           << i << "/" << usage_info.size() << " (err " << (error_count++) << ")"
           << release_msg;
     }
     ASSERT_LE(error_count, 100);  // Give up after 100 failures.
-    status = decryptor_.GetUsageInfo("", kDefaultCdmIdentifier, &usage_info);
+    status = decryptor_->GetUsageInfo("", kDefaultCdmIdentifier, &usage_info);
     switch (status) {
       case KEY_MESSAGE:
         EXPECT_FALSE(usage_info.empty());
@@ -1478,7 +1478,7 @@ TEST_P(WvCdmStreamingUsageReportTest, UsageTest) {
 
   // Validate that update usage table entry is exercised.
   drm_metrics::WvCdmMetrics metrics;
-  ASSERT_EQ(NO_ERROR, decryptor_.GetMetrics(kDefaultCdmIdentifier, &metrics));
+  ASSERT_EQ(NO_ERROR, decryptor_->GetMetrics(kDefaultCdmIdentifier, &metrics));
   ValidateHasUpdateUsageEntry(metrics);
 }
 
@@ -1493,8 +1493,8 @@ TEST_P(WvCdmOfflineUsageReportTest, UsageTest) {
   Unprovision();
   Provision();
 
-  decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                         NULL, &session_id_);
+  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
+                          NULL, &session_id_);
   GenerateKeyRequest(kOfflineClip2PstInitData, kLicenseTypeOffline);
   VerifyKeyRequestResponse(config_.license_server(), config_.client_auth(),
                            false);
@@ -1509,7 +1509,7 @@ TEST_P(WvCdmOfflineUsageReportTest, UsageTest) {
   QueryKeyStatus(false, true, &initial_license_duration_remaining,
                  &initial_playback_duration_remaining);
 
-  decryptor_.CloseSession(session_id_);
+  decryptor_->CloseSession(session_id_);
 
   sleep(kMinute);
   int64_t expected_seconds_since_license_received = kMinute;
@@ -1518,9 +1518,9 @@ TEST_P(WvCdmOfflineUsageReportTest, UsageTest) {
 
   for (size_t i = 0; i < GetParam(); ++i) {
     session_id_.clear();
-    decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
+    decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
                            NULL, &session_id_);
-    EXPECT_EQ(KEY_ADDED, decryptor_.RestoreKey(session_id_, key_set_id));
+    EXPECT_EQ(KEY_ADDED, decryptor_->RestoreKey(session_id_, key_set_id));
 
     // Query and validate usage information
     int64_t license_duration_remaining = 0;
@@ -1546,14 +1546,14 @@ TEST_P(WvCdmOfflineUsageReportTest, UsageTest) {
       decryption_parameters.is_secure = (data + i)->is_secure;
       decryption_parameters.subsample_flags = (data + i)->subsample_flags;
       EXPECT_EQ(NO_ERROR,
-                decryptor_.Decrypt(session_id_, (data + i)->validate_key_id,
-                                   decryption_parameters));
+                decryptor_->Decrypt(session_id_, (data + i)->validate_key_id,
+                                    decryption_parameters));
 
       EXPECT_EQ((data + i)->decrypt_data, decrypt_buffer);
     }
 
     sleep(10);
-    decryptor_.CloseSession(session_id_);
+    decryptor_->CloseSession(session_id_);
 
     sleep(kMinute - 10);
     expected_seconds_since_license_received += kMinute;
@@ -1562,9 +1562,9 @@ TEST_P(WvCdmOfflineUsageReportTest, UsageTest) {
   }
 
   session_id_.clear();
-  decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                         NULL, &session_id_);
-  EXPECT_EQ(KEY_ADDED, decryptor_.RestoreKey(session_id_, key_set_id));
+  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
+                          NULL, &session_id_);
+  EXPECT_EQ(KEY_ADDED, decryptor_->RestoreKey(session_id_, key_set_id));
 
   // Query and validate usage information
   int64_t license_duration_remaining = 0;
@@ -1577,7 +1577,7 @@ TEST_P(WvCdmOfflineUsageReportTest, UsageTest) {
   EXPECT_NEAR(initial_playback_duration_remaining - playback_duration_remaining,
               expected_seconds_since_initial_playback, kClockTolerance);
 
-  decryptor_.CloseSession(session_id_);
+  decryptor_->CloseSession(session_id_);
 
   session_id_.clear();
   key_set_id_.clear();
@@ -1612,22 +1612,23 @@ TEST_F(WvCdmExtendedDurationTest, MaxUsageEntryOfflineRecoveryTest) {
   // licenses will be deleted internally to make space and we will
   // not encounter an error.
   for (size_t i = 0; i < 2000; ++i) {
-    decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                           NULL, &session_id_);
+    decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
+                            NULL, &session_id_);
     GenerateKeyRequest(kOfflineClip2PstInitData, kLicenseTypeOffline);
     VerifyKeyRequestResponse(config_.license_server(), client_auth, false);
 
     key_set_ids.push_back(key_set_id_);
 
-    decryptor_.CloseSession(session_id_);
+    decryptor_->CloseSession(session_id_);
   }
 
   uint32_t number_of_valid_offline_sessions = 0;
   for (size_t i = 0; i < key_set_ids.size(); ++i) {
     session_id_.clear();
-    decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                           NULL, &session_id_);
-    CdmResponseType result = decryptor_.RestoreKey(session_id_, key_set_ids[i]);
+    decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
+                            NULL, &session_id_);
+    CdmResponseType result = decryptor_->RestoreKey(session_id_,
+                                                    key_set_ids[i]);
 
     if (result == KEY_ADDED) {
       ++number_of_valid_offline_sessions;
@@ -1643,19 +1644,19 @@ TEST_F(WvCdmExtendedDurationTest, MaxUsageEntryOfflineRecoveryTest) {
       decryption_parameters.is_secure = data->is_secure;
       decryption_parameters.subsample_flags = data->subsample_flags;
       EXPECT_EQ(NO_ERROR,
-                decryptor_.Decrypt(session_id_, data->validate_key_id,
+                decryptor_->Decrypt(session_id_, data->validate_key_id,
                                    decryption_parameters));
 
       EXPECT_EQ(data->decrypt_data, decrypt_buffer);
 
-      decryptor_.CloseSession(session_id_);
+      decryptor_->CloseSession(session_id_);
 
       // Release the license
       GenerateKeyRelease(key_set_ids[i]);
       key_set_id_ = key_set_ids[i];
       VerifyKeyRequestResponse(config_.license_server(), client_auth, false);
     } else {
-      decryptor_.CloseSession(session_id_);
+      decryptor_->CloseSession(session_id_);
     }
   }
 
diff --git a/libwvdrmengine/cdm/test/request_license_test.cpp b/libwvdrmengine/cdm/test/request_license_test.cpp
index df94a2a7..88b925c0 100644
--- a/libwvdrmengine/cdm/test/request_license_test.cpp
+++ b/libwvdrmengine/cdm/test/request_license_test.cpp
@@ -1623,8 +1623,9 @@ class TestWvCdmEventListener : public WvCdmEventListener {
 
 class DecryptCallbackTester {
  public:
-  DecryptCallbackTester(android::sp<wvcdm::WvContentDecryptionModule> decryptor,
-                        SubSampleInfo* sub_sample_info)
+  DecryptCallbackTester(
+      const android::sp<wvcdm::WvContentDecryptionModule>& decryptor,
+      SubSampleInfo* sub_sample_info)
    : decryptor_(decryptor),
      sub_sample_info_(sub_sample_info) {}