diff --git a/libwvdrmengine/oemcrypto/ref/src/oemcrypto_auth_ref.h b/libwvdrmengine/oemcrypto/ref/src/oemcrypto_auth_ref.h
index 61b85aaa..f6ee9ded 100644
--- a/libwvdrmengine/oemcrypto/ref/src/oemcrypto_auth_ref.h
+++ b/libwvdrmengine/oemcrypto/ref/src/oemcrypto_auth_ref.h
@@ -61,6 +61,7 @@ class AuthenticationRoot {
   RSA_shared_ptr& SharedRsaKey() { return rsa_key_; }
   RSA* rsa_key() { return rsa_key_.get(); }
   bool LoadTestRsaKey();
+  void Clear() { use_test_keybox_ = false; }
 
  private:
   OEMCrypto_ProvisioningMethod provisioning_method_;
diff --git a/libwvdrmengine/oemcrypto/ref/src/oemcrypto_engine_ref.cpp b/libwvdrmengine/oemcrypto/ref/src/oemcrypto_engine_ref.cpp
index aa2c0448..72493d85 100644
--- a/libwvdrmengine/oemcrypto/ref/src/oemcrypto_engine_ref.cpp
+++ b/libwvdrmengine/oemcrypto/ref/src/oemcrypto_engine_ref.cpp
@@ -38,12 +38,6 @@ CryptoEngine::CryptoEngine(std::unique_ptr<wvcdm::FileSystem>&& file_system)
 }
 
 CryptoEngine::~CryptoEngine() {
-  std::unique_lock<std::mutex> lock(session_table_lock_);
-  ActiveSessions::iterator it;
-  for (it = sessions_.begin(); it != sessions_.end(); ++it) {
-    delete it->second;
-  }
-  sessions_.clear();
   ERR_free_strings();
 }
 
@@ -52,6 +46,16 @@ bool CryptoEngine::Initialize() {
   return true;
 }
 
+void CryptoEngine::Terminate() {
+  std::unique_lock<std::mutex> lock(session_table_lock_);
+  ActiveSessions::iterator it;
+  for (it = sessions_.begin(); it != sessions_.end(); ++it) {
+    delete it->second;
+  }
+  sessions_.clear();
+  root_of_trust_.Clear();
+}
+
 SessionId CryptoEngine::OpenSession() {
   std::unique_lock<std::mutex> lock(session_table_lock_);
   static OEMCrypto_SESSION unique_id = 1;
diff --git a/libwvdrmengine/oemcrypto/ref/src/oemcrypto_engine_ref.h b/libwvdrmengine/oemcrypto/ref/src/oemcrypto_engine_ref.h
index 5000f789..32ab9eb6 100644
--- a/libwvdrmengine/oemcrypto/ref/src/oemcrypto_engine_ref.h
+++ b/libwvdrmengine/oemcrypto/ref/src/oemcrypto_engine_ref.h
@@ -71,11 +71,11 @@ class CryptoEngine {
     return root_of_trust_.DeviceToken();
   }
 
-  virtual void Terminate() {}
+  virtual void Terminate();
 
   virtual SessionId OpenSession();
 
-  bool DestroySession(SessionId sid);
+  virtual bool DestroySession(SessionId sid);
 
   SessionContext* FindSession(SessionId sid);
 
diff --git a/libwvdrmengine/oemcrypto/ref/src/oemcrypto_ref.cpp b/libwvdrmengine/oemcrypto/ref/src/oemcrypto_ref.cpp
index bb5ca174..67d3e12c 100644
--- a/libwvdrmengine/oemcrypto/ref/src/oemcrypto_ref.cpp
+++ b/libwvdrmengine/oemcrypto/ref/src/oemcrypto_ref.cpp
@@ -53,7 +53,7 @@ uint32_t unaligned_dereference_uint32(const void* unaligned_ptr) {
 
 namespace wvoec_ref {
 
-static CryptoEngine* crypto_engine = NULL;
+static std::unique_ptr<CryptoEngine> crypto_engine;
 
 typedef struct {
   uint8_t signature[wvoec::MAC_KEY_SIZE];
@@ -63,17 +63,15 @@ typedef struct {
 } WrappedRSAKey;
 
 OEMCRYPTO_API OEMCryptoResult OEMCrypto_Initialize(void) {
-  if (crypto_engine) {
+  if (crypto_engine != nullptr) {
     LOGE("-------------------------  Calling Initialize without Terminate\n");
-    delete crypto_engine;
-    crypto_engine = NULL;
+    crypto_engine.reset();
   }
   // NOTE: This requires a compatible Filesystem implementation.
   // NOTE: Ownership of the FileSystem object is transferred to CryptoEngine
   std::unique_ptr<wvcdm::FileSystem> fs(new wvcdm::FileSystem());
-  crypto_engine = CryptoEngine::MakeCryptoEngine(std::move(fs));
-
-  if (!crypto_engine || !crypto_engine->Initialize()) {
+  crypto_engine.reset(CryptoEngine::MakeCryptoEngine(std::move(fs)));
+  if (crypto_engine == nullptr || !crypto_engine->Initialize()) {
     LOGE("[OEMCrypto_Initialize(): failed]");
     return OEMCrypto_ERROR_INIT_FAILED;
   }
@@ -86,20 +84,18 @@ OEMCRYPTO_API OEMCryptoResult OEMCrypto_SetSandbox(
 }
 
 OEMCRYPTO_API OEMCryptoResult OEMCrypto_Terminate(void) {
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("[OEMCrypto_Terminate(): not initialized]");
     return OEMCrypto_ERROR_TERMINATE_FAILED;
   }
   crypto_engine->Terminate();
-
-  delete crypto_engine;
-  crypto_engine = NULL;
+  crypto_engine.reset();
   return OEMCrypto_SUCCESS;
 }
 
 OEMCRYPTO_API OEMCryptoResult OEMCrypto_OpenSession(
     OEMCrypto_SESSION* session) {
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("OEMCrypto_OpenSession: OEMCrypto not initialized.");
     return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   }
@@ -115,7 +111,7 @@ OEMCRYPTO_API OEMCryptoResult OEMCrypto_OpenSession(
 
 OEMCRYPTO_API OEMCryptoResult OEMCrypto_CloseSession(
     OEMCrypto_SESSION session) {
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("OEMCrypto_CloseSession: OEMCrypto not initialized.");
     return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   }
@@ -130,7 +126,7 @@ OEMCRYPTO_API OEMCryptoResult OEMCrypto_GenerateDerivedKeys(
     OEMCrypto_SESSION session, const uint8_t* mac_key_context,
     uint32_t mac_key_context_length, const uint8_t* enc_key_context,
     uint32_t enc_key_context_length) {
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("OEMCrypto_GenerateDerivedKeys: OEMCrypto not initialized.");
     return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   }
@@ -164,7 +160,7 @@ OEMCRYPTO_API OEMCryptoResult OEMCrypto_GenerateDerivedKeys(
 
 OEMCRYPTO_API OEMCryptoResult OEMCrypto_GenerateNonce(OEMCrypto_SESSION session,
                                                       uint32_t* nonce) {
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("OEMCrypto_GenerateNonce: OEMCrypto not initialized.");
     return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   }
@@ -209,7 +205,7 @@ OEMCRYPTO_API OEMCryptoResult OEMCrypto_GenerateNonce(OEMCrypto_SESSION session,
 OEMCRYPTO_API OEMCryptoResult OEMCrypto_GenerateSignature(
     OEMCrypto_SESSION session, const uint8_t* message, size_t message_length,
     uint8_t* signature, size_t* signature_length) {
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("OEMCrypto_GenerateSignature: OEMCrypto Not Initialized.");
     return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   }
@@ -261,7 +257,7 @@ OEMCRYPTO_API OEMCryptoResult OEMCrypto_LoadKeys(
     size_t num_keys, const OEMCrypto_KeyObject* key_array,
     OEMCrypto_Substring pst, OEMCrypto_Substring srm_restriction_data,
     OEMCrypto_LicenseType license_type) {
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("OEMCrypto_LoadKeys: OEMCrypto Not Initialized.");
     return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   }
@@ -321,7 +317,7 @@ OEMCRYPTO_API OEMCryptoResult OEMCrypto_LoadEntitledContentKeys(
     LOGE("[OEMCrypto_LoadEntitledContentKeys(): missing key_array.");
     return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   }
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("OEMCrypto_LoadEntitledContentKeys: OEMCrypto Not Initialized.");
     return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   }
@@ -352,7 +348,7 @@ OEMCRYPTO_API OEMCryptoResult OEMCrypto_RefreshKeys(
     OEMCrypto_SESSION session, const uint8_t* message, size_t message_length,
     const uint8_t* signature, size_t signature_length, size_t num_keys,
     const OEMCrypto_KeyRefreshObject* key_array) {
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("OEMCrypto_RefreshKeys: OEMCrypto Not Initialized.");
     return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   }
@@ -440,7 +436,7 @@ OEMCRYPTO_API OEMCryptoResult OEMCrypto_RefreshKeys(
 OEMCRYPTO_API OEMCryptoResult OEMCrypto_QueryKeyControl(
     OEMCrypto_SESSION session, const uint8_t* key_id, size_t key_id_length,
     uint8_t* key_control_block, size_t* key_control_block_length) {
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("OEMCrypto_QueryKeyControl: OEMCrypto Not Initialized.");
     return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   }
@@ -498,7 +494,7 @@ OEMCRYPTO_API OEMCryptoResult OEMCrypto_DecryptCENC(
     bool is_encrypted, const uint8_t* iv, size_t block_offset,
     OEMCrypto_DestBufferDesc* out_buffer,
     const OEMCrypto_CENCEncryptPatternDesc* pattern, uint8_t subsample_flags) {
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("OEMCrypto_DecryptCENC: OEMCrypto Not Initialized.");
     return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   }
@@ -543,7 +539,7 @@ OEMCRYPTO_API OEMCryptoResult OEMCrypto_DecryptCENC(
 OEMCRYPTO_API OEMCryptoResult OEMCrypto_CopyBuffer(
     OEMCrypto_SESSION session, const uint8_t* data_addr, size_t data_length,
     OEMCrypto_DestBufferDesc* out_buffer, uint8_t subsample_flags) {
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("OEMCrypto_CopyBuffer: OEMCrypto Not Initialized.");
     return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   }
@@ -586,7 +582,7 @@ OEMCRYPTO_API OEMCryptoResult OEMCrypto_WrapKeyboxOrOEMCert(
 
 OEMCRYPTO_API OEMCryptoResult OEMCrypto_InstallKeyboxOrOEMCert(
     const uint8_t* keybox, size_t keyBoxLength) {
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("OEMCrypto_InstallKeyboxOrOEMCert: OEMCrypto Not Initialized.");
     return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   }
@@ -601,7 +597,7 @@ OEMCRYPTO_API OEMCryptoResult OEMCrypto_InstallKeyboxOrOEMCert(
 
 OEMCRYPTO_API OEMCryptoResult OEMCrypto_LoadTestKeybox(const uint8_t* buffer,
                                                        size_t length) {
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("OEMCrypto_LoadTestKeybox: OEMCrypto Not Initialized.");
     return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   }
@@ -613,7 +609,7 @@ OEMCRYPTO_API OEMCryptoResult OEMCrypto_LoadTestKeybox(const uint8_t* buffer,
 }
 
 OEMCRYPTO_API OEMCryptoResult OEMCrypto_IsKeyboxOrOEMCertValid(void) {
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("OEMCrypto_IsKeyboxOrOEMCertValid: OEMCrypto Not Initialized.");
     return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   }
@@ -645,7 +641,7 @@ OEMCRYPTO_API OEMCryptoResult OEMCrypto_IsKeyboxOrOEMCertValid(void) {
 }
 
 OEMCRYPTO_API OEMCrypto_ProvisioningMethod OEMCrypto_GetProvisioningMethod() {
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("OEMCrypto_GetProvisioningMethod: OEMCrypto Not Initialized.");
     return OEMCrypto_ProvisioningError;
   }
@@ -655,7 +651,7 @@ OEMCRYPTO_API OEMCrypto_ProvisioningMethod OEMCrypto_GetProvisioningMethod() {
 OEMCRYPTO_API OEMCryptoResult OEMCrypto_GetOEMPublicCertificate(
     OEMCrypto_SESSION session, uint8_t* public_cert,
     size_t* public_cert_length) {
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("OEMCrypto_GetOEMPublicCertificate: OEMCrypto Not Initialized.");
     return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   }
@@ -675,7 +671,7 @@ OEMCRYPTO_API OEMCryptoResult OEMCrypto_GetOEMPublicCertificate(
 
 OEMCRYPTO_API OEMCryptoResult OEMCrypto_GetDeviceID(uint8_t* deviceID,
                                                     size_t* idLength) {
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("OEMCrypto_GetDeviceID: OEMCrypto Not Initialized.");
     return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   }
@@ -704,7 +700,7 @@ OEMCRYPTO_API OEMCryptoResult OEMCrypto_GetDeviceID(uint8_t* deviceID,
 
 OEMCRYPTO_API OEMCryptoResult OEMCrypto_GetKeyData(uint8_t* keyData,
                                                    size_t* keyDataLength) {
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("OEMCrypto_GetKeyData: OEMCrypto Not Initialized.");
     return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   }
@@ -733,7 +729,7 @@ OEMCRYPTO_API OEMCryptoResult OEMCrypto_GetKeyData(uint8_t* keyData,
 
 OEMCRYPTO_API OEMCryptoResult OEMCrypto_GetRandom(uint8_t* randomData,
                                                   size_t dataLength) {
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("OEMCrypto_GetRandom: OEMCrypto Not Initialized.");
     return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   }
@@ -756,7 +752,7 @@ OEMCRYPTO_API OEMCryptoResult OEMCrypto_RewrapDeviceRSAKey30(
   if (unaligned_nonce == NULL) {
     return OEMCrypto_ERROR_INVALID_CONTEXT;
   }
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("OEMCrypto_RewrapDeviceRSAKey30: OEMCrypto Not Initialized.");
     return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   }
@@ -873,7 +869,7 @@ OEMCRYPTO_API OEMCryptoResult OEMCrypto_RewrapDeviceRSAKey(
     if (unaligned_nonce == NULL) {
       return OEMCrypto_ERROR_INVALID_CONTEXT;
     }
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("OEMCrypto_RewrapDeviceRSAKey: OEMCrypto Not Initialized.");
     return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   }
@@ -990,7 +986,7 @@ OEMCRYPTO_API OEMCryptoResult OEMCrypto_LoadDeviceRSAKey(
     LOGE("[OEMCrypto_LoadDeviceRSAKey(): OEMCrypto_ERROR_INVALID_CONTEXT]");
     return OEMCrypto_ERROR_INVALID_CONTEXT;
   }
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("OEMCrypto_LoadDeviceRSAKey: OEMCrypto Not Initialized.");
     return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   }
@@ -1053,7 +1049,7 @@ OEMCRYPTO_API OEMCryptoResult OEMCrypto_LoadDeviceRSAKey(
 }
 
 OEMCRYPTO_API OEMCryptoResult OEMCrypto_LoadTestRSAKey() {
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("OEMCrypto_LoadTestRSAKey: OEMCrypto Not Initialized.");
     return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   }
@@ -1065,7 +1061,7 @@ OEMCRYPTO_API OEMCryptoResult OEMCrypto_GenerateRSASignature(
     OEMCrypto_SESSION session, const uint8_t* message, size_t message_length,
     uint8_t* signature, size_t* signature_length,
     RSA_Padding_Scheme padding_scheme) {
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("OEMCrypto_GenerateRSASignature: OEMCrypto Not Initialized.");
     return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   }
@@ -1103,7 +1099,7 @@ OEMCRYPTO_API OEMCryptoResult OEMCrypto_DeriveKeysFromSessionKey(
     size_t enc_session_key_length, const uint8_t* mac_key_context,
     size_t mac_key_context_length, const uint8_t* enc_key_context,
     size_t enc_key_context_length) {
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("OEMCrypto_DeriveKeysFromSessionKey: OEMCrypto Not Initialized.");
     return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   }
@@ -1151,7 +1147,7 @@ OEMCRYPTO_API const char* OEMCrypto_SecurityLevel() {
 
 OEMCRYPTO_API OEMCryptoResult OEMCrypto_GetHDCPCapability(
     OEMCrypto_HDCP_Capability* current, OEMCrypto_HDCP_Capability* maximum) {
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("OEMCrypto_GetHDCPCapability: OEMCrypto Not Initialized.");
     return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   }
@@ -1163,7 +1159,7 @@ OEMCRYPTO_API OEMCryptoResult OEMCrypto_GetHDCPCapability(
 }
 
 OEMCRYPTO_API uint32_t OEMCrypto_GetAnalogOutputFlags() {
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("OEMCrypto_GetAnalogOutputFlags: OEMCrypto Not Initialized.");
     return 0;
   }
@@ -1175,7 +1171,7 @@ OEMCRYPTO_API const char* OEMCrypto_BuildInformation() {
 }
 
 OEMCRYPTO_API uint32_t OEMCrypto_ResourceRatingTier() {
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("OEMCrypto_ResourceRatingTier: OEMCrypto Not Initialized.");
     return 0;
   }
@@ -1183,7 +1179,7 @@ OEMCRYPTO_API uint32_t OEMCrypto_ResourceRatingTier() {
 }
 
 OEMCRYPTO_API bool OEMCrypto_SupportsUsageTable() {
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("OEMCrypto_SupportsUsageTable: OEMCrypto Not Initialized.");
     return 0;
   }
@@ -1192,7 +1188,7 @@ OEMCRYPTO_API bool OEMCrypto_SupportsUsageTable() {
 }
 
 OEMCRYPTO_API OEMCryptoResult OEMCrypto_GetNumberOfOpenSessions(size_t* count) {
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("OEMCrypto_GetNumberOfOpenSessions: OEMCrypto Not Initialized.");
     return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   }
@@ -1203,7 +1199,7 @@ OEMCRYPTO_API OEMCryptoResult OEMCrypto_GetNumberOfOpenSessions(size_t* count) {
 
 OEMCRYPTO_API OEMCryptoResult OEMCrypto_GetMaxNumberOfSessions(
     size_t* maximum) {
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("OEMCrypto_GetMaxNumberOfSessions: OEMCrypto Not Initialized.");
     return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   }
@@ -1220,7 +1216,7 @@ OEMCRYPTO_API bool OEMCrypto_IsAntiRollbackHwPresent() {
 }
 
 OEMCRYPTO_API uint32_t OEMCrypto_SupportedCertificates() {
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("OEMCrypto_GetProvisioningMethod: OEMCrypto Not Initialized.");
     return 0;
   }
@@ -1234,7 +1230,7 @@ OEMCRYPTO_API uint32_t OEMCrypto_SupportedCertificates() {
 OEMCRYPTO_API OEMCryptoResult OEMCrypto_Generic_Encrypt(
     OEMCrypto_SESSION session, const uint8_t* in_buffer, size_t buffer_length,
     const uint8_t* iv, OEMCrypto_Algorithm algorithm, uint8_t* out_buffer) {
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("OEMCrypto_Generic_Encrypt: OEMCrypto Not Initialized.");
     return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   }
@@ -1260,7 +1256,7 @@ OEMCRYPTO_API OEMCryptoResult OEMCrypto_Generic_Encrypt(
 OEMCRYPTO_API OEMCryptoResult OEMCrypto_Generic_Decrypt(
     OEMCrypto_SESSION session, const uint8_t* in_buffer, size_t buffer_length,
     const uint8_t* iv, OEMCrypto_Algorithm algorithm, uint8_t* out_buffer) {
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("OEMCrypto_Generic_Decrypt: OEMCrypto Not Initialized.");
     return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   }
@@ -1287,7 +1283,7 @@ OEMCRYPTO_API OEMCryptoResult OEMCrypto_Generic_Sign(
     OEMCrypto_SESSION session, const uint8_t* in_buffer, size_t buffer_length,
     OEMCrypto_Algorithm algorithm, uint8_t* signature,
     size_t* signature_length) {
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("OEMCrypto_Generic_Sign: OEMCrypto Not Initialized.");
     return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   }
@@ -1317,7 +1313,7 @@ OEMCRYPTO_API OEMCryptoResult OEMCrypto_Generic_Verify(
     OEMCrypto_SESSION session, const uint8_t* in_buffer, size_t buffer_length,
     OEMCrypto_Algorithm algorithm, const uint8_t* signature,
     size_t signature_length) {
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("OEMCrypto_Generic_Verify: OEMCrypto Not Initialized.");
     return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   }
@@ -1348,7 +1344,7 @@ OEMCRYPTO_API OEMCryptoResult OEMCrypto_UpdateUsageTable() {
 
 OEMCRYPTO_API OEMCryptoResult OEMCrypto_DeactivateUsageEntry(
     OEMCrypto_SESSION session, const uint8_t* pst, size_t pst_length) {
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("OEMCrypto_DeactivateUsageEntry: OEMCrypto Not Initialized.");
     return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   }
@@ -1369,7 +1365,7 @@ OEMCRYPTO_API OEMCryptoResult OEMCrypto_ReportUsage(OEMCrypto_SESSION session,
                                                     size_t pst_length,
                                                     uint8_t* buffer,
                                                     size_t* buffer_length) {
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("OEMCrypto_ReportUsage: OEMCrypto Not Initialized.");
     return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   }
@@ -1403,7 +1399,7 @@ OEMCRYPTO_API OEMCryptoResult OEMCrypto_ForceDeleteUsageEntry(const uint8_t*,
 }
 
 OEMCRYPTO_API OEMCryptoResult OEMCrypto_DeleteOldUsageTable() {
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("OEMCrypto_DeleteOldUsageTable: OEMCrypto Not Initialized.");
     return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   }
@@ -1414,7 +1410,7 @@ OEMCRYPTO_API OEMCryptoResult OEMCrypto_DeleteOldUsageTable() {
 }
 
 OEMCRYPTO_API bool OEMCrypto_IsSRMUpdateSupported() {
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("OEMCrypto_IsSRMUpdateSupported: OEMCrypto Not Initialized.");
     return false;
   }
@@ -1424,7 +1420,7 @@ OEMCRYPTO_API bool OEMCrypto_IsSRMUpdateSupported() {
 
 OEMCRYPTO_API OEMCryptoResult OEMCrypto_GetCurrentSRMVersion(
     uint16_t* version) {
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("OEMCrypto_GetCurrentSRMVersion: OEMCrypto Not Initialized.");
     return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   }
@@ -1437,7 +1433,7 @@ OEMCRYPTO_API OEMCryptoResult OEMCrypto_GetCurrentSRMVersion(
 
 OEMCRYPTO_API OEMCryptoResult OEMCrypto_LoadSRM(const uint8_t* buffer,
                                                 size_t buffer_length) {
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("OEMCrypto_LoadSRM: OEMCrypto Not Initialized.");
     return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   }
@@ -1445,7 +1441,7 @@ OEMCRYPTO_API OEMCryptoResult OEMCrypto_LoadSRM(const uint8_t* buffer,
 }
 
 OEMCRYPTO_API OEMCryptoResult OEMCrypto_RemoveSRM() {
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("OEMCrypto_RemoveSRM: OEMCrypto Not Initialized.");
     return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   }
@@ -1454,7 +1450,7 @@ OEMCRYPTO_API OEMCryptoResult OEMCrypto_RemoveSRM() {
 
 OEMCRYPTO_API OEMCryptoResult OEMCrypto_CreateUsageTableHeader(
     uint8_t* header_buffer, size_t* header_buffer_length) {
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("OEMCrypto_CreateUsageTableHeader: OEMCrypto Not Initialized.");
     return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   }
@@ -1468,7 +1464,7 @@ OEMCRYPTO_API OEMCryptoResult OEMCrypto_CreateUsageTableHeader(
 
 OEMCRYPTO_API OEMCryptoResult OEMCrypto_LoadUsageTableHeader(
     const uint8_t* buffer, size_t buffer_length) {
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("OEMCrypto_LoadUsageTableHeader: OEMCrypto Not Initialized.");
     return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   }
@@ -1485,7 +1481,7 @@ OEMCRYPTO_API OEMCryptoResult OEMCrypto_LoadUsageTableHeader(
 
 OEMCRYPTO_API OEMCryptoResult OEMCrypto_CreateNewUsageEntry(
     OEMCrypto_SESSION session, uint32_t* usage_entry_number) {
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("OEMCrypto_CreateNewUsageEntry: OEMCrypto Not Initialized.");
     return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   }
@@ -1507,7 +1503,7 @@ OEMCRYPTO_API OEMCryptoResult OEMCrypto_CreateNewUsageEntry(
 OEMCRYPTO_API OEMCryptoResult OEMCrypto_LoadUsageEntry(
     OEMCrypto_SESSION session, uint32_t index, const uint8_t* buffer,
     size_t buffer_size) {
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("OEMCrypto_LoadUsageEntry: OEMCrypto Not Initialized.");
     return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   }
@@ -1531,7 +1527,7 @@ OEMCRYPTO_API OEMCryptoResult OEMCrypto_UpdateUsageEntry(
     OEMCrypto_SESSION session, uint8_t* header_buffer,
     size_t* header_buffer_length, uint8_t* entry_buffer,
     size_t* entry_buffer_length) {
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("OEMCrypto_UpdateUsageEntry: OEMCrypto Not Initialized.");
     return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   }
@@ -1553,7 +1549,7 @@ OEMCRYPTO_API OEMCryptoResult OEMCrypto_UpdateUsageEntry(
 OEMCRYPTO_API OEMCryptoResult OEMCrypto_ShrinkUsageTableHeader(
     uint32_t new_table_size, uint8_t* header_buffer,
     size_t* header_buffer_length) {
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("OEMCrypto_ShrinkUsageTableHeader: OEMCrypto Not Initialized.");
     return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   }
@@ -1566,7 +1562,7 @@ OEMCRYPTO_API OEMCryptoResult OEMCrypto_ShrinkUsageTableHeader(
 
 OEMCRYPTO_API OEMCryptoResult OEMCrypto_MoveEntry(OEMCrypto_SESSION session,
                                                   uint32_t new_index) {
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("OEMCrypto_MoveEntry: OEMCrypto Not Initialized.");
     return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   }
@@ -1583,7 +1579,7 @@ OEMCRYPTO_API OEMCryptoResult OEMCrypto_MoveEntry(OEMCrypto_SESSION session,
 
 OEMCRYPTO_API OEMCryptoResult OEMCrypto_CopyOldUsageEntry(
     OEMCrypto_SESSION session, const uint8_t* pst, size_t pst_length) {
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("OEMCrypto_CopyOldUsageEntry: OEMCrypto Not Initialized.");
     return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   }
@@ -1604,7 +1600,7 @@ OEMCRYPTO_API OEMCryptoResult OEMCrypto_CreateOldUsageEntry(
     uint64_t time_since_last_decrypt, OEMCrypto_Usage_Entry_Status status,
     uint8_t* server_mac_key, uint8_t* client_mac_key, const uint8_t* pst,
     size_t pst_length) {
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("OEMCrypto_CreateOldUsageEntry: OEMCrypto Not Initialized.");
     return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   }
@@ -1624,7 +1620,7 @@ OEMCRYPTO_API uint32_t OEMCrypto_SupportsDecryptHash() {
 OEMCRYPTO_API OEMCryptoResult OEMCrypto_SetDecryptHash(
     OEMCrypto_SESSION session, uint32_t frame_number, const uint8_t* hash,
     size_t hash_length) {
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("OEMCrypto_SetDecryptHash: OEMCrypto Not Initialized.");
     return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   }
@@ -1638,7 +1634,7 @@ OEMCRYPTO_API OEMCryptoResult OEMCrypto_SetDecryptHash(
 
 OEMCRYPTO_API OEMCryptoResult OEMCrypto_GetHashErrorCode(
     OEMCrypto_SESSION session, uint32_t* failed_frame_number) {
-  if (!crypto_engine) {
+  if (crypto_engine == nullptr) {
     LOGE("OEMCrypto_GetHashErrorCode: OEMCrypto Not Initialized.");
     return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   }