diff --git a/libwvdrmengine/cdm/include/wv_content_decryption_module.h b/libwvdrmengine/cdm/include/wv_content_decryption_module.h
index 4f12f545..fa95269c 100644
--- a/libwvdrmengine/cdm/include/wv_content_decryption_module.h
+++ b/libwvdrmengine/cdm/include/wv_content_decryption_module.h
@@ -179,8 +179,8 @@ class WvContentDecryptionModule : public android::RefBase, public TimerHandler {
   // Finds the CdmEngine instance for the given identifier, creating one if
   // needed.
   CdmEngine* EnsureCdmForIdentifier(const CdmIdentifier& identifier);
-  // Finds the CdmEngine instance for the given session id, returning NULL if
-  // not found.
+  // Finds the CdmEngine instance for the given session id, returning nullptr
+  // if not found.
   CdmEngine* GetCdmForSessionId(const std::string& session_id);
 
   // Close all of the open CdmEngine instances. This is used when ready to close
diff --git a/libwvdrmengine/cdm/src/timer.cpp b/libwvdrmengine/cdm/src/timer.cpp
index a0e0b135..7f6a09aa 100644
--- a/libwvdrmengine/cdm/src/timer.cpp
+++ b/libwvdrmengine/cdm/src/timer.cpp
@@ -19,7 +19,7 @@ class Timer::Impl : virtual public android::RefBase {
  private:
   class ImplThread : public android::Thread {
    public:
-    ImplThread() : Thread(false), handler_(NULL), period_ns_(0) {}
+    ImplThread() : Thread(false), handler_(nullptr), period_ns_(0) {}
     virtual ~ImplThread() {};
 
     bool Start(TimerHandler *handler, uint32_t time_in_secs) {
@@ -69,7 +69,7 @@ class Timer::Impl : virtual public android::RefBase {
   }
 
   bool IsRunning() {
-    return (impl_thread_ != NULL) && (impl_thread_->isRunning());
+    return (impl_thread_ != nullptr) && (impl_thread_->isRunning());
   }
 
   CORE_DISALLOW_COPY_AND_ASSIGN(Impl);
diff --git a/libwvdrmengine/cdm/src/wv_content_decryption_module.cpp b/libwvdrmengine/cdm/src/wv_content_decryption_module.cpp
index a6eb3b45..54527091 100644
--- a/libwvdrmengine/cdm/src/wv_content_decryption_module.cpp
+++ b/libwvdrmengine/cdm/src/wv_content_decryption_module.cpp
@@ -100,7 +100,7 @@ CdmResponseType WvContentDecryptionModule::GenerateKeyRequest(
   CdmEngine* cdm_engine = EnsureCdmForIdentifier(identifier);
   CdmResponseType sts;
   if (license_type == kLicenseTypeRelease) {
-    sts = cdm_engine->OpenKeySetSession(key_set_id, property_set, NULL);
+    sts = cdm_engine->OpenKeySetSession(key_set_id, property_set, nullptr);
     if (sts != NO_ERROR) return sts;
     cdm_by_session_id_[key_set_id] = cdm_engine;
   }
@@ -147,7 +147,7 @@ CdmResponseType WvContentDecryptionModule::AddKey(
   if (!cdm_engine) return SESSION_NOT_FOUND_3;
   // Save key_set_id, as CDM will return an empty key_set_id on release
   CdmKeySetId release_key_set_id;
-  if (session_id.empty() && key_set_id != NULL) {
+  if (session_id.empty() && key_set_id != nullptr) {
     release_key_set_id = *key_set_id;
   }
   CdmResponseType sts;
@@ -276,18 +276,18 @@ CdmResponseType WvContentDecryptionModule::GetSecureStopIds(
     const std::string& app_id,
     const CdmIdentifier& identifier,
     std::vector<CdmSecureStopId>* ssids) {
-  if (ssids == NULL) {
+  if (ssids == nullptr) {
     LOGE("WvContentDecryptionModule::GetSecureStopIds: ssid destination not "
          "provided");
     return PARAMETER_NULL;
   }
 
   CdmEngine* cdm_engine = EnsureCdmForIdentifier(identifier);
-  CdmResponseType sts = cdm_engine->ListUsageIds(app_id, kSecurityLevelL1,
-                                                 NULL, ssids);
+  CdmResponseType sts =
+      cdm_engine->ListUsageIds(app_id, kSecurityLevelL1, nullptr, ssids);
   std::vector<CdmSecureStopId> secure_stop_ids;
   CdmResponseType sts_l3 = cdm_engine->ListUsageIds(app_id, kSecurityLevelL3,
-                                                    NULL, &secure_stop_ids);
+                                                    nullptr, &secure_stop_ids);
   ssids->insert(ssids->end(), secure_stop_ids.begin(), secure_stop_ids.end());
   return sts_l3 != NO_ERROR ? sts_l3 : sts;
 }
@@ -381,7 +381,7 @@ CdmEngine* WvContentDecryptionModule::GetCdmForSessionId(
     const std::string& session_id) {
   // Use find to avoid creating empty entries when not found.
   auto it = cdm_by_session_id_.find(session_id);
-  if (it == cdm_by_session_id_.end()) return NULL;
+  if (it == cdm_by_session_id_.end()) return nullptr;
   return it->second;
 }
 
diff --git a/libwvdrmengine/cdm/test/cdm_extended_duration_test.cpp b/libwvdrmengine/cdm/test/cdm_extended_duration_test.cpp
index 49b30c65..e6209352 100644
--- a/libwvdrmengine/cdm/test/cdm_extended_duration_test.cpp
+++ b/libwvdrmengine/cdm/test/cdm_extended_duration_test.cpp
@@ -279,7 +279,7 @@ class WvCdmExtendedDurationTest : public WvCdmTestBase {
 
     *response = decryptor_->GenerateKeyRequest(
                     session_id_, key_set_id_, "video/mp4", init_data,
-                    license_type, app_parameters, NULL,
+                    license_type, app_parameters, nullptr,
                     kDefaultCdmIdentifier, &key_request);
     if (*response == KEY_MESSAGE) {
       EXPECT_EQ(kKeyRequestTypeInitial, key_request.type);
@@ -299,7 +299,7 @@ class WvCdmExtendedDurationTest : public WvCdmTestBase {
 
     EXPECT_EQ(KEY_MESSAGE, decryptor_->GenerateKeyRequest(
                                session_id_, key_set_id_, "video/mp4", init_data,
-                               license_type, app_parameters, NULL,
+                               license_type, app_parameters, nullptr,
                                kDefaultCdmIdentifier, &key_request));
 
     *server_url = key_request.url;
@@ -319,7 +319,7 @@ class WvCdmExtendedDurationTest : public WvCdmTestBase {
 
     EXPECT_EQ(expected_response, decryptor_->GenerateKeyRequest(
                                session_id, key_set_id, "video/mp4", init_data,
-                               kLicenseTypeRelease, app_parameters, NULL,
+                               kLicenseTypeRelease, app_parameters, nullptr,
                                kDefaultCdmIdentifier, &key_request));
 
     if (expected_response == KEY_MESSAGE) {
@@ -414,7 +414,7 @@ class WvCdmExtendedDurationTest : public WvCdmTestBase {
   void VerifyKeyRequestResponse(const std::string& server_url,
                                 const std::string& client_auth,
                                 bool is_renewal) {
-    VerifyKeyRequestResponse(server_url, client_auth, is_renewal, NULL);
+    VerifyKeyRequestResponse(server_url, client_auth, is_renewal, nullptr);
   }
 
   void VerifyKeyRequestResponse(const std::string& server_url,
@@ -425,7 +425,7 @@ class WvCdmExtendedDurationTest : public WvCdmTestBase {
     CdmResponseType sts =
         decryptor_->AddKey(session_id_, resp, &key_set_id_);
 
-    if (status == NULL) {
+    if (status == nullptr) {
       EXPECT_EQ(KEY_ADDED, sts);
     } else {
       *status = sts;
@@ -441,7 +441,7 @@ class WvCdmExtendedDurationTest : public WvCdmTestBase {
 
   void Provision() {
     CdmResponseType status = decryptor_->OpenSession(
-        config_.key_system(), NULL, kDefaultCdmIdentifier, NULL, &session_id_);
+        config_.key_system(), nullptr, kDefaultCdmIdentifier, nullptr, &session_id_);
     switch (status) {
       case NO_ERROR:
         decryptor_->CloseSession(session_id_);
@@ -683,7 +683,7 @@ class WvCdmExtendedDurationTest : public WvCdmTestBase {
 
   std::string GetSecurityLevel(TestWvCdmClientPropertySet* property_set) {
     decryptor_->OpenSession(config_.key_system(), property_set,
-                            kDefaultCdmIdentifier, NULL, &session_id_);
+                            kDefaultCdmIdentifier, nullptr, &session_id_);
     CdmQueryMap query_info;
     EXPECT_EQ(NO_ERROR,
               decryptor_->QuerySessionStatus(session_id_, &query_info));
@@ -694,7 +694,7 @@ class WvCdmExtendedDurationTest : public WvCdmTestBase {
   }
 
   CdmSecurityLevel GetDefaultSecurityLevel() {
-    std::string level = GetSecurityLevel(NULL);
+    std::string level = GetSecurityLevel(nullptr);
     CdmSecurityLevel security_level = kSecurityLevelUninitialized;
     if (level == QUERY_VALUE_SECURITY_LEVEL_L1) {
       security_level = kSecurityLevelL1;
@@ -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(), nullptr, kDefaultCdmIdentifier,
+                          nullptr, &session_id_);
   GenerateKeyRequest(binary_key_id(), kLicenseTypeStreaming);
 
   EXPECT_TRUE(!key_msg_.empty());
@@ -821,8 +821,8 @@ TEST_F(WvCdmExtendedDurationTest, VerifyLicenseRequestTest) {
 
 TEST_F(WvCdmExtendedDurationTest, VerifyLicenseRenewalTest) {
   Provision();
-  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                          NULL, &session_id_);
+  decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                          nullptr, &session_id_);
   GenerateKeyRequest(binary_key_id(), kLicenseTypeStreaming);
   VerifyKeyRequestResponse(config_.license_server(), config_.client_auth(),
                            false);
@@ -901,12 +901,12 @@ 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(), nullptr, kDefaultCdmIdentifier,
+                          nullptr, &session_id);
 
   // Retrieve offline license
-  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                          NULL, &session_id_);
+  decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                          nullptr, &session_id_);
   GenerateKeyRequest(kOfflineClip2PstInitData, kLicenseTypeOffline);
   VerifyKeyRequestResponse(config_.license_server(), config_.client_auth(),
                            false);
@@ -916,8 +916,8 @@ TEST_F(WvCdmExtendedDurationTest, DecryptionCloseSessionConcurrencyTest) {
   decryptor_->CloseSession(session_id_);
 
   for (uint32_t j = 0; j < 500; ++j) {
-    decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                            NULL, &session_id_);
+    decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                            nullptr, &session_id_);
     EXPECT_EQ(KEY_ADDED, decryptor_->RestoreKey(session_id_, key_set_id_));
 
     CdmResponseType status = NO_ERROR;
@@ -927,7 +927,7 @@ TEST_F(WvCdmExtendedDurationTest, DecryptionCloseSessionConcurrencyTest) {
 
     CloseSessionThread* thread = new CloseSessionThread();
     thread->Start(decryptor_, session_id_, 500 /* 500 ms */);
-    thread = NULL;
+    thread = nullptr;
 
     while (status == NO_ERROR) {
       struct timespec delay_remaining;
@@ -973,7 +973,7 @@ TEST_F(WvCdmExtendedDurationTest, DecryptionCloseSessionConcurrencyTest) {
 TEST_F(WvCdmExtendedDurationTest, DISABLED_UsageOverflowTest) {
   Provision();
   TestWvCdmClientPropertySet client_property_set;
-  TestWvCdmClientPropertySet* property_set = NULL;
+  TestWvCdmClientPropertySet* property_set = nullptr;
 
   CdmSecurityLevel security_level = GetDefaultSecurityLevel();
   FileSystem file_system;
@@ -985,7 +985,7 @@ TEST_F(WvCdmExtendedDurationTest, DISABLED_UsageOverflowTest) {
 
   for (size_t i = 0; i < kMaxUsageTableSize + 100; ++i) {
     decryptor_->OpenSession(config_.key_system(), property_set,
-                            kDefaultCdmIdentifier, NULL, &session_id_);
+                            kDefaultCdmIdentifier, nullptr, &session_id_);
     std::string key_id = a2bs_hex(
         "000000427073736800000000"                  // blob size and pssh
         "EDEF8BA979D64ACEA3C827DCD51D21ED00000022"  // Widevine system id
@@ -1038,8 +1038,8 @@ TEST_F(WvCdmExtendedDurationTest, AutomatedOfflineSessionReleaseOnTimerEvent) {
 
   // Leave session open to run the CDM timer
   CdmSessionId streaming_session_id;
-  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                         NULL, &streaming_session_id);
+  decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                         nullptr, &streaming_session_id);
 
   // override default settings unless configured through the command line
   std::string key_id;
@@ -1049,8 +1049,8 @@ 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,
-                         NULL, &session_id_);
+  decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                         nullptr, &session_id_);
   GenerateKeyRequest(kOfflineClip4, kLicenseTypeOffline);
   VerifyKeyRequestResponse(kUatLicenseServer, client_auth, false);
 
@@ -1060,8 +1060,8 @@ TEST_F(WvCdmExtendedDurationTest, AutomatedOfflineSessionReleaseOnTimerEvent) {
 
   session_id_.clear();
   key_set_id_.clear();
-  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                         NULL, &session_id_);
+  decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                         nullptr, &session_id_);
   EXPECT_EQ(wvcdm::KEY_ADDED, decryptor_->RestoreKey(session_id_, key_set_id));
   decryptor_->CloseSession(session_id_);
 
@@ -1102,8 +1102,8 @@ 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(), nullptr, kDefaultCdmIdentifier,
+                          nullptr, &session_id_);
   GenerateKeyRequest(kOfflineClip4, kLicenseTypeOffline);
   VerifyKeyRequestResponse(kUatLicenseServer, client_auth, false);
 
@@ -1113,16 +1113,16 @@ TEST_F(WvCdmExtendedDurationTest, AutomatedOfflineSessionReleaseOnOpenSession) {
 
   session_id_.clear();
   key_set_id_.clear();
-  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                          NULL, &session_id_);
+  decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                          nullptr, &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(), nullptr, kDefaultCdmIdentifier,
+                          nullptr, &session_id_);
 
   EXPECT_GT(
       QueryStatus(kLevelDefault, wvcdm::QUERY_KEY_NUMBER_OF_OPEN_SESSIONS),
@@ -1140,8 +1140,8 @@ 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(), nullptr, kDefaultCdmIdentifier,
+                          nullptr, &session_id_);
 
   EXPECT_GT(
       QueryStatus(kLevelDefault, wvcdm::QUERY_KEY_NUMBER_OF_OPEN_SESSIONS),
@@ -1184,8 +1184,8 @@ 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,
-                           NULL, &session_id_);
+    decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                           nullptr, &session_id_);
     GenerateKeyRequest(kOfflineClip4, kLicenseTypeOffline);
     VerifyKeyRequestResponse(kUatLicenseServer, client_auth, false);
 
@@ -1198,8 +1198,8 @@ 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,
-                           NULL, &session_id_);
+    decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                           nullptr, &session_id_);
     EXPECT_EQ(wvcdm::KEY_ADDED, decryptor_->RestoreKey(session_id_, *iter));
     decryptor_->CloseSession(session_id_);
   }
@@ -1241,8 +1241,8 @@ TEST_P(WvCdmStreamingNoPstTest, UsageTest) {
   Unprovision();
   Provision();
 
-  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                         NULL, &session_id_);
+  decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                         nullptr, &session_id_);
   GenerateKeyRequest(binary_key_id(), kLicenseTypeStreaming);
   VerifyKeyRequestResponse(config_.license_server(), config_.client_auth(),
                            false);
@@ -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(), nullptr, kDefaultCdmIdentifier,
+                          nullptr, &session_id_);
   GenerateKeyRequest(kStreamingClip8PstInitData, kLicenseTypeStreaming);
   VerifyKeyRequestResponse(config_.license_server(), config_.client_auth(),
                            false);
@@ -1384,8 +1384,8 @@ TEST_P(WvCdmStreamingUsageReportTest, UsageTest) {
   Unprovision();
   Provision();
 
-  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                         NULL, &session_id_);
+  decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                         nullptr, &session_id_);
   GenerateKeyRequest(kStreamingClip8PstInitData, kLicenseTypeStreaming);
   VerifyKeyRequestResponse(config_.license_server(), config_.client_auth(),
                            false);
@@ -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(), nullptr, kDefaultCdmIdentifier,
+                          nullptr, &session_id_);
   GenerateKeyRequest(kOfflineClip2PstInitData, kLicenseTypeOffline);
   VerifyKeyRequestResponse(config_.license_server(), config_.client_auth(),
                            false);
@@ -1518,8 +1518,8 @@ TEST_P(WvCdmOfflineUsageReportTest, UsageTest) {
 
   for (size_t i = 0; i < GetParam(); ++i) {
     session_id_.clear();
-    decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                           NULL, &session_id_);
+    decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                           nullptr, &session_id_);
     EXPECT_EQ(KEY_ADDED, decryptor_->RestoreKey(session_id_, key_set_id));
 
     // Query and validate usage information
@@ -1562,8 +1562,8 @@ TEST_P(WvCdmOfflineUsageReportTest, UsageTest) {
   }
 
   session_id_.clear();
-  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                          NULL, &session_id_);
+  decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                          nullptr, &session_id_);
   EXPECT_EQ(KEY_ADDED, decryptor_->RestoreKey(session_id_, key_set_id));
 
   // Query and validate usage information
@@ -1612,8 +1612,8 @@ 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(), nullptr, kDefaultCdmIdentifier,
+                            nullptr, &session_id_);
     GenerateKeyRequest(kOfflineClip2PstInitData, kLicenseTypeOffline);
     VerifyKeyRequestResponse(config_.license_server(), client_auth, false);
 
@@ -1625,8 +1625,8 @@ TEST_F(WvCdmExtendedDurationTest, MaxUsageEntryOfflineRecoveryTest) {
   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_);
+    decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                            nullptr, &session_id_);
     CdmResponseType result = decryptor_->RestoreKey(session_id_,
                                                     key_set_ids[i]);
 
diff --git a/libwvdrmengine/cdm/test/cdm_feature_test.cpp b/libwvdrmengine/cdm/test/cdm_feature_test.cpp
index 39a4b2ca..4b0ff2a9 100644
--- a/libwvdrmengine/cdm/test/cdm_feature_test.cpp
+++ b/libwvdrmengine/cdm/test/cdm_feature_test.cpp
@@ -298,7 +298,7 @@ class WvCdmFeatureTest : public WvCdmTestBase {
 
   void GenerateKeyRequest(const std::string& init_data,
                           CdmLicenseType license_type) {
-    GenerateKeyRequest(init_data, license_type, NULL);
+    GenerateKeyRequest(init_data, license_type, nullptr);
   }
 
   void GenerateKeyRequest(const std::string& init_data,
@@ -401,8 +401,8 @@ class WvCdmFeatureTest : public WvCdmTestBase {
 // To run this test set options,
 // * use_keybox 0
 TEST_F(WvCdmFeatureTest, OEMCertificateProvisioning) {
-  decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                         NULL, &session_id_);
+  decryptor_.OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                         nullptr, &session_id_);
   std::string provisioning_server_url;
   CdmCertificateType cert_type = kCertificateWidevine;
   std::string cert_authority, cert, wrapped_key;
@@ -438,8 +438,8 @@ TEST_F(WvCdmFeatureTest, OEMCertificateProvisioning) {
 // To run this test set options,
 // * use_keybox 1
 TEST_F(WvCdmFeatureTest, KeyboxProvisioning) {
-  decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                         NULL, &session_id_);
+  decryptor_.OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                         nullptr, &session_id_);
   std::string provisioning_server_url;
   CdmCertificateType cert_type = kCertificateWidevine;
   std::string cert_authority, cert, wrapped_key;
@@ -495,7 +495,7 @@ TEST_P(WvCdmSrmTest, Srm) {
 
   StrictMock<TestWvCdmEventListener> listener;
   TestKeyVerifier verify_keys_callback(config->expected_key_ids);
-  decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
+  decryptor_.OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
                          &listener, &session_id_);
 
   EXPECT_CALL(listener,
@@ -552,7 +552,7 @@ TEST_P(WvCdmSrmNotSupportedTest, Srm) {
 
   StrictMock<TestWvCdmEventListener> listener;
   TestKeyVerifier verify_keys_callback(config->expected_key_ids);
-  decryptor_.OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
+  decryptor_.OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
                          &listener, &session_id_);
 
   EXPECT_CALL(listener,
diff --git a/libwvdrmengine/cdm/test/request_license_test.cpp b/libwvdrmengine/cdm/test/request_license_test.cpp
index 9307dae9..dbdf3a0e 100644
--- a/libwvdrmengine/cdm/test/request_license_test.cpp
+++ b/libwvdrmengine/cdm/test/request_license_test.cpp
@@ -1604,8 +1604,8 @@ class DecryptCallbackTester {
   void Decrypt(const CdmSessionId& session_id,
                const CdmKeyStatusMap& /* keys_status */,
                bool /* has_new_usable_key */) {
-    EXPECT_TRUE(decryptor_.get() != NULL);
-    EXPECT_TRUE(sub_sample_info_ != NULL);
+    EXPECT_TRUE(decryptor_);
+    EXPECT_TRUE(sub_sample_info_ != nullptr);
 
     std::vector<uint8_t> decrypt_buffer(sub_sample_info_->encrypt_data.size());
   CdmDecryptionParameters decryption_parameters(
@@ -1663,7 +1663,7 @@ class WvCdmRequestLicenseTest : public WvCdmTestBase {
 
   void GenerateKeyRequest(const std::string& init_data,
                           CdmLicenseType license_type) {
-    GenerateKeyRequest(init_data, license_type, NULL);
+    GenerateKeyRequest(init_data, license_type, nullptr);
   }
 
   void GenerateKeyRequest(const std::string& init_data,
@@ -1671,7 +1671,7 @@ class WvCdmRequestLicenseTest : public WvCdmTestBase {
                           const CdmIdentifier& identifier) {
     CdmAppParameterMap app_parameters;
     GenerateKeyRequest(wvcdm::KEY_MESSAGE, "video/mp4", init_data,
-                       app_parameters, license_type, identifier, NULL);
+                       app_parameters, license_type, identifier, nullptr);
   }
 
   void GenerateKeyRequest(const std::string& init_data,
@@ -1739,11 +1739,11 @@ class WvCdmRequestLicenseTest : public WvCdmTestBase {
     std::string init_data;
     wvcdm::CdmAppParameterMap app_parameters;
     CdmKeyRequest key_request;
-    EXPECT_EQ(wvcdm::KEY_MESSAGE,
-              decryptor_->GenerateKeyRequest(
-                  session_id_, key_set_id_, "video/mp4", init_data,
-                  license_type, app_parameters, NULL, kDefaultCdmIdentifier,
-                  &key_request));
+    EXPECT_EQ(
+        wvcdm::KEY_MESSAGE,
+        decryptor_->GenerateKeyRequest(
+            session_id_, key_set_id_, "video/mp4", init_data, license_type,
+            app_parameters, nullptr, kDefaultCdmIdentifier, &key_request));
     key_msg_ = key_request.message;
     *server_url = key_request.url;
     EXPECT_EQ(kKeyRequestTypeRenewal, key_request.type);
@@ -1756,11 +1756,9 @@ class WvCdmRequestLicenseTest : public WvCdmTestBase {
                           const std::string& init_data) {
     wvcdm::CdmAppParameterMap app_parameters;
     CdmKeyRequest key_request;
-    CdmResponseType status =
-        decryptor_->GenerateKeyRequest(
-            session_id_, key_set_id_, "video/mp4", init_data,
-            license_type, app_parameters, NULL, kDefaultCdmIdentifier,
-            &key_request);
+    CdmResponseType status = decryptor_->GenerateKeyRequest(
+        session_id_, key_set_id_, "video/mp4", init_data, license_type,
+        app_parameters, nullptr, kDefaultCdmIdentifier, &key_request);
     EXPECT_EQ(wvcdm::KEY_ADDED, status);
     EXPECT_TRUE(key_request.message.empty());
     EXPECT_EQ(kKeyRequestTypeNone, key_request.type);
@@ -1770,7 +1768,7 @@ class WvCdmRequestLicenseTest : public WvCdmTestBase {
   }
 
   void GenerateKeyRelease(CdmKeySetId key_set_id) {
-    GenerateKeyRelease(key_set_id, NULL, NULL);
+    GenerateKeyRelease(key_set_id, nullptr, nullptr);
   }
 
   void GenerateKeyRelease(CdmKeySetId key_set_id,
@@ -1948,7 +1946,7 @@ class WvCdmRequestLicenseTest : public WvCdmTestBase {
 
   void Provision(const CdmIdentifier& identifier, SecurityLevel level) {
     TestWvCdmClientPropertySet property_set_L3;
-    TestWvCdmClientPropertySet* property_set = NULL;
+    TestWvCdmClientPropertySet* property_set = nullptr;
 
     if (kLevel3 == level) {
       property_set_L3.set_security_level(QUERY_VALUE_SECURITY_LEVEL_L3);
@@ -1956,7 +1954,7 @@ class WvCdmRequestLicenseTest : public WvCdmTestBase {
     }
 
     CdmResponseType status = decryptor_->OpenSession(
-        config_.key_system(), property_set, identifier, NULL, &session_id_);
+        config_.key_system(), property_set, identifier, nullptr, &session_id_);
     switch (status) {
       case NO_ERROR:
         decryptor_->CloseSession(session_id_);
@@ -1993,10 +1991,9 @@ class WvCdmRequestLicenseTest : public WvCdmTestBase {
   }
 
   std::string GetSecurityLevel(TestWvCdmClientPropertySet* property_set) {
-    EXPECT_EQ(NO_ERROR,
-              decryptor_->OpenSession(config_.key_system(), property_set,
-                                     kDefaultCdmIdentifier, NULL,
-                                     &session_id_));
+    EXPECT_EQ(NO_ERROR, decryptor_->OpenSession(
+                            config_.key_system(), property_set,
+                            kDefaultCdmIdentifier, nullptr, &session_id_));
     CdmQueryMap query_info;
     EXPECT_EQ(wvcdm::NO_ERROR,
               decryptor_->QuerySessionStatus(session_id_, &query_info));
@@ -2012,7 +2009,7 @@ class WvCdmRequestLicenseTest : public WvCdmTestBase {
   }
 
   CdmSecurityLevel GetDefaultSecurityLevel() {
-    std::string level = GetSecurityLevel(NULL).c_str();
+    std::string level = GetSecurityLevel(nullptr).c_str();
     CdmSecurityLevel security_level = kSecurityLevelUninitialized;
     if (level.compare(wvcdm::QUERY_VALUE_SECURITY_LEVEL_L1) == 0) {
       security_level = kSecurityLevelL1;
@@ -2046,10 +2043,10 @@ class WvCdmRequestLicenseTest : public WvCdmTestBase {
 
 TEST_F(WvCdmRequestLicenseTest, ProvisioningTest) {
   Unprovision();
-  EXPECT_EQ(NEED_PROVISIONING,
-              decryptor_->OpenSession(config_.key_system(), NULL,
-                                      kDefaultCdmIdentifier, NULL,
-                                      &session_id_));
+  EXPECT_EQ(
+      NEED_PROVISIONING,
+      decryptor_->OpenSession(config_.key_system(), nullptr,
+                              kDefaultCdmIdentifier, nullptr, &session_id_));
   std::string provisioning_server;
   CdmCertificateType cert_type = kCertificateWidevine;
   std::string cert_authority, cert, wrapped_key;
@@ -2074,9 +2071,8 @@ TEST_F(WvCdmRequestLicenseTest, ProvisioningTest) {
 
 TEST_F(WvCdmRequestLicenseTest, ProvisioningTestWithServiceCertificate) {
   CdmResponseType status =
-      decryptor_->OpenSession(config_.key_system(), NULL,
-                              kDefaultCdmIdentifier, NULL,
-                              &session_id_);
+      decryptor_->OpenSession(config_.key_system(), nullptr,
+                              kDefaultCdmIdentifier, nullptr, &session_id_);
   EXPECT_TRUE(status == NEED_PROVISIONING || status == NO_ERROR)
       << "Failure to open session. error: " << status;
   std::string provisioning_server;
@@ -2106,7 +2102,7 @@ TEST_F(WvCdmRequestLicenseTest, L3ProvisioningTest) {
   property_set_L3.set_security_level(QUERY_VALUE_SECURITY_LEVEL_L3);
   CdmResponseType status =
       decryptor_->OpenSession(config_.key_system(), &property_set_L3,
-                              kDefaultCdmIdentifier, NULL, &session_id_);
+                              kDefaultCdmIdentifier, nullptr, &session_id_);
   EXPECT_TRUE(status == NEED_PROVISIONING || status == NO_ERROR)
       << "Failure to open session. error: " << status;
   std::string provisioning_server;
@@ -2136,17 +2132,15 @@ TEST_F(WvCdmRequestLicenseTest, PerOriginProvisioningTest) {
             decryptor_->Unprovision(kSecurityLevelL3, kExampleIdentifier));
 
   // Verify the global identifier is provisioned.
-  EXPECT_EQ(wvcdm::NO_ERROR,
-            decryptor_->OpenSession(config_.key_system(), NULL,
-                                    kDefaultCdmIdentifier,
-                                    NULL, &session_id_));
+  EXPECT_EQ(wvcdm::NO_ERROR, decryptor_->OpenSession(
+                                 config_.key_system(), nullptr,
+                                 kDefaultCdmIdentifier, nullptr, &session_id_));
   decryptor_->CloseSession(session_id_);
 
   // The other identifier should not be provisioned.
-  EXPECT_EQ(
-      wvcdm::NEED_PROVISIONING,
-      decryptor_->OpenSession(config_.key_system(), NULL, kExampleIdentifier,
-                              NULL, &session_id_));
+  EXPECT_EQ(wvcdm::NEED_PROVISIONING,
+            decryptor_->OpenSession(config_.key_system(), nullptr,
+                                    kExampleIdentifier, nullptr, &session_id_));
 }
 
 TEST_F(WvCdmRequestLicenseTest, PerOriginProvisioningSupportsOldPaths) {
@@ -2199,8 +2193,8 @@ TEST_F(WvCdmRequestLicenseTest, UnprovisionTest) {
 }
 
 TEST_F(WvCdmRequestLicenseTest, ProvisioningInterposedRetryTest) {
-  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                          NULL, &session_id_);
+  decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                          nullptr, &session_id_);
   std::string provisioning_server;
   CdmCertificateType cert_type = kCertificateWidevine;
   std::string cert_authority, cert, wrapped_key;
@@ -2243,8 +2237,8 @@ TEST_F(WvCdmRequestLicenseTest, ProvisioningInterposedRetryTest) {
 }
 
 TEST_F(WvCdmRequestLicenseTest, ProvisioningInterspersedRetryTest) {
-  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                          NULL, &session_id_);
+  decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                          nullptr, &session_id_);
   std::string provisioning_server;
   CdmCertificateType cert_type = kCertificateWidevine;
   std::string cert_authority, cert, wrapped_key;
@@ -2324,8 +2318,8 @@ TEST_F(WvCdmRequestLicenseTest, ProvisioningInterspersedRetryTest) {
 }
 
 TEST_F(WvCdmRequestLicenseTest, DISABLED_X509ProvisioningTest) {
-  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, NULL,
-                         &session_id_);
+  decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                          nullptr, &session_id_);
   std::string provisioning_server;
   CdmCertificateType cert_type = kCertificateX509;
   // TODO(rfrias): insert appropriate CA here
@@ -2360,14 +2354,14 @@ TEST_F(WvCdmRequestLicenseTest, PropertySetTest) {
 
   property_set_L1.set_security_level(QUERY_VALUE_SECURITY_LEVEL_L1);
   property_set_L1.set_use_privacy_mode(true);
-  decryptor_->OpenSession(config_.key_system(), &property_set_L1, kDefaultCdmIdentifier,
-                         NULL, &session_id_L1);
+  decryptor_->OpenSession(config_.key_system(), &property_set_L1,
+                          kDefaultCdmIdentifier, nullptr, &session_id_L1);
   property_set_L3.set_security_level(QUERY_VALUE_SECURITY_LEVEL_L3);
   property_set_L3.set_use_privacy_mode(false);
 
-  CdmResponseType sts = decryptor_->OpenSession(
-      config_.key_system(), &property_set_L3, kDefaultCdmIdentifier, NULL,
-      &session_id_L3);
+  CdmResponseType sts =
+      decryptor_->OpenSession(config_.key_system(), &property_set_L3,
+                              kDefaultCdmIdentifier, nullptr, &session_id_L3);
 
   if (NEED_PROVISIONING == sts) {
     std::string provisioning_server;
@@ -2384,17 +2378,16 @@ TEST_F(WvCdmRequestLicenseTest, PropertySetTest) {
     EXPECT_EQ(NO_ERROR, decryptor_->HandleProvisioningResponse(
                             kDefaultCdmIdentifier, response, &cert,
                             &wrapped_key));
-    EXPECT_EQ(NO_ERROR,
-              decryptor_->OpenSession(config_.key_system(), &property_set_L3,
-                                      kDefaultCdmIdentifier, NULL,
-                                      &session_id_L3));
+    EXPECT_EQ(NO_ERROR, decryptor_->OpenSession(
+                            config_.key_system(), &property_set_L3,
+                            kDefaultCdmIdentifier, nullptr, &session_id_L3));
   } else {
     EXPECT_EQ(NO_ERROR, sts);
   }
 
   property_set_Ln.set_security_level("");
   decryptor_->OpenSession(config_.key_system(), &property_set_Ln,
-                          kDefaultCdmIdentifier, NULL, &session_id_Ln);
+                          kDefaultCdmIdentifier, nullptr, &session_id_Ln);
 
   CdmQueryMap query_info;
   EXPECT_EQ(wvcdm::NO_ERROR,
@@ -2444,9 +2437,10 @@ TEST_F(WvCdmRequestLicenseTest, ForceL3Test) {
   EXPECT_TRUE(handle.Init(kSecurityLevelL3));
   EXPECT_TRUE(handle.DeleteAllFiles());
 
-  EXPECT_EQ(NEED_PROVISIONING,
-            decryptor_->OpenSession(config_.key_system(), &property_set,
-                                    kDefaultCdmIdentifier, NULL, &session_id_));
+  EXPECT_EQ(
+      NEED_PROVISIONING,
+      decryptor_->OpenSession(config_.key_system(), &property_set,
+                              kDefaultCdmIdentifier, nullptr, &session_id_));
   std::string provisioning_server;
   CdmCertificateType cert_type = kCertificateWidevine;
   std::string cert_authority, cert, wrapped_key;
@@ -2462,9 +2456,9 @@ TEST_F(WvCdmRequestLicenseTest, ForceL3Test) {
                           kDefaultCdmIdentifier, response, &cert,
                           &wrapped_key));
 
-  EXPECT_EQ(NO_ERROR,
-            decryptor_->OpenSession(config_.key_system(), &property_set,
-                                    kDefaultCdmIdentifier, NULL, &session_id_));
+  EXPECT_EQ(NO_ERROR, decryptor_->OpenSession(
+                          config_.key_system(), &property_set,
+                          kDefaultCdmIdentifier, nullptr, &session_id_));
   GenerateKeyRequest(binary_key_id(), kLicenseTypeStreaming);
   VerifyKeyRequestResponse(config_.license_server(), config_.client_auth());
   decryptor_->CloseSession(session_id_);
@@ -2474,8 +2468,8 @@ TEST_F(WvCdmRequestLicenseTest, PrivacyModeTest) {
   TestWvCdmClientPropertySet property_set;
 
   property_set.set_use_privacy_mode(true);
-  decryptor_->OpenSession(config_.key_system(), &property_set, kDefaultCdmIdentifier,
-                         NULL, &session_id_);
+  decryptor_->OpenSession(config_.key_system(), &property_set,
+                          kDefaultCdmIdentifier, nullptr, &session_id_);
 
   GenerateKeyRequest(binary_key_id(), kLicenseTypeStreaming);
   std::string resp = GetKeyRequestResponse(config_.license_server(), config_.client_auth());
@@ -2495,24 +2489,24 @@ TEST_F(WvCdmRequestLicenseTest, PrivacyModeWithServiceCertificateTest) {
   property_set.set_use_privacy_mode(true);
   property_set.set_service_certificate(config_.license_service_certificate());
   // TODO: pass config_.service_certificate() into CdmEngine::SetServiceCertificate()
-  decryptor_->OpenSession(config_.key_system(), &property_set, kDefaultCdmIdentifier,
-                         NULL, &session_id_);
+  decryptor_->OpenSession(config_.key_system(), &property_set,
+                          kDefaultCdmIdentifier, nullptr, &session_id_);
   GenerateKeyRequest(binary_key_id(), kLicenseTypeStreaming);
   VerifyKeyRequestResponse(config_.license_server(), config_.client_auth());
   decryptor_->CloseSession(session_id_);
 }
 
 TEST_F(WvCdmRequestLicenseTest, BaseMessageTest) {
-  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, NULL,
-                         &session_id_);
+  decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                          nullptr, &session_id_);
   GenerateKeyRequest(binary_key_id(), kLicenseTypeStreaming);
   GetKeyRequestResponse(config_.license_server(), config_.client_auth());
   decryptor_->CloseSession(session_id_);
 }
 
 TEST_F(WvCdmRequestLicenseTest, AddStreamingKeyTest) {
-  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, NULL,
-                         &session_id_);
+  decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                          nullptr, &session_id_);
   GenerateKeyRequest(binary_key_id(), kLicenseTypeStreaming);
   VerifyKeyRequestResponse(config_.license_server(), config_.client_auth());
   decryptor_->CloseSession(session_id_);
@@ -2527,8 +2521,8 @@ TEST_F(WvCdmRequestLicenseTest, AddKeyOfflineTest) {
   std::string client_auth;
   GetOfflineConfiguration(&key_id, &client_auth);
 
-  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, NULL,
-                         &session_id_);
+  decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                          nullptr, &session_id_);
   GenerateKeyRequest(key_id, kLicenseTypeOffline);
   VerifyKeyRequestResponse(config_.license_server(), client_auth);
   decryptor_->CloseSession(session_id_);
@@ -2543,8 +2537,8 @@ TEST_F(WvCdmRequestLicenseTest, RestoreOfflineKeyTest) {
   std::string client_auth;
   GetOfflineConfiguration(&key_id, &client_auth);
 
-  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, NULL,
-                         &session_id_);
+  decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                          nullptr, &session_id_);
   GenerateKeyRequest(key_id, kLicenseTypeOffline);
   VerifyKeyRequestResponse(config_.license_server(), client_auth);
 
@@ -2553,8 +2547,8 @@ TEST_F(WvCdmRequestLicenseTest, RestoreOfflineKeyTest) {
   decryptor_->CloseSession(session_id_);
 
   session_id_.clear();
-  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, NULL,
-                         &session_id_);
+  decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                          nullptr, &session_id_);
   EXPECT_EQ(wvcdm::KEY_ADDED, decryptor_->RestoreKey(session_id_, key_set_id));
   decryptor_->CloseSession(session_id_);
 }
@@ -2568,8 +2562,8 @@ TEST_F(WvCdmRequestLicenseTest, ReleaseOfflineKeyTest) {
   std::string client_auth;
   GetOfflineConfiguration(&key_id, &client_auth);
 
-  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, NULL,
-                         &session_id_);
+  decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                          nullptr, &session_id_);
   GenerateKeyRequest(key_id, kLicenseTypeOffline);
   VerifyKeyRequestResponse(config_.license_server(), client_auth);
 
@@ -2579,8 +2573,8 @@ TEST_F(WvCdmRequestLicenseTest, ReleaseOfflineKeyTest) {
 
   session_id_.clear();
   key_set_id_.clear();
-  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, NULL,
-                         &session_id_);
+  decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                          nullptr, &session_id_);
   EXPECT_EQ(wvcdm::KEY_ADDED, decryptor_->RestoreKey(session_id_, key_set_id));
   decryptor_->CloseSession(session_id_);
 
@@ -2604,8 +2598,8 @@ TEST_F(WvCdmRequestLicenseTest, ReleaseOfflineKeySessionUsageDisabledTest) {
   GetOfflineConfiguration(&key_id, &client_auth);
   key_id[key_id.size()-1] = '1';
 
-  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                          NULL, &session_id_);
+  decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                          nullptr, &session_id_);
   GenerateKeyRequest(key_id, kLicenseTypeOffline);
   VerifyKeyRequestResponse(config_.license_server(), client_auth);
 
@@ -2615,15 +2609,15 @@ TEST_F(WvCdmRequestLicenseTest, ReleaseOfflineKeySessionUsageDisabledTest) {
 
   session_id_.clear();
   key_set_id_.clear();
-  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                          NULL, &session_id_);
+  decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                          nullptr, &session_id_);
   EXPECT_EQ(wvcdm::KEY_ADDED, decryptor_->RestoreKey(session_id_, key_set_id));
   decryptor_->CloseSession(session_id_);
 
   session_id_.clear();
   key_set_id_.clear();
   CdmKeyMessage key_msg;
-  GenerateKeyRelease(key_set_id, NULL, &key_msg);
+  GenerateKeyRelease(key_set_id, nullptr, &key_msg);
   key_set_id_ = key_set_id;
   VerifyKeyRequestResponse(config_.license_server(), client_auth);
 
@@ -2659,8 +2653,8 @@ TEST_F(WvCdmRequestLicenseTest, ReleaseRetryOfflineKeyTest) {
   std::string client_auth;
   GetOfflineConfiguration(&key_id, &client_auth);
 
-  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                          NULL, &session_id_);
+  decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                          nullptr, &session_id_);
   GenerateKeyRequest(key_id, kLicenseTypeOffline);
   VerifyKeyRequestResponse(config_.license_server(), client_auth);
 
@@ -2670,8 +2664,8 @@ TEST_F(WvCdmRequestLicenseTest, ReleaseRetryOfflineKeyTest) {
 
   session_id_.clear();
   key_set_id_.clear();
-  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                          NULL, &session_id_);
+  decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                          nullptr, &session_id_);
   EXPECT_EQ(wvcdm::KEY_ADDED, decryptor_->RestoreKey(session_id_, key_set_id));
   decryptor_->CloseSession(session_id_);
 
@@ -2680,8 +2674,8 @@ TEST_F(WvCdmRequestLicenseTest, ReleaseRetryOfflineKeyTest) {
   GenerateKeyRelease(key_set_id);
 
   session_id_.clear();
-  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier, NULL,
-                         &session_id_);
+  decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                          nullptr, &session_id_);
   EXPECT_EQ(wvcdm::GET_RELEASED_LICENSE_ERROR,
             decryptor_->RestoreKey(session_id_, key_set_id));
   decryptor_->CloseSession(session_id_);
@@ -2704,8 +2698,9 @@ TEST_F(WvCdmRequestLicenseTest, ReleaseRetryL3OfflineKeyTest) {
   std::string client_auth;
   GetOfflineConfiguration(&key_id, &client_auth);
 
-  CdmResponseType sts = decryptor_->OpenSession(
-      config_.key_system(), &property_set, kDefaultCdmIdentifier, NULL, &session_id_);
+  CdmResponseType sts =
+      decryptor_->OpenSession(config_.key_system(), &property_set,
+                              kDefaultCdmIdentifier, nullptr, &session_id_);
 
   if (NEED_PROVISIONING == sts) {
     std::string provisioning_server;
@@ -2722,16 +2717,15 @@ TEST_F(WvCdmRequestLicenseTest, ReleaseRetryL3OfflineKeyTest) {
     EXPECT_EQ(NO_ERROR, decryptor_->HandleProvisioningResponse(
                             kDefaultCdmIdentifier, response, &cert,
                             &wrapped_key));
-    EXPECT_EQ(NO_ERROR,
-              decryptor_->OpenSession(config_.key_system(), &property_set,
-                                     kDefaultCdmIdentifier, NULL,
-                                     &session_id_));
+    EXPECT_EQ(NO_ERROR, decryptor_->OpenSession(
+                            config_.key_system(), &property_set,
+                            kDefaultCdmIdentifier, nullptr, &session_id_));
   } else {
     EXPECT_EQ(NO_ERROR, sts);
   }
 
-  decryptor_->OpenSession(config_.key_system(), &property_set, kDefaultCdmIdentifier,
-                         NULL, &session_id_);
+  decryptor_->OpenSession(config_.key_system(), &property_set,
+                          kDefaultCdmIdentifier, nullptr, &session_id_);
   GenerateKeyRequest(key_id, kLicenseTypeOffline, &property_set);
   VerifyKeyRequestResponse(config_.license_server(), client_auth);
 
@@ -2741,25 +2735,25 @@ TEST_F(WvCdmRequestLicenseTest, ReleaseRetryL3OfflineKeyTest) {
 
   session_id_.clear();
   key_set_id_.clear();
-  decryptor_->OpenSession(config_.key_system(), &property_set, kDefaultCdmIdentifier,
-                         NULL, &session_id_);
+  decryptor_->OpenSession(config_.key_system(), &property_set,
+                          kDefaultCdmIdentifier, nullptr, &session_id_);
   EXPECT_EQ(wvcdm::KEY_ADDED, decryptor_->RestoreKey(session_id_, key_set_id));
   decryptor_->CloseSession(session_id_);
 
   session_id_.clear();
   key_set_id_.clear();
-  GenerateKeyRelease(key_set_id, &property_set, NULL);
+  GenerateKeyRelease(key_set_id, &property_set, nullptr);
 
   session_id_.clear();
-  decryptor_->OpenSession(config_.key_system(), &property_set, kDefaultCdmIdentifier,
-                         NULL, &session_id_);
+  decryptor_->OpenSession(config_.key_system(), &property_set,
+                          kDefaultCdmIdentifier, nullptr, &session_id_);
   EXPECT_EQ(wvcdm::GET_RELEASED_LICENSE_ERROR,
             decryptor_->RestoreKey(session_id_, key_set_id));
   decryptor_->CloseSession(session_id_);
 
   session_id_.clear();
   key_set_id_.clear();
-  GenerateKeyRelease(key_set_id, &property_set, NULL);
+  GenerateKeyRelease(key_set_id, &property_set, nullptr);
   key_set_id_ = key_set_id;
   VerifyKeyRequestResponse(config_.license_server(), client_auth);
 }
@@ -2780,8 +2774,9 @@ TEST_F(WvCdmRequestLicenseTest,
   GetOfflineConfiguration(&key_id, &client_auth);
   key_id[key_id.size()-1] = '1';
 
-  CdmResponseType sts = decryptor_->OpenSession(
-      config_.key_system(), &property_set, kDefaultCdmIdentifier, NULL, &session_id_);
+  CdmResponseType sts =
+      decryptor_->OpenSession(config_.key_system(), &property_set,
+                              kDefaultCdmIdentifier, nullptr, &session_id_);
 
   if (NEED_PROVISIONING == sts) {
     std::string provisioning_server_url;
@@ -2798,16 +2793,15 @@ TEST_F(WvCdmRequestLicenseTest,
     EXPECT_EQ(NO_ERROR, decryptor_->HandleProvisioningResponse(
                             kDefaultCdmIdentifier, response, &cert,
                             &wrapped_key));
-    EXPECT_EQ(NO_ERROR,
-              decryptor_->OpenSession(config_.key_system(), &property_set,
-                                      kDefaultCdmIdentifier, NULL,
-                                      &session_id_));
+    EXPECT_EQ(NO_ERROR, decryptor_->OpenSession(
+                            config_.key_system(), &property_set,
+                            kDefaultCdmIdentifier, nullptr, &session_id_));
   } else {
     EXPECT_EQ(NO_ERROR, sts);
   }
 
   decryptor_->OpenSession(config_.key_system(), &property_set,
-                          kDefaultCdmIdentifier, NULL, &session_id_);
+                          kDefaultCdmIdentifier, nullptr, &session_id_);
   GenerateKeyRequest(key_id, kLicenseTypeOffline, &property_set);
   VerifyKeyRequestResponse(config_.license_server(), client_auth);
 
@@ -2817,25 +2811,25 @@ TEST_F(WvCdmRequestLicenseTest,
 
   session_id_.clear();
   key_set_id_.clear();
-  decryptor_->OpenSession(config_.key_system(), &property_set, kDefaultCdmIdentifier,
-                         NULL, &session_id_);
+  decryptor_->OpenSession(config_.key_system(), &property_set,
+                          kDefaultCdmIdentifier, nullptr, &session_id_);
   EXPECT_EQ(wvcdm::KEY_ADDED, decryptor_->RestoreKey(session_id_, key_set_id));
   decryptor_->CloseSession(session_id_);
 
   session_id_.clear();
   key_set_id_.clear();
-  GenerateKeyRelease(key_set_id, &property_set, NULL);
+  GenerateKeyRelease(key_set_id, &property_set, nullptr);
 
   session_id_.clear();
-  decryptor_->OpenSession(config_.key_system(), &property_set, kDefaultCdmIdentifier,
-                         NULL, &session_id_);
+  decryptor_->OpenSession(config_.key_system(), &property_set,
+                          kDefaultCdmIdentifier, nullptr, &session_id_);
   EXPECT_EQ(wvcdm::GET_RELEASED_LICENSE_ERROR,
             decryptor_->RestoreKey(session_id_, key_set_id));
   decryptor_->CloseSession(session_id_);
 
   session_id_.clear();
   key_set_id_.clear();
-  GenerateKeyRelease(key_set_id, &property_set, NULL);
+  GenerateKeyRelease(key_set_id, &property_set, nullptr);
   key_set_id_ = key_set_id;
   VerifyKeyRequestResponse(config_.license_server(), client_auth);
 }
@@ -2852,8 +2846,8 @@ TEST_F(WvCdmRequestLicenseTest, AutomatedOfflineSessionReleaseTest) {
   std::string client_auth;
   GetOfflineConfiguration(&key_id, &client_auth);
 
-  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                          NULL, &session_id_);
+  decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                          nullptr, &session_id_);
   GenerateKeyRequest(key_id, kLicenseTypeOffline);
   VerifyKeyRequestResponse(config_.license_server(), client_auth);
 
@@ -2863,8 +2857,8 @@ TEST_F(WvCdmRequestLicenseTest, AutomatedOfflineSessionReleaseTest) {
 
   session_id_.clear();
   key_set_id_.clear();
-  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                          NULL, &session_id_);
+  decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                          nullptr, &session_id_);
   EXPECT_EQ(wvcdm::KEY_ADDED, decryptor_->RestoreKey(session_id_, key_set_id));
   decryptor_->CloseSession(session_id_);
 
@@ -2897,8 +2891,8 @@ TEST_F(WvCdmRequestLicenseTest, AutomatedOfflineSessionReleaseTest) {
 }
 
 TEST_F(WvCdmRequestLicenseTest, StreamingLicenseRenewal) {
-  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                          NULL, &session_id_);
+  decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                          nullptr, &session_id_);
   GenerateKeyRequest(binary_key_id(), kLicenseTypeStreaming);
   VerifyKeyRequestResponse(config_.license_server(), config_.client_auth());
 
@@ -2910,8 +2904,8 @@ TEST_F(WvCdmRequestLicenseTest, StreamingLicenseRenewal) {
 }
 
 TEST_F(WvCdmRequestLicenseTest, StreamingLicenseRenewalProhibited) {
-  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                          NULL, &session_id_);
+  decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                          nullptr, &session_id_);
   std::string key_id = a2bs_hex(                  // streaming_clip11
       "000000437073736800000000"                  // blob size and pssh
       "EDEF8BA979D64ACEA3C827DCD51D21ED00000023"  // Widevine system id
@@ -2926,7 +2920,7 @@ TEST_F(WvCdmRequestLicenseTest, StreamingLicenseRenewalProhibited) {
   EXPECT_EQ(wvcdm::LICENSE_RENEWAL_PROHIBITED,
             decryptor_->GenerateKeyRequest(
                 session_id_, key_set_id_, "video/mp4", init_data,
-                kLicenseTypeStreaming, app_parameters, NULL,
+                kLicenseTypeStreaming, app_parameters, nullptr,
                 kDefaultCdmIdentifier, &key_request));
   key_msg_ = key_request.message;
   decryptor_->CloseSession(session_id_);
@@ -2941,8 +2935,8 @@ TEST_F(WvCdmRequestLicenseTest, OfflineLicenseRenewal) {
   std::string client_auth;
   GetOfflineConfiguration(&key_id, &client_auth);
 
-  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                          NULL, &session_id_);
+  decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                          nullptr, &session_id_);
   GenerateKeyRequest(key_id, kLicenseTypeOffline);
   VerifyKeyRequestResponse(config_.license_server(), client_auth);
 
@@ -2963,8 +2957,8 @@ TEST_F(WvCdmRequestLicenseTest, OfflineLicenseRenewalAndRelease) {
   GetOfflineConfiguration(&key_id, &client_auth);
 
   // Retrieve offline license
-  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                          NULL, &session_id_);
+  decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                          nullptr, &session_id_);
   GenerateKeyRequest(key_id, kLicenseTypeOffline);
   VerifyKeyRequestResponse(config_.license_server(), client_auth);
 
@@ -2991,8 +2985,8 @@ TEST_F(WvCdmRequestLicenseTest, OfflineLicenseRenewalAndRelease) {
   session_id_.clear();
 
   // Restore offline license and renew it
-  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                          NULL, &session_id_);
+  decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                          nullptr, &session_id_);
   EXPECT_EQ(wvcdm::KEY_ADDED, decryptor_->RestoreKey(session_id_, key_set_id));
 
   std::string license_server;
@@ -3011,8 +3005,8 @@ TEST_F(WvCdmRequestLicenseTest, OfflineLicenseRenewalAndRelease) {
   session_id_.clear();
 
   // Restore offline license and test it
-  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                          NULL, &session_id_);
+  decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                          nullptr, &session_id_);
   EXPECT_EQ(wvcdm::KEY_ADDED, decryptor_->RestoreKey(session_id_, key_set_id));
 
   // Verify that we can decrypt a subsample
@@ -3038,8 +3032,8 @@ class WvCdmEntitlementTest
 
 TEST_P(WvCdmEntitlementTest, EntitlementWithKeyRotation) {
   EntitlementTestConfiguration* config = GetParam();
-  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                          NULL, &session_id_);
+  decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                          nullptr, &session_id_);
 
   // Fetch entitlement license
   GenerateKeyRequest(config->entitlement_pssh, kLicenseTypeStreaming);
@@ -3066,9 +3060,9 @@ INSTANTIATE_TEST_CASE_P(
                      &kEntitlementTestConfiguration[2]));
 
 TEST_F(WvCdmRequestLicenseTest, RemoveKeys) {
-  ASSERT_EQ(NO_ERROR, decryptor_->OpenSession(config_.key_system(), NULL,
-                                              kDefaultCdmIdentifier, NULL,
-                                             &session_id_));
+  ASSERT_EQ(NO_ERROR, decryptor_->OpenSession(config_.key_system(), nullptr,
+                                              kDefaultCdmIdentifier, nullptr,
+                                              &session_id_));
   GenerateKeyRequest(binary_key_id(), kLicenseTypeStreaming);
   VerifyKeyRequestResponse(config_.license_server(), config_.client_auth());
 
@@ -3135,7 +3129,7 @@ TEST_P(WvCdmStreamingLicenseRenewalTest, WithClientId) {
   }
   // TODO: pass config_.service_certificate() into CdmEngine::SetServiceCertificate()
   decryptor_->OpenSession(config_.key_system(), &property_set,
-                          kDefaultCdmIdentifier, NULL, &session_id_);
+                          kDefaultCdmIdentifier, nullptr, &session_id_);
   GenerateKeyRequest(key_id, app_parameters, kLicenseTypeStreaming,
                      &property_set);
   if (config->enable_privacy_mode && !config->specify_service_certificate) {
@@ -3266,8 +3260,8 @@ TEST_P(WvCdmOfflineLicenseReleaseTest, WithClientId) {
   }
   // TODO: pass config_.service_certificate() into CdmEngine::SetServiceCertificate()
   decryptor_->OpenSession(config_.key_system(), &property_set,
-                          kDefaultCdmIdentifier, NULL, &session_id_);
-  GenerateKeyRequest(key_id, app_parameters, kLicenseTypeOffline, NULL);
+                          kDefaultCdmIdentifier, nullptr, &session_id_);
+  GenerateKeyRequest(key_id, app_parameters, kLicenseTypeOffline, nullptr);
   if (config->enable_privacy_mode && !config->specify_service_certificate) {
     std::string resp = GetKeyRequestResponse(config_.license_server(),
                                              client_auth);
@@ -3304,7 +3298,7 @@ TEST_P(WvCdmOfflineLicenseReleaseTest, WithClientId) {
   key_set_id_.clear();
 
   decryptor_->OpenSession(config_.key_system(), &property_set,
-                          kDefaultCdmIdentifier, NULL, &session_id_);
+                          kDefaultCdmIdentifier, nullptr, &session_id_);
   EXPECT_EQ(wvcdm::KEY_ADDED, decryptor_->RestoreKey(session_id_, key_set_id));
   decryptor_->CloseSession(session_id_);
 
@@ -3405,7 +3399,7 @@ TEST_P(WvCdmUsageTest, WithClientId) {
 
   SubSampleInfo* data = &usage_info_sub_samples_icp[0];
   decryptor_->OpenSession(config_.key_system(), &property_set,
-                          kDefaultCdmIdentifier, NULL, &session_id_);
+                          kDefaultCdmIdentifier, nullptr, &session_id_);
 
   GenerateKeyRequest(key_id, app_parameters, kLicenseTypeStreaming,
                      &property_set);
@@ -3508,15 +3502,15 @@ TEST_F(WvCdmRequestLicenseTest, UsageInfoRetryTest) {
                   &psts));
 
   SubSampleInfo* data = &usage_info_sub_samples_icp[0];
-  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                          NULL, &session_id_);
+  decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                          nullptr, &session_id_);
   std::string key_id = a2bs_hex(
       "000000427073736800000000"                  // blob size and pssh
       "EDEF8BA979D64ACEA3C827DCD51D21ED00000022"  // Widevine system id
       "08011a0d7769646576696e655f74657374220f73"  // pssh data
       "747265616d696e675f636c697033");
 
-  GenerateKeyRequest(key_id, kLicenseTypeStreaming, NULL);
+  GenerateKeyRequest(key_id, kLicenseTypeStreaming, nullptr);
   VerifyUsageKeyRequestResponse(config_.license_server(), config_.client_auth());
 
   std::vector<uint8_t> decrypt_buffer(data->encrypt_data.size());
@@ -3588,11 +3582,11 @@ TEST_F(WvCdmRequestLicenseTest, UsageInfo_ReleaseThreeRecords) {
   std::string session_id_clip3, session_id_clip4, session_id_clip7;
 
   // Open session for streaming_clip3 and verify decryption is successful
-  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                          NULL, &session_id_clip3);
+  decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                          nullptr, &session_id_clip3);
 
   session_id_ = session_id_clip3;
-  GenerateKeyRequest(kPsshStreamingClip3, kLicenseTypeStreaming, NULL);
+  GenerateKeyRequest(kPsshStreamingClip3, kLicenseTypeStreaming, nullptr);
   VerifyUsageKeyRequestResponse(config_.license_server(),
                                 config_.client_auth());
 
@@ -3600,11 +3594,11 @@ TEST_F(WvCdmRequestLicenseTest, UsageInfo_ReleaseThreeRecords) {
                                usage_info_sub_samples_icp[0]));
 
   // Open session for streaming_clip4 and verify decryption is successful
-  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                          NULL, &session_id_clip4);
+  decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                          nullptr, &session_id_clip4);
 
   session_id_ = session_id_clip4;
-  GenerateKeyRequest(kPsshStreamingClip4, kLicenseTypeStreaming, NULL);
+  GenerateKeyRequest(kPsshStreamingClip4, kLicenseTypeStreaming, nullptr);
   VerifyUsageKeyRequestResponse(config_.license_server(),
                                 config_.client_auth());
 
@@ -3612,11 +3606,11 @@ TEST_F(WvCdmRequestLicenseTest, UsageInfo_ReleaseThreeRecords) {
                                usage_info_sub_samples_icp[1]));
 
   // Open session for streaming_clip7 and verify decryption is successful
-  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                          NULL, &session_id_clip7);
+  decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                          nullptr, &session_id_clip7);
 
   session_id_ = session_id_clip7;
-  GenerateKeyRequest(kPsshStreamingClip7, kLicenseTypeStreaming, NULL);
+  GenerateKeyRequest(kPsshStreamingClip7, kLicenseTypeStreaming, nullptr);
   VerifyUsageKeyRequestResponse(config_.license_server(),
                                 config_.client_auth());
 
@@ -3670,7 +3664,7 @@ TEST_P(WvCdmUsageInfoTest, UsageInfo) {
 
   UsageInfoSubSampleInfo* usage_info_data = GetParam();
   TestWvCdmClientPropertySet client_property_set;
-  TestWvCdmClientPropertySet* property_set = NULL;
+  TestWvCdmClientPropertySet* property_set = nullptr;
   if (kLevel3 == usage_info_data->security_level) {
     client_property_set.set_security_level(QUERY_VALUE_SECURITY_LEVEL_L3);
     property_set = &client_property_set;
@@ -3692,7 +3686,7 @@ TEST_P(WvCdmUsageInfoTest, UsageInfo) {
   for (size_t i = 0; i < usage_info_data->usage_info; ++i) {
     SubSampleInfo* data = usage_info_data->sub_sample + i;
     decryptor_->OpenSession(config_.key_system(), property_set,
-                            kDefaultCdmIdentifier, NULL, &session_id_);
+                            kDefaultCdmIdentifier, nullptr, &session_id_);
     std::string key_id = a2bs_hex(
         "000000427073736800000000"                  // blob size and pssh
         "EDEF8BA979D64ACEA3C827DCD51D21ED00000022"  // Widevine system id
@@ -3779,7 +3773,7 @@ TEST_F(WvCdmRequestLicenseTest, UsageRemoveAllTest) {
     SubSampleInfo* data = usage_info_sub_samples_icp + i;
     property_set.set_app_id(i % 2 == 0 ? app_id_empty : app_id_not_empty);
     decryptor_->OpenSession(config_.key_system(), &property_set,
-                            kDefaultCdmIdentifier, NULL, &session_id_);
+                            kDefaultCdmIdentifier, nullptr, &session_id_);
     std::string key_id = a2bs_hex(
         "000000427073736800000000"                  // blob size and pssh
         "EDEF8BA979D64ACEA3C827DCD51D21ED00000022"  // Widevine system id
@@ -3877,7 +3871,7 @@ TEST_F(WvCdmRequestLicenseTest, RemoveCorruptedUsageInfoTest) {
     SubSampleInfo* data = usage_info_sub_samples_icp + i;
     property_set.set_app_id(i % 2 == 0 ? app_id_empty : app_id_not_empty);
     decryptor_->OpenSession(config_.key_system(), &property_set,
-                            kDefaultCdmIdentifier, NULL, &session_id_);
+                            kDefaultCdmIdentifier, nullptr, &session_id_);
     std::string key_id = a2bs_hex(
         "000000427073736800000000"                  // blob size and pssh
         "EDEF8BA979D64ACEA3C827DCD51D21ED00000022"  // Widevine system id
@@ -3934,7 +3928,7 @@ TEST_F(WvCdmRequestLicenseTest, RemoveCorruptedUsageInfoTest) {
   std::unique_ptr<File> file =
       file_system.Open(usage_info_not_empty_app_id_file_name,
                        FileSystem::kReadOnly);
-  EXPECT_TRUE(NULL != file);
+  EXPECT_TRUE(nullptr != file);
   std::string file_data;
   file_data.resize(file_size);
   ssize_t bytes = file->Read(&file_data[0], file_data.size());
@@ -3945,7 +3939,7 @@ TEST_F(WvCdmRequestLicenseTest, RemoveCorruptedUsageInfoTest) {
   memset(&file_data[0]+bytes-4, 0, 4);
   file = file_system.Open(usage_info_not_empty_app_id_file_name,
                           FileSystem::kCreate | FileSystem::kTruncate);
-  EXPECT_TRUE(NULL != file);
+  EXPECT_TRUE(nullptr != file);
   bytes = file->Write(file_data.data(), file_data.size());
   EXPECT_EQ(file_size, bytes);
 
@@ -3972,7 +3966,7 @@ TEST_F(WvCdmRequestLicenseTest, RemoveCorruptedUsageInfoTest) {
   EXPECT_LT(4, file_size);
   file = file_system.Open(usage_info_empty_app_id_file_name,
                           FileSystem::kReadOnly);
-  EXPECT_TRUE(NULL != file);
+  EXPECT_TRUE(nullptr != file);
   file_data.resize(file_size);
   bytes = file->Read(&file_data[0], file_data.size());
   EXPECT_EQ(file_size, bytes);
@@ -3982,7 +3976,7 @@ TEST_F(WvCdmRequestLicenseTest, RemoveCorruptedUsageInfoTest) {
   memset(&file_data[0]+bytes-4, 0, 4);
   file = file_system.Open(usage_info_empty_app_id_file_name,
                           FileSystem::kCreate | FileSystem::kTruncate);
-  EXPECT_TRUE(NULL != file);
+  EXPECT_TRUE(nullptr != file);
   bytes = file->Write(file_data.data(), file_data.size());
   EXPECT_EQ(file_size, bytes);
 
@@ -4023,7 +4017,7 @@ TEST_F(WvCdmRequestLicenseTest, RemoveCorruptedUsageInfoTest2) {
     SubSampleInfo* data = usage_info_sub_samples_icp + i;
     property_set.set_app_id(i % 2 == 0 ? app_id_empty : app_id_not_empty);
     decryptor_->OpenSession(config_.key_system(), &property_set,
-                            kDefaultCdmIdentifier, NULL, &session_id_);
+                            kDefaultCdmIdentifier, nullptr, &session_id_);
     std::string key_id = a2bs_hex(
         "000000427073736800000000"                  // blob size and pssh
         "EDEF8BA979D64ACEA3C827DCD51D21ED00000022"  // Widevine system id
@@ -4080,7 +4074,7 @@ TEST_F(WvCdmRequestLicenseTest, RemoveCorruptedUsageInfoTest2) {
   std::unique_ptr<File> file =
       file_system.Open(usage_info_not_empty_app_id_file_name,
                        FileSystem::kReadOnly);
-  EXPECT_TRUE(NULL != file);
+  EXPECT_TRUE(nullptr != file);
   std::string file_data;
   file_data.resize(file_size);
   ssize_t bytes = file->Read(&file_data[0], file_data.size());
@@ -4099,7 +4093,7 @@ TEST_F(WvCdmRequestLicenseTest, RemoveCorruptedUsageInfoTest2) {
 
   file = file_system.Open(usage_info_not_empty_app_id_file_name,
                           FileSystem::kCreate | FileSystem::kTruncate);
-  EXPECT_TRUE(NULL != file);
+  EXPECT_TRUE(nullptr != file);
   bytes = file->Write(file_data.data(), file_data.size());
   EXPECT_EQ(file_size, bytes);
 
@@ -4126,7 +4120,7 @@ TEST_F(WvCdmRequestLicenseTest, RemoveCorruptedUsageInfoTest2) {
   EXPECT_LT(4, file_size);
   file = file_system.Open(usage_info_empty_app_id_file_name,
                           FileSystem::kReadOnly);
-  EXPECT_TRUE(NULL != file);
+  EXPECT_TRUE(nullptr != file);
   file_data.resize(file_size);
   bytes = file->Read(&file_data[0], file_data.size());
   EXPECT_EQ(file_size, bytes);
@@ -4142,7 +4136,7 @@ TEST_F(WvCdmRequestLicenseTest, RemoveCorruptedUsageInfoTest2) {
 
   file = file_system.Open(usage_info_empty_app_id_file_name,
                           FileSystem::kCreate | FileSystem::kTruncate);
-  EXPECT_TRUE(NULL != file);
+  EXPECT_TRUE(nullptr != file);
   bytes = file->Write(file_data.data(), file_data.size());
   EXPECT_EQ(file_size, bytes);
 
@@ -4191,7 +4185,7 @@ TEST_F(WvCdmRequestLicenseTest, GetSecureStopIdsTest) {
 
     property_set.set_app_id(app_id_empty);
     decryptor_->OpenSession(config_.key_system(), &property_set,
-                            kDefaultCdmIdentifier, NULL, &session_id_);
+                            kDefaultCdmIdentifier, nullptr, &session_id_);
     GenerateKeyRequest(kUsageLicenseTestVector1[i].pssh, kLicenseTypeStreaming,
                        &property_set);
 
@@ -4244,9 +4238,9 @@ TEST_F(WvCdmRequestLicenseTest, GetSecureStopIdsTest) {
     SubSampleInfo* data = kUsageLicenseTestVector2[i].sub_sample;
 
     property_set.set_app_id(kExampleIdentifier.app_package_name);
-    EXPECT_EQ(NO_ERROR,
-              decryptor_->OpenSession(config_.key_system(), &property_set,
-                                      kExampleIdentifier, NULL, &session_id_));
+    EXPECT_EQ(NO_ERROR, decryptor_->OpenSession(
+                            config_.key_system(), &property_set,
+                            kExampleIdentifier, nullptr, &session_id_));
     std::string init_data_type = "video/mp4";
     CdmAppParameterMap app_parameters;
     GenerateKeyRequest(wvcdm::KEY_MESSAGE, init_data_type,
@@ -4345,7 +4339,7 @@ TEST_F(WvCdmRequestLicenseTest, UsageRecoveryTest) {
 
   property_set.set_app_id(app_id_empty);
   decryptor_->OpenSession(config_.key_system(), &property_set,
-                          kDefaultCdmIdentifier, NULL, &session_id_);
+                          kDefaultCdmIdentifier, nullptr, &session_id_);
   GenerateKeyRequest(kUsageLicenseTestVector1[0].pssh, kLicenseTypeStreaming,
                      &property_set);
 
@@ -4375,7 +4369,7 @@ TEST_F(WvCdmRequestLicenseTest, UsageRecoveryTest) {
   EXPECT_LT(4, file_size);
   std::unique_ptr<File> file =
       file_system.Open(usage_info_file_name, FileSystem::kReadOnly);
-  EXPECT_TRUE(NULL != file);
+  EXPECT_TRUE(nullptr != file);
   std::string file_data;
   file_data.resize(file_size);
   ssize_t bytes = file->Read(&file_data[0], file_data.size());
@@ -4385,14 +4379,14 @@ TEST_F(WvCdmRequestLicenseTest, UsageRecoveryTest) {
   memset(&file_data[0]+bytes-4, 0, 4);
   file = file_system.Open(usage_info_file_name,
                           FileSystem::kCreate | FileSystem::kTruncate);
-  EXPECT_TRUE(NULL != file);
+  EXPECT_TRUE(nullptr != file);
   bytes = file->Write(file_data.data(), file_data.size());
   EXPECT_EQ(file_size, bytes);
 
   // Fetch a second usage license, this should fail as the usage table is
   // corrupt
   decryptor_->OpenSession(config_.key_system(), &property_set,
-                          kDefaultCdmIdentifier, NULL, &session_id_);
+                          kDefaultCdmIdentifier, nullptr, &session_id_);
   GenerateKeyRequest(kUsageLicenseTestVector1[1].pssh, kLicenseTypeStreaming,
                      &property_set);
 
@@ -4405,7 +4399,7 @@ TEST_F(WvCdmRequestLicenseTest, UsageRecoveryTest) {
 
   // Fetch the second usage license and verify that it is usable
   decryptor_->OpenSession(config_.key_system(), &property_set,
-                          kDefaultCdmIdentifier, NULL, &session_id_);
+                          kDefaultCdmIdentifier, nullptr, &session_id_);
   GenerateKeyRequest(kUsageLicenseTestVector1[1].pssh, kLicenseTypeStreaming,
                      &property_set);
 
@@ -4454,7 +4448,7 @@ TEST_F(WvCdmRequestLicenseTest, UsageRemoveSecureStopTest) {
 
     property_set.set_app_id(app_id_empty);
     decryptor_->OpenSession(config_.key_system(), &property_set,
-                            kDefaultCdmIdentifier, NULL, &session_id_);
+                            kDefaultCdmIdentifier, nullptr, &session_id_);
     GenerateKeyRequest(kUsageLicenseTestVector1[i].pssh, kLicenseTypeStreaming,
                        &property_set);
 
@@ -4482,9 +4476,9 @@ TEST_F(WvCdmRequestLicenseTest, UsageRemoveSecureStopTest) {
     SubSampleInfo* data = kUsageLicenseTestVector2[i].sub_sample;
 
     property_set.set_app_id(kExampleIdentifier.app_package_name);
-    EXPECT_EQ(NO_ERROR,
-              decryptor_->OpenSession(config_.key_system(), &property_set,
-                                      kExampleIdentifier, NULL, &session_id_));
+    EXPECT_EQ(NO_ERROR, decryptor_->OpenSession(
+                            config_.key_system(), &property_set,
+                            kExampleIdentifier, nullptr, &session_id_));
     std::string init_data_type = "video/mp4";
     CdmAppParameterMap app_parameters;
     GenerateKeyRequest(wvcdm::KEY_MESSAGE, init_data_type,
@@ -4564,8 +4558,8 @@ TEST_F(WvCdmRequestLicenseTest, VerifyProviderClientToken) {
   key_id[key_id.size()-1] = '5';
 
   // Acquire license
-  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                          NULL, &session_id_);
+  decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                          nullptr, &session_id_);
   GenerateKeyRequest(key_id, kLicenseTypeOffline);
   EXPECT_TRUE(!key_msg_.empty());
   std::string key_msg = key_msg_;
@@ -4610,8 +4604,8 @@ TEST_F(WvCdmRequestLicenseTest, VerifyProviderClientToken) {
   session_id_.clear();
 
   // Restore offline license and renew it
-  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                          NULL, &session_id_);
+  decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                          nullptr, &session_id_);
   EXPECT_EQ(wvcdm::KEY_ADDED, decryptor_->RestoreKey(session_id_, key_set_id));
 
   std::string license_server;
@@ -4666,7 +4660,7 @@ TEST_F(WvCdmRequestLicenseTest, QueryUnmodifiedSessionStatus) {
             decryptor_->QueryStatus(kLevelDefault,
                                     wvcdm::QUERY_KEY_SECURITY_LEVEL,
                                     &security_level));
-  EXPECT_EQ(GetSecurityLevel(NULL), security_level);
+  EXPECT_EQ(GetSecurityLevel(nullptr), security_level);
 }
 
 TEST_F(WvCdmRequestLicenseTest, QueryModifiedSessionStatus) {
@@ -4683,8 +4677,8 @@ TEST_F(WvCdmRequestLicenseTest, QueryKeyStatus) {
   Unprovision();
   Provision(kLevelDefault);
 
-  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                          NULL, &session_id_);
+  decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                          nullptr, &session_id_);
   GenerateKeyRequest(binary_key_id(), kLicenseTypeStreaming);
   VerifyKeyRequestResponse(config_.license_server(), config_.client_auth());
 
@@ -4971,8 +4965,8 @@ TEST_F(WvCdmRequestLicenseTest, QueryOemCryptoSessionId) {
   Unprovision();
   Provision(kLevelDefault);
 
-  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                          NULL, &session_id_);
+  decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                          nullptr, &session_id_);
   GenerateKeyRequest(binary_key_id(), kLicenseTypeStreaming);
   VerifyKeyRequestResponse(config_.license_server(), config_.client_auth());
 
@@ -5008,8 +5002,8 @@ TEST_F(WvCdmRequestLicenseTest, IsSecurityLevelSupported) {
 }
 
 TEST_F(WvCdmRequestLicenseTest, DISABLED_OfflineLicenseDecryptionTest) {
-  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                          NULL, &session_id_);
+  decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                          nullptr, &session_id_);
   GenerateKeyRequest(binary_key_id(), kLicenseTypeOffline);
   VerifyKeyRequestResponse(config_.license_server(), config_.client_auth());
 
@@ -5062,8 +5056,8 @@ TEST_F(WvCdmRequestLicenseTest, DISABLED_OfflineLicenseDecryptionTest) {
 }
 
 TEST_F(WvCdmRequestLicenseTest, DISABLED_RestoreOfflineLicenseDecryptionTest) {
-  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                          NULL, &session_id_);
+  decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                          nullptr, &session_id_);
   GenerateKeyRequest(binary_key_id(), kLicenseTypeOffline);
   VerifyKeyRequestResponse(config_.license_server(), config_.client_auth());
   CdmKeySetId key_set_id = key_set_id_;
@@ -5071,8 +5065,8 @@ TEST_F(WvCdmRequestLicenseTest, DISABLED_RestoreOfflineLicenseDecryptionTest) {
   decryptor_->CloseSession(session_id_);
 
   session_id_.clear();
-  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                          NULL, &session_id_);
+  decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                          nullptr, &session_id_);
   EXPECT_EQ(wvcdm::KEY_ADDED, decryptor_->RestoreKey(session_id_, key_set_id));
   /*
     // key 1, encrypted, 256b
@@ -5194,10 +5188,9 @@ TEST_P(WvCdmSessionSharingTest, SessionSharingTest) {
   property_set.set_session_sharing_mode(
       session_sharing_info->session_sharing_enabled);
 
-  ASSERT_EQ(NO_ERROR, decryptor_->OpenSession(config_.key_system(),
-                                              &property_set,
-                                              cdm_identifier, NULL,
-                                              &session_id_));
+  ASSERT_EQ(NO_ERROR,
+            decryptor_->OpenSession(config_.key_system(), &property_set,
+                                    cdm_identifier, nullptr, &session_id_));
   CdmSessionId gp_session_id_1 = session_id_;
   GenerateKeyRequest(binary_key_id(), kLicenseTypeStreaming, cdm_identifier);
   VerifyKeyRequestResponse(config_.license_server(), config_.client_auth());
@@ -5210,10 +5203,9 @@ TEST_P(WvCdmSessionSharingTest, SessionSharingTest) {
       "edef8ba979d64acea3c827dcd51d21ed00000014"    // Widevine system id
       "08011210bdf1cb4fffc6506b8b7945b0bd2917fb");  // pssh data
 
-  ASSERT_EQ(NO_ERROR, decryptor_->OpenSession(config_.key_system(),
-                                              &property_set,
-                                              cdm_identifier, NULL,
-                                              &session_id_));
+  ASSERT_EQ(NO_ERROR,
+            decryptor_->OpenSession(config_.key_system(), &property_set,
+                                    cdm_identifier, nullptr, &session_id_));
   CdmSessionId gp_session_id_2 = session_id_;
   GenerateKeyRequest(gp_key_id2, kLicenseTypeStreaming, cdm_identifier);
   VerifyKeyRequestResponse(config_.license_server(), gp_client_auth2);
@@ -5267,7 +5259,7 @@ TEST_F(WvCdmRequestLicenseTest, SessionSharingTest) {
       "0801121030313233343536373839616263646566");  // pssh data
 
   decryptor_->OpenSession(config_.key_system(), &property_set,
-                          kDefaultCdmIdentifier, NULL, &session_id_);
+                          kDefaultCdmIdentifier, nullptr, &session_id_);
   CdmSessionId session_id1 = session_id_;
   GenerateKeyRequest(init_data1, kLicenseTypeStreaming);
   VerifyKeyRequestResponse(config_.license_server(), config_.client_auth());
@@ -5281,7 +5273,7 @@ TEST_F(WvCdmRequestLicenseTest, SessionSharingTest) {
       "08011210bdf1cb4fffc6506b8b7945b0bd2917fb");  // pssh data
 
   decryptor_->OpenSession(config_.key_system(), &property_set,
-                          kDefaultCdmIdentifier, NULL, &session_id_);
+                          kDefaultCdmIdentifier, nullptr, &session_id_);
   CdmSessionId session_id2 = session_id_;
   GenerateKeyRequest(init_data2, kLicenseTypeStreaming);
   VerifyKeyRequestResponse(config_.license_server(), gp_client_auth2);
@@ -5303,7 +5295,7 @@ TEST_F(WvCdmRequestLicenseTest, SessionSharingTest) {
         kSingleEncryptedSubSampleIcpLicenseExpirationWindow);
 
   decryptor_->OpenSession(config_.key_system(), &property_set,
-                          kDefaultCdmIdentifier, NULL, &session_id_);
+                          kDefaultCdmIdentifier, nullptr, &session_id_);
   CdmSessionId session_id3 = session_id_;
   GenerateKeyRequest(init_data1, kLicenseTypeStreaming);
   VerifyKeyRequestResponse(config_.license_server(), config_.client_auth());
@@ -5327,8 +5319,8 @@ TEST_F(WvCdmRequestLicenseTest, DecryptionKeyExpiredTest) {
       "EDEF8BA979D64ACEA3C827DCD51D21ED00000014"    // Widevine system id
       "0801121030313233343536373839616263646566");  // pssh data
   SubSampleInfo* data = &single_encrypted_sub_sample_short_expiry;
-  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                          NULL, &session_id_);
+  decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                          nullptr, &session_id_);
   if (data->retrieve_key) {
     GenerateKeyRequest(kCpKeyId, kLicenseTypeStreaming);
     VerifyKeyRequestResponse(config_.license_server(), config_.client_auth());
@@ -5354,7 +5346,7 @@ TEST_F(WvCdmRequestLicenseTest, PlaybackExpiry) {
   StrictMock<TestWvCdmEventListener> listener;
   DecryptCallbackTester decrypt_callback(
       decryptor_, &usage_info_sub_samples_icp[0]);
-  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
+  decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
                           &listener, &session_id_);
 
   EXPECT_CALL(
@@ -5365,7 +5357,7 @@ TEST_F(WvCdmRequestLicenseTest, PlaybackExpiry) {
       .WillOnce(Invoke(&decrypt_callback, &DecryptCallbackTester::Decrypt));
   EXPECT_CALL(listener, OnExpirationUpdate(session_id_, _));
 
-  GenerateKeyRequest(kPsshStreamingClip21, kLicenseTypeStreaming, NULL);
+  GenerateKeyRequest(kPsshStreamingClip21, kLicenseTypeStreaming, nullptr);
   VerifyKeyRequestResponse(config_.license_server(), config_.client_auth());
 
   EXPECT_CALL(
@@ -5382,7 +5374,7 @@ TEST_F(WvCdmRequestLicenseTest, PlaybackExpiry_DecryptBeforeLicense) {
   StrictMock<TestWvCdmEventListener> listener;
   DecryptCallbackTester decrypt_callback(
       decryptor_, &usage_info_sub_samples_icp[0]);
-  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
+  decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
                           &listener, &session_id_);
 
   // Decrypt before license is received is expected to fail but should
@@ -5399,7 +5391,7 @@ TEST_F(WvCdmRequestLicenseTest, PlaybackExpiry_DecryptBeforeLicense) {
       .WillOnce(Invoke(&decrypt_callback, &DecryptCallbackTester::Decrypt));
   EXPECT_CALL(listener, OnExpirationUpdate(session_id_, _));
 
-  GenerateKeyRequest(kPsshStreamingClip21, kLicenseTypeStreaming, NULL);
+  GenerateKeyRequest(kPsshStreamingClip21, kLicenseTypeStreaming, nullptr);
   VerifyKeyRequestResponse(config_.license_server(), config_.client_auth());
 
   EXPECT_CALL(
@@ -5416,7 +5408,7 @@ TEST_F(WvCdmRequestLicenseTest, SessionKeyChangeNotificationTest) {
   StrictMock<TestWvCdmEventListener> listener;
   DecryptCallbackTester decrypt_callback(
       decryptor_, &single_encrypted_sub_sample_short_expiry);
-  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
+  decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
                           &listener, &session_id_);
   EXPECT_CALL(
       listener,
@@ -5444,8 +5436,8 @@ class WvCdmDecryptionTest
 
 TEST_P(WvCdmDecryptionTest, DecryptionTest) {
   SubSampleInfo* data = GetParam();
-  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                          NULL, &session_id_);
+  decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                          nullptr, &session_id_);
   if (data->retrieve_key) {
     GenerateKeyRequest(binary_key_id(), kLicenseTypeStreaming);
     VerifyKeyRequestResponse(config_.license_server(), config_.client_auth());
@@ -5502,7 +5494,7 @@ TEST_P(WvCdmSessionSharingNoKeyTest, DecryptionTest) {
   property_set.set_session_sharing_mode(true);
 
   decryptor_->OpenSession(config_.key_system(), &property_set,
-                          kDefaultCdmIdentifier, NULL, &session_id_);
+                          kDefaultCdmIdentifier, nullptr, &session_id_);
   CdmSessionId gp_session_id_1 = session_id_;
   GenerateKeyRequest(binary_key_id(), kLicenseTypeStreaming);
 
@@ -5515,7 +5507,7 @@ TEST_P(WvCdmSessionSharingNoKeyTest, DecryptionTest) {
       "08011210bdf1cb4fffc6506b8b7945b0bd2917fb");  // pssh data
 
   decryptor_->OpenSession(config_.key_system(), &property_set,
-                          kDefaultCdmIdentifier, NULL, &session_id_);
+                          kDefaultCdmIdentifier, nullptr, &session_id_);
   CdmSessionId gp_session_id_2 = session_id_;
   GenerateKeyRequest(gp_key_id2, kLicenseTypeStreaming);
 
@@ -5567,12 +5559,12 @@ TEST(VersionNumberTest, VersionNumberChangeCanary) {
 }
 
 TEST_F(WvCdmRequestLicenseTest, AddHlsStreamingKeyTest) {
-  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                          NULL, &session_id_);
+  decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                          nullptr, &session_id_);
   CdmAppParameterMap app_parameters;
   GenerateKeyRequest(wvcdm::KEY_MESSAGE, HLS_INIT_DATA_FORMAT,
                      kAttributeListSampleAes, app_parameters,
-                     kLicenseTypeStreaming, NULL);
+                     kLicenseTypeStreaming, nullptr);
   //TODO(rfrias): Remove once we switch to git-on-borg
   std::string license_server = "https://proxy.uat.widevine.com/proxy";
   VerifyKeyRequestResponse(license_server, config_.client_auth());
@@ -5584,12 +5576,12 @@ class WvHlsInitDataTest
       public ::testing::WithParamInterface<std::string> {};
 
 TEST_P(WvHlsInitDataTest, InvalidHlsFormatTest) {
-  decryptor_->OpenSession(config_.key_system(), NULL, kDefaultCdmIdentifier,
-                          NULL, &session_id_);
+  decryptor_->OpenSession(config_.key_system(), nullptr, kDefaultCdmIdentifier,
+                          nullptr, &session_id_);
   CdmAppParameterMap app_parameters;
   std::string init_data = GetParam();
   GenerateKeyRequest(wvcdm::INIT_DATA_NOT_FOUND, HLS_INIT_DATA_FORMAT,
-                     init_data, app_parameters, kLicenseTypeStreaming, NULL);
+                     init_data, app_parameters, kLicenseTypeStreaming, nullptr);
   decryptor_->CloseSession(session_id_);
 }
 
@@ -5616,7 +5608,7 @@ TEST_P(WvHlsDecryptionTest, HlsDecryptionTest) {
   CdmAppParameterMap app_parameters;
   GenerateKeyRequest(wvcdm::KEY_MESSAGE, HLS_INIT_DATA_FORMAT,
                      info->attribute_list, app_parameters,
-                     kLicenseTypeStreaming, NULL);
+                     kLicenseTypeStreaming, nullptr);
   //TODO(rfrias): Remove once we switch to git-on-borg
   std::string license_server = "https://proxy.uat.widevine.com/proxy";
   VerifyKeyRequestResponse(license_server, config_.client_auth());
@@ -5670,7 +5662,7 @@ TEST_P(WvHlsFourCCBackwardCompatibilityTest, HlsDecryptionTest) {
   CdmAppParameterMap app_parameters;
   GenerateKeyRequest(wvcdm::KEY_MESSAGE, ISO_BMFF_VIDEO_MIME_TYPE,
                      info->attribute_list, app_parameters,
-                     kLicenseTypeStreaming, NULL);
+                     kLicenseTypeStreaming, nullptr);
   //TODO(rfrias): Remove once we switch to git-on-borg
   std::string license_server = "https://proxy.uat.widevine.com/proxy";
   VerifyKeyRequestResponse(license_server, config_.client_auth());
@@ -5739,8 +5731,8 @@ TEST_P(WvCenc30Test, DecryptionTest) {
   decryptor_->OpenSession(config_.key_system(), &client_property_set,
                           kDefaultCdmIdentifier, &listener, &session_id_);
   CdmAppParameterMap app_parameters;
-  GenerateKeyRequest(info->pssh, app_parameters,
-                     kLicenseTypeStreaming, NULL);
+  GenerateKeyRequest(info->pssh, app_parameters, kLicenseTypeStreaming,
+                     nullptr);
   VerifyKeyRequestResponse(config_.license_server(), config_.client_auth());
   CdmKeyStatusMap key_status_map = listener.GetKeyStatusMap();
   EXPECT_EQ(8u, key_status_map.size());
@@ -5804,8 +5796,8 @@ TEST_P(WvCenc30SwitchCipherModeTest, DecryptionTest) {
   decryptor_->OpenSession(config_.key_system(), &client_property_set,
                           kDefaultCdmIdentifier, &listener, &session_id_);
   CdmAppParameterMap app_parameters;
-  GenerateKeyRequest(info->pssh, app_parameters,
-                     kLicenseTypeStreaming, NULL);
+  GenerateKeyRequest(info->pssh, app_parameters, kLicenseTypeStreaming,
+                     nullptr);
   VerifyKeyRequestResponse(config_.license_server(), config_.client_auth());
   CdmKeyStatusMap key_status_map = listener.GetKeyStatusMap();
   EXPECT_EQ(8u, key_status_map.size());
@@ -5845,8 +5837,8 @@ TEST_F(WvCdmRequestLicenseTest, CloseCdmReleaseResourcesTest) {
   Provision(kAlternateCdmIdentifier1, kLevelDefault);
 
   // Retrieve a streaming license
-  EXPECT_EQ(NO_ERROR, decryptor_->OpenSession(config_.key_system(), NULL,
-                                              kDefaultCdmIdentifier, NULL,
+  EXPECT_EQ(NO_ERROR, decryptor_->OpenSession(config_.key_system(), nullptr,
+                                              kDefaultCdmIdentifier, nullptr,
                                               &session_id_));
   GenerateKeyRequest(binary_key_id(), kLicenseTypeStreaming);
   VerifyKeyRequestResponse(config_.license_server(), config_.client_auth());
@@ -5857,23 +5849,22 @@ TEST_F(WvCdmRequestLicenseTest, CloseCdmReleaseResourcesTest) {
   CdmSessionId session_id3;
   CdmSessionId session_id4;
   CdmSessionId alternate_session_id;
-  EXPECT_EQ(NO_ERROR, decryptor_->OpenSession(config_.key_system(), NULL,
-                                              kDefaultCdmIdentifier, NULL,
+  EXPECT_EQ(NO_ERROR, decryptor_->OpenSession(config_.key_system(), nullptr,
+                                              kDefaultCdmIdentifier, nullptr,
                                               &session_id1));
-  EXPECT_EQ(NO_ERROR, decryptor_->OpenSession(config_.key_system(), NULL,
-                                              kDefaultCdmIdentifier, NULL,
+  EXPECT_EQ(NO_ERROR, decryptor_->OpenSession(config_.key_system(), nullptr,
+                                              kDefaultCdmIdentifier, nullptr,
                                               &session_id2));
-  EXPECT_EQ(NO_ERROR, decryptor_->OpenSession(config_.key_system(), NULL,
-                                              kDefaultCdmIdentifier, NULL,
+  EXPECT_EQ(NO_ERROR, decryptor_->OpenSession(config_.key_system(), nullptr,
+                                              kDefaultCdmIdentifier, nullptr,
                                               &session_id3));
-  EXPECT_EQ(NO_ERROR, decryptor_->OpenSession(config_.key_system(), NULL,
-                                              kDefaultCdmIdentifier, NULL,
+  EXPECT_EQ(NO_ERROR, decryptor_->OpenSession(config_.key_system(), nullptr,
+                                              kDefaultCdmIdentifier, nullptr,
                                               &session_id4));
-  EXPECT_EQ(NO_ERROR, decryptor_->OpenSession(config_.key_system(), NULL,
-                                              kAlternateCdmIdentifier1, NULL,
+  EXPECT_EQ(NO_ERROR, decryptor_->OpenSession(config_.key_system(), nullptr,
+                                              kAlternateCdmIdentifier1, nullptr,
                                               &alternate_session_id));
 
-
   // Close all open sessions and disable the timer running for |session_id_|
   decryptor_->CloseCdm(kDefaultCdmIdentifier);
 
@@ -5891,8 +5882,8 @@ TEST_F(WvCdmRequestLicenseTest, DISABLED_DecryptPathTest) {
   Provision(kDefaultCdmIdentifier, kLevelDefault);
 
   // Retrieve a streaming license
-  EXPECT_EQ(NO_ERROR, decryptor_->OpenSession(config_.key_system(), NULL,
-                                              kDefaultCdmIdentifier, NULL,
+  EXPECT_EQ(NO_ERROR, decryptor_->OpenSession(config_.key_system(), nullptr,
+                                              kDefaultCdmIdentifier, nullptr,
                                               &session_id_));
 
   CdmSessionId invalid_session_id = session_id_ + "more";
diff --git a/libwvdrmengine/cdm/test/timer_unittest.cpp b/libwvdrmengine/cdm/test/timer_unittest.cpp
index be633888..b474531c 100644
--- a/libwvdrmengine/cdm/test/timer_unittest.cpp
+++ b/libwvdrmengine/cdm/test/timer_unittest.cpp
@@ -22,7 +22,7 @@ class TestTimerHandler : public TimerHandler {
 
 TEST(TimerTest, ParametersCheck) {
   Timer timer;
-  EXPECT_FALSE(timer.Start(NULL, 10));
+  EXPECT_FALSE(timer.Start(nullptr, 10));
 
   TestTimerHandler handler;
   EXPECT_FALSE(timer.Start(&handler, 0));
diff --git a/libwvdrmengine/cdm/test/wv_cdm_metrics_test.cpp b/libwvdrmengine/cdm/test/wv_cdm_metrics_test.cpp
index 9abfb11c..17daad22 100644
--- a/libwvdrmengine/cdm/test/wv_cdm_metrics_test.cpp
+++ b/libwvdrmengine/cdm/test/wv_cdm_metrics_test.cpp
@@ -101,8 +101,8 @@ TEST_F(WvContentDecryptionModuleMetricsTest, EngineAndSessionMetrics) {
   // Openning the session will fail with NEEDS_PROVISIONING error. But it will
   // still create some session-level stats.
   EXPECT_EQ(CdmResponseType::NEED_PROVISIONING,
-            decryptor_.OpenSession(key_system, NULL,
-                                   kDefaultCdmIdentifier, NULL, &session_id));
+            decryptor_.OpenSession(key_system, nullptr, kDefaultCdmIdentifier,
+                                   nullptr, &session_id));
 
   drm_metrics::WvCdmMetrics metrics;
   ASSERT_EQ(wvcdm::NO_ERROR,
@@ -155,8 +155,8 @@ TEST_F(WvContentDecryptionModuleMetricsTest,
     // each identifier.
     for (int j = 0; j <= i; j ++) {
       EXPECT_EQ(CdmResponseType::NEED_PROVISIONING,
-                decryptor_.OpenSession(key_system, NULL,
-                                       identifiers[i], NULL, &session_id));
+                decryptor_.OpenSession(key_system, nullptr, identifiers[i],
+                                       nullptr, &session_id));
     }
   }
 
diff --git a/libwvdrmengine/cdm/util/src/clock.cpp b/libwvdrmengine/cdm/util/src/clock.cpp
index a8ead9f7..3f27e4aa 100644
--- a/libwvdrmengine/cdm/util/src/clock.cpp
+++ b/libwvdrmengine/cdm/util/src/clock.cpp
@@ -13,7 +13,7 @@ namespace wvcdm {
 int64_t Clock::GetCurrentTime() {
   struct timeval tv;
   tv.tv_sec = tv.tv_usec = 0;
-  gettimeofday(&tv, NULL);
+  gettimeofday(&tv, nullptr);
   return tv.tv_sec;
 }
 
diff --git a/libwvdrmengine/cdm/util/src/file_utils.cpp b/libwvdrmengine/cdm/util/src/file_utils.cpp
index b073abd7..d5585eb4 100644
--- a/libwvdrmengine/cdm/util/src/file_utils.cpp
+++ b/libwvdrmengine/cdm/util/src/file_utils.cpp
@@ -38,10 +38,10 @@ bool FileUtils::Remove(const std::string& path) {
   if (FileUtils::IsDirectory(path)) {
     // Handle directory deletion
     DIR* dir;
-    if ((dir = opendir(path.c_str())) != NULL) {
+    if ((dir = opendir(path.c_str())) != nullptr) {
       // first remove files and dir within it
       struct dirent* entry;
-      while ((entry = readdir(dir)) != NULL) {
+      while ((entry = readdir(dir)) != nullptr) {
         if (!IsCurrentOrParentDirectory(entry->d_name)) {
           std::string path_to_remove = path + kDirectoryDelimiter;
           path_to_remove += entry->d_name;
@@ -76,7 +76,7 @@ bool FileUtils::Remove(const std::string& path) {
 
       DIR* dir;
       std::string dir_path = path.substr(0, delimiter_pos);
-      if ((dir = opendir(dir_path.c_str())) == NULL) {
+      if ((dir = opendir(dir_path.c_str())) == nullptr) {
         LOGW("File::Remove: directory open failed for wildcard");
         return false;
       }
@@ -84,7 +84,7 @@ bool FileUtils::Remove(const std::string& path) {
       struct dirent* entry;
       std::string ext = path.substr(wildcard_pos + 1);
 
-      while ((entry = readdir(dir)) != NULL) {
+      while ((entry = readdir(dir)) != nullptr) {
         size_t filename_len = strlen(entry->d_name);
         if (filename_len > ext.size()) {
           if (strcmp(entry->d_name + filename_len - ext.size(), ext.c_str()) ==
@@ -141,7 +141,7 @@ bool FileUtils::Copy(const std::string& src, const std::string& dest) {
 }
 
 bool FileUtils::List(const std::string& path, std::vector<std::string>* files) {
-  if (NULL == files) {
+  if (nullptr == files) {
     LOGV("File::List: files destination not provided");
     return false;
   }
@@ -153,7 +153,7 @@ bool FileUtils::List(const std::string& path, std::vector<std::string>* files) {
   }
 
   DIR* dir = opendir(path.c_str());
-  if (dir == NULL) {
+  if (dir == nullptr) {
     LOGW("File::List: unable to open directory %s: %d, %s", path.c_str(), errno,
          strerror(errno));
     return false;
@@ -161,7 +161,7 @@ bool FileUtils::List(const std::string& path, std::vector<std::string>* files) {
 
   files->clear();
   struct dirent* entry;
-  while ((entry = readdir(dir)) != NULL) {
+  while ((entry = readdir(dir)) != nullptr) {
     if (!IsCurrentOrParentDirectory(entry->d_name)) {
       files->push_back(entry->d_name);
     }