diff --git a/libwvdrmengine/cdm/core/src/oemcrypto_adapter_dynamic.cpp b/libwvdrmengine/cdm/core/src/oemcrypto_adapter_dynamic.cpp
index cce67f42..5df23f45 100644
--- a/libwvdrmengine/cdm/core/src/oemcrypto_adapter_dynamic.cpp
+++ b/libwvdrmengine/cdm/core/src/oemcrypto_adapter_dynamic.cpp
@@ -28,6 +28,7 @@
 #include "log.h"
 #include "metrics_collections.h"
 #include "properties.h"
+#include "scoped_ptr.h"
 #include "wv_cdm_constants.h"
 
 using namespace wvoec3;
@@ -528,24 +529,30 @@ struct LevelSession {
   LOOKUP(min, kMaximumVersion, Name, Function)
 
 
-// An Adapter keeps a block of FunctionPointers for the built-in level 3 and
-// the dynamically loaded level 1 oemcrypto.  When initialized, it tries to
-// load the level 1 library and verifies that all needed functions are present.
-// If they are not, then it flags the level 1 as invalid.  Later, when the
-// function get(kLevel3) is called, it returns the level 3 function pointers.
-// When get(kLevelDefault) is called, it returns level 1 function pointers if
-// level 1 is valid and otherwise returns the level 3 function pointers.
+// The Adapter keeps a block of FunctionPointers for the built-in level 3 and
+// the dynamically loaded level 1 oemcrypto.  When initialized, it tries to load
+// the level 1 library and verifies that all needed functions are present.  If
+// they are not, then it flags the level 1 as invalid.  Later, when the function
+// GetFunctionPointers(kLevel3) is called, it returns the level 3 function
+// pointers.  When GetFunctionPointers(kLevelDefault) is called, it returns
+// level 1 function pointers if level 1 is valid and otherwise returns the level
+// 3 function pointers.  The Adapter is a global singleton.
 class Adapter {
  public:
   typedef std::map<OEMCrypto_SESSION, LevelSession>::iterator map_iterator;
 
   Adapter() : level1_valid_(false), level1_library_(NULL) {}
 
+  // The adapter is only destroyed on certain errors, or when the process
+  // dies.  It is NOT deleted after each OEMCrypto_Terminate.
   ~Adapter() {
+    if (level1_library_) {
+      dlclose(level1_library_);
+      level1_library_ = NULL;
+    }
   }
 
   OEMCryptoResult Initialize() {
-
     /*
      * To avoid changing the function signature and function contract, use a
      * reference to a singleton object for the metrics collected from the
@@ -580,21 +587,26 @@ class Adapter {
           wvcdm::metrics::OEMCrypto_INITIALIZED_USING_L3_NO_L1_LIBRARY_PATH);
       return result;
     }
-    level1_library_ = dlopen(library_name.c_str(), RTLD_NOW);
     if (level1_library_ == NULL) {
-      LOGW("Could not load %s. Falling back to L3.  %s", library_name.c_str(),
-           dlerror());
-      metrics.OemCryptoDynamicAdapterMetrics::SetInitializationMode(
-          wvcdm::metrics::OEMCrypto_INITIALIZED_USING_L3_L1_OPEN_FAILED);
-      return result;
+      level1_library_ = dlopen(library_name.c_str(), RTLD_NOW);
+      if (level1_library_ == NULL) {
+        LOGW("Could not load %s. Falling back to L3.  %s", library_name.c_str(),
+             dlerror());
+        metrics.OemCryptoDynamicAdapterMetrics::SetInitializationMode(
+            wvcdm::metrics::OEMCrypto_INITIALIZED_USING_L3_L1_OPEN_FAILED);
+        return result;
+      }
     }
     if (LoadLevel1(&metrics)) {
       LOGD("OEMCrypto_Initialize Level 1 success. I will use level 1.");
     } else {
       level1_ = FunctionPointers();  // revert to all null pointers.
-      dlclose(level1_library_);
-      level1_library_ = NULL;
       level1_valid_ = false;
+      // Note: if the function pointers are bad, we do not close the library and
+      // try again later.  Instead, we permanently fall back to L3.  This is a
+      // debatable choice: I decided the risk of a dlclose resource leak out
+      // weighed the possibility that the library would be fixed on the next
+      // load.
     }
     return result;
   }
@@ -849,18 +861,16 @@ class Adapter {
     OEMCryptoResult result = Level3_Terminate();
     if (level1_valid_) {
       result = level1_.Terminate();
-      dlclose(level1_library_);
-      level1_library_ = NULL;
     }
     return result;
   }
 
-  const FunctionPointers* get(wvcdm::SecurityLevel level) {
+  const FunctionPointers* GetFunctionPointers(wvcdm::SecurityLevel level) {
     if (level1_valid_ && level == kLevelDefault) return &level1_;
     return &level3_;
   }
 
-  LevelSession get(OEMCrypto_SESSION session) {
+  LevelSession GetSession(OEMCrypto_SESSION session) {
     wvcdm::AutoLock auto_lock(session_map_lock_);
     map_iterator pair = session_map_.find(session);
     if (pair == session_map_.end()) {
@@ -928,23 +938,22 @@ class Adapter {
   }
 };
 
-static Adapter* kAdapter = 0;
-
+static wvcdm::scoped_ptr<Adapter> gAdapter;
 }  // namespace
 
 namespace wvcdm {
 
 OEMCryptoResult OEMCrypto_OpenSession(OEMCrypto_SESSION* session,
                                       SecurityLevel level) {
-  if (!kAdapter) return OEMCrypto_ERROR_OPEN_SESSION_FAILED;
-  return kAdapter->OpenSession(session, level);
+  if (!gAdapter.get()) return OEMCrypto_ERROR_OPEN_SESSION_FAILED;
+  return gAdapter->OpenSession(session, level);
 }
 
 OEMCryptoResult OEMCrypto_CopyBuffer(
     SecurityLevel level, const uint8_t* data_addr, size_t data_length,
     OEMCrypto_DestBufferDesc* out_buffer, uint8_t subsample_flags) {
-  if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
-  const FunctionPointers* fcn = kAdapter->get(level);
+  if (!gAdapter.get()) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
+  const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
   if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (fcn->version < 10) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   if (fcn->CopyBuffer == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
@@ -954,8 +963,8 @@ OEMCryptoResult OEMCrypto_CopyBuffer(
 OEMCryptoResult OEMCrypto_InstallKeyboxOrOEMCert(const uint8_t* keybox,
                                         size_t keyBoxLength,
                                         SecurityLevel level) {
-  if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
-  const FunctionPointers* fcn = kAdapter->get(level);
+  if (!gAdapter.get()) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
+  const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
   if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (fcn->InstallKeyboxOrOEMCert == NULL)
     return OEMCrypto_ERROR_NOT_IMPLEMENTED;
@@ -964,8 +973,8 @@ OEMCryptoResult OEMCrypto_InstallKeyboxOrOEMCert(const uint8_t* keybox,
 
 OEMCrypto_ProvisioningMethod OEMCrypto_GetProvisioningMethod(
     SecurityLevel level) {
-  if (!kAdapter) return OEMCrypto_ProvisioningError;
-  const FunctionPointers* fcn = kAdapter->get(level);
+  if (!gAdapter.get()) return OEMCrypto_ProvisioningError;
+  const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
   if (!fcn) return OEMCrypto_ProvisioningError;
   if (fcn->version < 12) return OEMCrypto_Keybox;
   if (fcn->GetProvisioningMethod == NULL) return OEMCrypto_Keybox;
@@ -973,8 +982,8 @@ OEMCrypto_ProvisioningMethod OEMCrypto_GetProvisioningMethod(
 }
 
 OEMCryptoResult OEMCrypto_IsKeyboxOrOEMCertValid(SecurityLevel level) {
-  if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
-  const FunctionPointers* fcn = kAdapter->get(level);
+  if (!gAdapter.get()) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
+  const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
   if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (fcn->IsKeyboxOrOEMCertValid == NULL)
     return OEMCrypto_ERROR_NOT_IMPLEMENTED;
@@ -983,8 +992,8 @@ OEMCryptoResult OEMCrypto_IsKeyboxOrOEMCertValid(SecurityLevel level) {
 
 OEMCryptoResult OEMCrypto_GetDeviceID(uint8_t* deviceID, size_t* idLength,
                                       SecurityLevel level) {
-  if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
-  const FunctionPointers* fcn = kAdapter->get(level);
+  if (!gAdapter.get()) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
+  const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
   if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (fcn->GetDeviceID == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return fcn->GetDeviceID(deviceID, idLength);
@@ -992,24 +1001,24 @@ OEMCryptoResult OEMCrypto_GetDeviceID(uint8_t* deviceID, size_t* idLength,
 
 OEMCryptoResult OEMCrypto_GetKeyData(uint8_t* keyData, size_t* keyDataLength,
                                      SecurityLevel level) {
-  if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
-  const FunctionPointers* fcn = kAdapter->get(level);
+  if (!gAdapter.get()) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
+  const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
   if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (fcn->GetKeyData == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return fcn->GetKeyData(keyData, keyDataLength);
 }
 
 uint32_t OEMCrypto_APIVersion(SecurityLevel level) {
-  if (!kAdapter) return 0;
-  const FunctionPointers* fcn = kAdapter->get(level);
+  if (!gAdapter.get()) return 0;
+  const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
   if (!fcn) return 0;
   if (fcn->APIVersion == NULL) return 0;
   return fcn->APIVersion();
 }
 
 uint8_t OEMCrypto_Security_Patch_Level(SecurityLevel level) {
-  if (!kAdapter) return 0;
-  const FunctionPointers* fcn = kAdapter->get(level);
+  if (!gAdapter.get()) return 0;
+  const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
   if (!fcn) return 0;
   if (fcn->version < 11) return 0;
   if (fcn->SecurityPatchLevel == NULL) return 0;
@@ -1017,8 +1026,8 @@ uint8_t OEMCrypto_Security_Patch_Level(SecurityLevel level) {
 }
 
 const char* OEMCrypto_SecurityLevel(SecurityLevel level) {
-  if (!kAdapter) return "";
-  const FunctionPointers* fcn = kAdapter->get(level);
+  if (!gAdapter.get()) return "";
+  const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
   if (!fcn) return "";
   if (fcn->SecurityLevel == NULL) return "";
   return fcn->SecurityLevel();
@@ -1027,8 +1036,8 @@ const char* OEMCrypto_SecurityLevel(SecurityLevel level) {
 OEMCryptoResult OEMCrypto_GetHDCPCapability(
     SecurityLevel level, OEMCrypto_HDCP_Capability* current,
     OEMCrypto_HDCP_Capability* maximum) {
-  if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
-  const FunctionPointers* fcn = kAdapter->get(level);
+  if (!gAdapter.get()) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
+  const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
   if (!fcn) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   if (fcn->version == 8) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   if (fcn->version == 9) {
@@ -1049,8 +1058,8 @@ OEMCryptoResult OEMCrypto_GetHDCPCapability(
 }
 
 uint32_t OEMCrypto_GetAnalogOutputFlags(SecurityLevel level) {
-  if (!kAdapter) return OEMCrypto_Unknown_Analog_Output;
-  const FunctionPointers* fcn = kAdapter->get(level);
+  if (!gAdapter.get()) return OEMCrypto_Unknown_Analog_Output;
+  const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
   if (!fcn) return OEMCrypto_Unknown_Analog_Output;
   if (fcn->version < 14) return OEMCrypto_Unknown_Analog_Output;
   if (fcn->GetAnalogOutputFlags == NULL) return OEMCrypto_Unknown_Analog_Output;
@@ -1058,8 +1067,8 @@ uint32_t OEMCrypto_GetAnalogOutputFlags(SecurityLevel level) {
 }
 
 bool OEMCrypto_SupportsUsageTable(SecurityLevel level) {
-  if (!kAdapter) return false;
-  const FunctionPointers* fcn = kAdapter->get(level);
+  if (!gAdapter.get()) return false;
+  const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
   if (!fcn) return false;
   if (fcn->version == 8) return false;
   if (fcn->SupportsUsageTable == NULL) return false;
@@ -1067,8 +1076,8 @@ bool OEMCrypto_SupportsUsageTable(SecurityLevel level) {
 }
 
 bool OEMCrypto_IsAntiRollbackHwPresent(SecurityLevel level) {
-  if (!kAdapter) return false;
-  const FunctionPointers* fcn = kAdapter->get(level);
+  if (!gAdapter.get()) return false;
+  const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
   if (!fcn) return false;
   if (fcn->version < 10) return false;
   if (fcn->IsAntiRollbackHwPresent == NULL) return false;
@@ -1077,8 +1086,8 @@ bool OEMCrypto_IsAntiRollbackHwPresent(SecurityLevel level) {
 
 OEMCryptoResult OEMCrypto_GetNumberOfOpenSessions(SecurityLevel level,
                                                   size_t* count) {
-  if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
-  const FunctionPointers* fcn = kAdapter->get(level);
+  if (!gAdapter.get()) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
+  const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
   if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (fcn->version < 10) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return fcn->GetNumberOfOpenSessions(count);
@@ -1086,8 +1095,8 @@ OEMCryptoResult OEMCrypto_GetNumberOfOpenSessions(SecurityLevel level,
 
 OEMCryptoResult OEMCrypto_GetMaxNumberOfSessions(SecurityLevel level,
                                                  size_t* maximum) {
-  if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
-  const FunctionPointers* fcn = kAdapter->get(level);
+  if (!gAdapter.get()) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
+  const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
   if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (fcn->version < 10) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   if (fcn->GetMaxNumberOfSessions == NULL)
@@ -1096,8 +1105,8 @@ OEMCryptoResult OEMCrypto_GetMaxNumberOfSessions(SecurityLevel level,
 }
 
 uint32_t OEMCrypto_SupportedCertificates(SecurityLevel level) {
-  if (!kAdapter) return 0;
-  const FunctionPointers* fcn = kAdapter->get(level);
+  if (!gAdapter.get()) return 0;
+  const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
   if (!fcn) return 0;
   // Default is to support 2048 bit RSA keys.
   if (fcn->version < 13) return OEMCrypto_Supports_RSA_2048bit;
@@ -1108,8 +1117,8 @@ uint32_t OEMCrypto_SupportedCertificates(SecurityLevel level) {
 OEMCryptoResult OEMCrypto_CreateUsageTableHeader(SecurityLevel level,
                                                  uint8_t* header_buffer,
                                                  size_t* header_buffer_length) {
-  if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
-  const FunctionPointers* fcn = kAdapter->get(level);
+  if (!gAdapter.get()) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
+  const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
   if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (fcn->version < 13) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   if (fcn->CreateUsageTableHeader == NULL)
@@ -1120,8 +1129,8 @@ OEMCryptoResult OEMCrypto_CreateUsageTableHeader(SecurityLevel level,
 OEMCryptoResult OEMCrypto_LoadUsageTableHeader(SecurityLevel level,
                                                const uint8_t* buffer,
                                                size_t buffer_length) {
-  if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
-  const FunctionPointers* fcn = kAdapter->get(level);
+  if (!gAdapter.get()) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
+  const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
   if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (fcn->version < 13) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   if (fcn->LoadUsageTableHeader == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
@@ -1132,8 +1141,8 @@ OEMCryptoResult OEMCrypto_ShrinkUsageTableHeader(SecurityLevel level,
                                                  uint32_t new_table_size,
                                                  uint8_t* header_buffer,
                                                  size_t* header_buffer_length) {
-  if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
-  const FunctionPointers* fcn = kAdapter->get(level);
+  if (!gAdapter.get()) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
+  const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
   if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (fcn->version < 13) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   if (fcn->ShrinkUsageTableHeader == NULL)
@@ -1147,8 +1156,8 @@ OEMCryptoResult OEMCrypto_CreateOldUsageEntry(
     uint64_t time_since_first_decrypt, 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 (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
-  const FunctionPointers* fcn = kAdapter->get(level);
+  if (!gAdapter.get()) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
+  const FunctionPointers* fcn = gAdapter->GetFunctionPointers(level);
   if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (fcn->version < 13) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   if (fcn->CreateOldUsageEntry == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
@@ -1160,21 +1169,17 @@ OEMCryptoResult OEMCrypto_CreateOldUsageEntry(
 }  // namespace wvcdm
 
 extern "C" OEMCryptoResult OEMCrypto_Initialize(void) {
-  if (kAdapter) {
-    kAdapter->Terminate();
-    delete kAdapter;
+  if (!gAdapter.get()) {
+    gAdapter.reset(new Adapter());
   }
-  kAdapter = new Adapter();
-  return kAdapter->Initialize();
+  return gAdapter->Initialize();
 }
 
 extern "C" OEMCryptoResult OEMCrypto_Terminate(void) {
   OEMCryptoResult result = OEMCrypto_SUCCESS;
-  if (kAdapter) {
-    result = kAdapter->Terminate();
-    delete kAdapter;
+  if (gAdapter.get()) {
+    result = gAdapter->Terminate();
   }
-  kAdapter = NULL;
   return result;
 }
 
@@ -1183,16 +1188,16 @@ extern "C" OEMCryptoResult OEMCrypto_OpenSession(OEMCrypto_SESSION* session) {
 }
 
 extern "C" OEMCryptoResult OEMCrypto_CloseSession(OEMCrypto_SESSION session) {
-  if (!kAdapter) return OEMCrypto_ERROR_CLOSE_SESSION_FAILED;
-  return kAdapter->CloseSession(session);
+  if (!gAdapter.get()) return OEMCrypto_ERROR_CLOSE_SESSION_FAILED;
+  return gAdapter->CloseSession(session);
 }
 
 extern "C" 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 (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
-  LevelSession pair = kAdapter->get(session);
+  if (!gAdapter.get()) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
+  LevelSession pair = gAdapter->GetSession(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (pair.fcn->GenerateDerivedKeys == NULL)
     return OEMCrypto_ERROR_NOT_IMPLEMENTED;
@@ -1203,8 +1208,8 @@ extern "C" OEMCryptoResult OEMCrypto_GenerateDerivedKeys(
 
 extern "C" OEMCryptoResult OEMCrypto_GenerateNonce(OEMCrypto_SESSION session,
                                                    uint32_t* nonce) {
-  if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
-  LevelSession pair = kAdapter->get(session);
+  if (!gAdapter.get()) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
+  LevelSession pair = gAdapter->GetSession(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (pair.fcn->GenerateNonce == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return pair.fcn->GenerateNonce(pair.session, nonce);
@@ -1213,8 +1218,8 @@ extern "C" OEMCryptoResult OEMCrypto_GenerateNonce(OEMCrypto_SESSION session,
 extern "C" OEMCryptoResult OEMCrypto_GenerateSignature(
     OEMCrypto_SESSION session, const uint8_t* message, size_t message_length,
     uint8_t* signature, size_t* signature_length) {
-  if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
-  LevelSession pair = kAdapter->get(session);
+  if (!gAdapter.get()) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
+  LevelSession pair = gAdapter->GetSession(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (pair.fcn->GenerateSignature == NULL)
     return OEMCrypto_ERROR_NOT_IMPLEMENTED;
@@ -1233,8 +1238,8 @@ extern "C" OEMCryptoResult OEMCrypto_LoadKeys_Back_Compat(
     const OEMCrypto_KeyObject_V13* key_array, const uint8_t* pst,
     size_t pst_length, const uint8_t* srm_requirement,
     OEMCrypto_LicenseType license_type) {
-  if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
-  LevelSession pair = kAdapter->get(session);
+  if (!gAdapter.get()) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
+  LevelSession pair = gAdapter->GetSession(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (pair.fcn->version < 11) {
     if (license_type != OEMCrypto_ContentLicense)
@@ -1323,8 +1328,8 @@ extern "C" OEMCryptoResult OEMCrypto_LoadKeys(
     const uint8_t* enc_mac_key_iv, const uint8_t* enc_mac_key, size_t num_keys,
     const OEMCrypto_KeyObject* key_array, const uint8_t* pst, size_t pst_length,
     const uint8_t* srm_requirement, OEMCrypto_LicenseType license_type) {
-  if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
-  LevelSession pair = kAdapter->get(session);
+  if (!gAdapter.get()) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
+  LevelSession pair = gAdapter->GetSession(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (pair.fcn->version < 11) {
     if (license_type != OEMCrypto_ContentLicense)
@@ -1405,8 +1410,8 @@ extern "C" OEMCryptoResult OEMCrypto_LoadKeys(
 extern "C" OEMCryptoResult OEMCrypto_LoadEntitledContentKeys(
     OEMCrypto_SESSION session, size_t num_keys,
     const OEMCrypto_EntitledContentKeyObject* key_array) {
-  if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
-  LevelSession pair = kAdapter->get(session);
+  if (!gAdapter.get()) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
+  LevelSession pair = gAdapter->GetSession(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (pair.fcn->version < 14) {
     return OEMCrypto_ERROR_NOT_IMPLEMENTED;
@@ -1420,8 +1425,8 @@ extern "C" 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 (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
-  LevelSession pair = kAdapter->get(session);
+  if (!gAdapter.get()) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
+  LevelSession pair = gAdapter->GetSession(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (pair.fcn->RefreshKeys == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return pair.fcn->RefreshKeys(pair.session, message, message_length, signature,
@@ -1431,8 +1436,8 @@ extern "C" OEMCryptoResult OEMCrypto_RefreshKeys(
 extern "C" 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 (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
-  LevelSession pair = kAdapter->get(session);
+  if (!gAdapter.get()) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
+  LevelSession pair = gAdapter->GetSession(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (pair.fcn->version < 10) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   if (pair.fcn->QueryKeyControl == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
@@ -1444,8 +1449,8 @@ extern "C" OEMCryptoResult OEMCrypto_SelectKey(const OEMCrypto_SESSION session,
                                                const uint8_t* key_id,
                                                size_t key_id_length,
                                                OEMCryptoCipherMode cipher_mode) {
-  if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
-  LevelSession pair = kAdapter->get(session);
+  if (!gAdapter.get()) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
+  LevelSession pair = gAdapter->GetSession(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (pair.fcn->version < 14) {
     if (pair.fcn->SelectKey_V13 == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
@@ -1462,8 +1467,8 @@ extern "C" OEMCryptoResult OEMCrypto_DecryptCENC(
     bool is_encrypted, const uint8_t* iv, size_t offset,
     OEMCrypto_DestBufferDesc* out_buffer,
     const OEMCrypto_CENCEncryptPatternDesc* pattern, uint8_t subsample_flags) {
-  if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
-  LevelSession pair = kAdapter->get(session);
+  if (!gAdapter.get()) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
+  LevelSession pair = gAdapter->GetSession(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (pair.fcn->version < 11) {
     if (pair.fcn->DecryptCTR_V10 == NULL)
@@ -1492,8 +1497,8 @@ extern "C" OEMCryptoResult OEMCrypto_WrapKeybox(const uint8_t* keybox,
                                                 size_t* wrappedKeyBoxLength,
                                                 const uint8_t* transportKey,
                                                 size_t transportKeyLength) {
-  if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
-  const FunctionPointers* fcn = kAdapter->get(kLevelDefault);
+  if (!gAdapter.get()) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
+  const FunctionPointers* fcn = gAdapter->GetFunctionPointers(kLevelDefault);
   if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (fcn->WrapKeybox == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return fcn->WrapKeybox(keybox, keyBoxLength, wrappedKeybox,
@@ -1507,8 +1512,8 @@ extern "C" OEMCryptoResult OEMCrypto_InstallKeyboxOrOEMCert(const uint8_t* keybo
 
 extern "C" OEMCryptoResult OEMCrypto_LoadTestKeybox(const uint8_t* buffer,
                                                     size_t length) {
-  if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
-  const FunctionPointers* fcn = kAdapter->get(kLevelDefault);
+  if (!gAdapter.get()) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
+  const FunctionPointers* fcn = gAdapter->GetFunctionPointers(kLevelDefault);
   if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (fcn->version < 10) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   if (fcn->LoadTestKeybox_V13 != NULL) {
@@ -1530,8 +1535,8 @@ extern "C" OEMCrypto_ProvisioningMethod OEMCrypto_GetProvisioningMethod() {
 extern "C" OEMCryptoResult OEMCrypto_GetOEMPublicCertificate(
     OEMCrypto_SESSION session, uint8_t* public_cert,
     size_t* public_cert_length) {
-  if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
-  LevelSession pair = kAdapter->get(session);
+  if (!gAdapter.get()) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
+  LevelSession pair = gAdapter->GetSession(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (pair.fcn->version < 12) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   if (pair.fcn->GetOEMPublicCertificate == NULL)
@@ -1552,8 +1557,8 @@ extern "C" OEMCryptoResult OEMCrypto_GetKeyData(uint8_t* keyData,
 
 extern "C" OEMCryptoResult OEMCrypto_GetRandom(uint8_t* randomData,
                                                size_t dataLength) {
-  if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
-  const FunctionPointers* fcn = kAdapter->get(kLevelDefault);
+  if (!gAdapter.get()) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
+  const FunctionPointers* fcn = gAdapter->GetFunctionPointers(kLevelDefault);
   if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (fcn->GetRandom == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return fcn->GetRandom(randomData, dataLength);
@@ -1569,8 +1574,8 @@ extern "C" OEMCryptoResult OEMCrypto_RewrapDeviceRSAKey30(
                                const uint8_t* enc_rsa_key_iv,
                                uint8_t* wrapped_rsa_key,
                                size_t* wrapped_rsa_key_length) {
-  if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
-  LevelSession pair = kAdapter->get(session);
+  if (!gAdapter.get()) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
+  LevelSession pair = gAdapter->GetSession(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (pair.fcn->version < 12) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   if (pair.fcn->RewrapDeviceRSAKey30 == NULL)
@@ -1589,8 +1594,8 @@ extern "C" OEMCryptoResult OEMCrypto_RewrapDeviceRSAKey(
     const uint8_t* enc_rsa_key, size_t enc_rsa_key_length,
     const uint8_t* enc_rsa_key_iv, uint8_t* wrapped_rsa_key,
     size_t* wrapped_rsa_key_length) {
-  if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
-  LevelSession pair = kAdapter->get(session);
+  if (!gAdapter.get()) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
+  LevelSession pair = gAdapter->GetSession(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (pair.fcn->RewrapDeviceRSAKey == NULL)
     return OEMCrypto_ERROR_NOT_IMPLEMENTED;
@@ -1603,8 +1608,8 @@ extern "C" OEMCryptoResult OEMCrypto_RewrapDeviceRSAKey(
 extern "C" OEMCryptoResult OEMCrypto_LoadDeviceRSAKey(
     OEMCrypto_SESSION session, const uint8_t* wrapped_rsa_key,
     size_t wrapped_rsa_key_length) {
-  if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
-  LevelSession pair = kAdapter->get(session);
+  if (!gAdapter.get()) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
+  LevelSession pair = gAdapter->GetSession(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (pair.fcn->LoadDeviceRSAKey == NULL)
     return OEMCrypto_ERROR_NOT_IMPLEMENTED;
@@ -1613,8 +1618,8 @@ extern "C" OEMCryptoResult OEMCrypto_LoadDeviceRSAKey(
 }
 
 extern "C" OEMCryptoResult OEMCrypto_LoadTestRSAKey() {
-  if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
-  const FunctionPointers* fcn = kAdapter->get(kLevelDefault);
+  if (!gAdapter.get()) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
+  const FunctionPointers* fcn = gAdapter->GetFunctionPointers(kLevelDefault);
   if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (fcn->version < 10) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   if (fcn->LoadTestRSAKey == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
@@ -1625,8 +1630,8 @@ extern "C" 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 (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
-  LevelSession pair = kAdapter->get(session);
+  if (!gAdapter.get()) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
+  LevelSession pair = gAdapter->GetSession(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (pair.fcn->version == 8) {
     if (pair.fcn->GenerateRSASignature_V8 == NULL)
@@ -1647,8 +1652,8 @@ extern "C" 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 (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
-  LevelSession pair = kAdapter->get(session);
+  if (!gAdapter.get()) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
+  LevelSession pair = gAdapter->GetSession(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (pair.fcn->DeriveKeysFromSessionKey == NULL)
     return OEMCrypto_ERROR_NOT_IMPLEMENTED;
@@ -1697,8 +1702,8 @@ extern "C" uint32_t OEMCrypto_SupportedCertificates() {
 extern "C" 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 (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
-  LevelSession pair = kAdapter->get(session);
+  if (!gAdapter.get()) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
+  LevelSession pair = gAdapter->GetSession(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (pair.fcn->Generic_Encrypt == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   OEMCryptoResult status = OEMCrypto_SUCCESS;
@@ -1721,8 +1726,8 @@ extern "C" OEMCryptoResult OEMCrypto_Generic_Encrypt(
 extern "C" 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 (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
-  LevelSession pair = kAdapter->get(session);
+  if (!gAdapter.get()) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
+  LevelSession pair = gAdapter->GetSession(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (pair.fcn->Generic_Decrypt == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   OEMCryptoResult status = OEMCrypto_SUCCESS;
@@ -1748,8 +1753,8 @@ extern "C" OEMCryptoResult OEMCrypto_Generic_Sign(OEMCrypto_SESSION session,
                                                   OEMCrypto_Algorithm algorithm,
                                                   uint8_t* signature,
                                                   size_t* signature_length) {
-  if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
-  LevelSession pair = kAdapter->get(session);
+  if (!gAdapter.get()) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
+  LevelSession pair = gAdapter->GetSession(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   return pair.fcn->Generic_Sign(pair.session, in_buffer, buffer_length,
                                 algorithm, signature, signature_length);
@@ -1759,8 +1764,8 @@ extern "C" 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 (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
-  LevelSession pair = kAdapter->get(session);
+  if (!gAdapter.get()) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
+  LevelSession pair = gAdapter->GetSession(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (pair.fcn->Generic_Verify == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return pair.fcn->Generic_Verify(pair.session, in_buffer, buffer_length,
@@ -1768,8 +1773,8 @@ extern "C" OEMCryptoResult OEMCrypto_Generic_Verify(
 }
 
 extern "C" OEMCryptoResult OEMCrypto_UpdateUsageTable() {
-  if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
-  const FunctionPointers* fcn1 = kAdapter->get(kLevelDefault);
+  if (!gAdapter.get()) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
+  const FunctionPointers* fcn1 = gAdapter->GetFunctionPointers(kLevelDefault);
   OEMCryptoResult sts = OEMCrypto_ERROR_NOT_IMPLEMENTED;
   if ((fcn1 != NULL) && (fcn1->UpdateUsageTable != NULL) &&
       (fcn1->version > 8) && (fcn1->version < 13)) {
@@ -1780,11 +1785,11 @@ extern "C" OEMCryptoResult OEMCrypto_UpdateUsageTable() {
 
 extern "C" OEMCryptoResult OEMCrypto_DeactivateUsageEntry(
     OEMCrypto_SESSION session, const uint8_t* pst, size_t pst_length) {
-  if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
-  LevelSession pair = kAdapter->get(session);
+  if (!gAdapter.get()) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
+  LevelSession pair = gAdapter->GetSession(session);
   if (!pair.fcn) {
-    const FunctionPointers* fcn1 = kAdapter->get(kLevelDefault);
-    const FunctionPointers* fcn3 = kAdapter->get(kLevel3);
+    const FunctionPointers* fcn1 = gAdapter->GetFunctionPointers(kLevelDefault);
+    const FunctionPointers* fcn3 = gAdapter->GetFunctionPointers(kLevel3);
     OEMCryptoResult sts = OEMCrypto_ERROR_INVALID_SESSION;
     if (fcn1) {
       if (fcn1->version < 13) {
@@ -1837,8 +1842,8 @@ extern "C" OEMCryptoResult OEMCrypto_ReportUsage(OEMCrypto_SESSION session,
                                                  size_t pst_length,
                                                  uint8_t* buffer,
                                                  size_t* buffer_length) {
-  if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
-  LevelSession pair = kAdapter->get(session);
+  if (!gAdapter.get()) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
+  LevelSession pair = gAdapter->GetSession(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (pair.fcn->version > 8) {
     if (pair.fcn->ReportUsage == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
@@ -1853,8 +1858,8 @@ extern "C" OEMCryptoResult OEMCrypto_DeleteUsageEntry(
     OEMCrypto_SESSION session, const uint8_t* pst, size_t pst_length,
     const uint8_t* message, size_t message_length, const uint8_t* signature,
     size_t signature_length) {
-  if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
-  LevelSession pair = kAdapter->get(session);
+  if (!gAdapter.get()) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
+  LevelSession pair = gAdapter->GetSession(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (pair.fcn->version > 8 && pair.fcn->version < 13) {
     return pair.fcn->DeleteUsageEntry(pair.session, pst, pst_length, message,
@@ -1867,9 +1872,9 @@ extern "C" OEMCryptoResult OEMCrypto_DeleteUsageEntry(
 
 extern "C" OEMCryptoResult OEMCrypto_ForceDeleteUsageEntry(const uint8_t* pst,
                                                            size_t pst_length) {
-  if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
-  const FunctionPointers* fcn1 = kAdapter->get(kLevelDefault);
-  const FunctionPointers* fcn3 = kAdapter->get(kLevel3);
+  if (!gAdapter.get()) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
+  const FunctionPointers* fcn1 = gAdapter->GetFunctionPointers(kLevelDefault);
+  const FunctionPointers* fcn3 = gAdapter->GetFunctionPointers(kLevel3);
   OEMCryptoResult sts = OEMCrypto_ERROR_NOT_IMPLEMENTED;
   if (fcn3 && (fcn3->version > 9) && (fcn3->version < 13) &&
       fcn3->ForceDeleteUsageEntry != NULL) {
@@ -1886,9 +1891,9 @@ extern "C" OEMCryptoResult OEMCrypto_ForceDeleteUsageEntry(const uint8_t* pst,
 }
 
 extern "C" OEMCryptoResult OEMCrypto_DeleteOldUsageTable() {
-  if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
-  const FunctionPointers* fcn1 = kAdapter->get(kLevelDefault);
-  const FunctionPointers* fcn3 = kAdapter->get(kLevel3);
+  if (!gAdapter.get()) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
+  const FunctionPointers* fcn1 = gAdapter->GetFunctionPointers(kLevelDefault);
+  const FunctionPointers* fcn3 = gAdapter->GetFunctionPointers(kLevel3);
   OEMCryptoResult sts = OEMCrypto_ERROR_NOT_IMPLEMENTED;
   if (fcn3 && (fcn3->version > 8) && (fcn3->DeleteOldUsageTable != NULL)) {
     sts = fcn3->DeleteOldUsageTable();
@@ -1901,9 +1906,9 @@ extern "C" OEMCryptoResult OEMCrypto_DeleteOldUsageTable() {
 }
 
 extern "C" bool OEMCrypto_IsSRMUpdateSupported() {
-  if (!kAdapter) return false;
+  if (!gAdapter.get()) return false;
   // Level 3 can't load an SRM, so this just checkes Level 1.
-  const FunctionPointers* fcn = kAdapter->get(kLevelDefault);
+  const FunctionPointers* fcn = gAdapter->GetFunctionPointers(kLevelDefault);
   if (!fcn) return false;
   if (fcn->version < 13) return false;
   if (fcn->IsSRMUpdateSupported == NULL) return false;
@@ -1911,9 +1916,9 @@ extern "C" bool OEMCrypto_IsSRMUpdateSupported() {
 }
 
 extern "C" OEMCryptoResult OEMCrypto_GetCurrentSRMVersion(uint16_t* version) {
-  if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
+  if (!gAdapter.get()) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   // Level 3 can't load an SRM, so this just checkes Level 1.
-  const FunctionPointers* fcn = kAdapter->get(kLevelDefault);
+  const FunctionPointers* fcn = gAdapter->GetFunctionPointers(kLevelDefault);
   if (!fcn) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   if (fcn->version < 13) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   if (fcn->GetCurrentSRMVersion == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
@@ -1922,9 +1927,9 @@ extern "C" OEMCryptoResult OEMCrypto_GetCurrentSRMVersion(uint16_t* version) {
 
 extern "C" OEMCryptoResult OEMCrypto_LoadSRM(const uint8_t* buffer,
                                              size_t buffer_length) {
-  if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
+  if (!gAdapter.get()) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   // Level 3 can't load an SRM, so this just checkes Level 1.
-  const FunctionPointers* fcn = kAdapter->get(kLevelDefault);
+  const FunctionPointers* fcn = gAdapter->GetFunctionPointers(kLevelDefault);
   if (!fcn) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   if (fcn->version < 13) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   if (fcn->LoadSRM == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
@@ -1932,9 +1937,9 @@ extern "C" OEMCryptoResult OEMCrypto_LoadSRM(const uint8_t* buffer,
 }
 
 extern "C" OEMCryptoResult OEMCrypto_RemoveSRM() {
-  if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
+  if (!gAdapter.get()) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   // Level 3 can't load an SRM, so this just checkes Level 1.
-  const FunctionPointers* fcn = kAdapter->get(kLevelDefault);
+  const FunctionPointers* fcn = gAdapter->GetFunctionPointers(kLevelDefault);
   if (!fcn) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   if (fcn->version < 13) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   if (fcn->RemoveSRM == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
@@ -1954,8 +1959,8 @@ extern "C" OEMCryptoResult OEMCrypto_LoadUsageTableHeader(
 
 extern "C" OEMCryptoResult OEMCrypto_CreateNewUsageEntry(
     OEMCrypto_SESSION session, uint32_t* usage_entry_number) {
-  if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
-  LevelSession pair = kAdapter->get(session);
+  if (!gAdapter.get()) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
+  LevelSession pair = gAdapter->GetSession(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (pair.fcn->version < 13) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   if (pair.fcn->CreateNewUsageEntry == NULL)
@@ -1967,8 +1972,8 @@ extern "C" OEMCryptoResult OEMCrypto_LoadUsageEntry(OEMCrypto_SESSION session,
                                                     uint32_t index,
                                                     const uint8_t* buffer,
                                                     size_t buffer_size) {
-  if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
-  LevelSession pair = kAdapter->get(session);
+  if (!gAdapter.get()) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
+  LevelSession pair = gAdapter->GetSession(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (pair.fcn->version < 13) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   if (pair.fcn->LoadUsageEntry == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
@@ -1979,8 +1984,8 @@ extern "C" 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 (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
-  LevelSession pair = kAdapter->get(session);
+  if (!gAdapter.get()) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
+  LevelSession pair = gAdapter->GetSession(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (pair.fcn->version < 13) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   if (pair.fcn->UpdateUsageEntry == NULL)
@@ -1999,8 +2004,8 @@ extern "C" OEMCryptoResult OEMCrypto_ShrinkUsageTableHeader(
 
 extern "C" OEMCryptoResult OEMCrypto_MoveEntry(OEMCrypto_SESSION session,
                                                uint32_t new_index) {
-  if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
-  LevelSession pair = kAdapter->get(session);
+  if (!gAdapter.get()) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
+  LevelSession pair = gAdapter->GetSession(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (pair.fcn->version < 13) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   if (pair.fcn->MoveEntry == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
@@ -2009,8 +2014,8 @@ extern "C" OEMCryptoResult OEMCrypto_MoveEntry(OEMCrypto_SESSION session,
 
 extern "C" OEMCryptoResult OEMCrypto_CopyOldUsageEntry(
     OEMCrypto_SESSION session, const uint8_t* pst, size_t pst_length) {
-  if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
-  LevelSession pair = kAdapter->get(session);
+  if (!gAdapter.get()) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
+  LevelSession pair = gAdapter->GetSession(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (pair.fcn->version < 13) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   if (pair.fcn->CopyOldUsageEntry == NULL)