Clean up oemcrypto dynamic adapter and add level 3 libraries

Merge from Widevine repo of http://go/wvgerrit/24043

This CL simplifies the way the oemcrypto dynamic adapter handles
backwards compatibility while looking up old function pointers.

It also puts in guards for functions that do not have pointers.

Current Level 3 libraries merged from http://go/wvgerrit/23686/

level3/arm64/libwvlevel3.a  Level3 Library 7283 Feb 15 2017 13:39:10
level3/mips64/libwvlevel3.a  Level3 Library 7285 Feb 15 2017 13:51:12
level3/arm/libwvlevel3.a  Level3 Library 4445 Feb 15 2017 14:20:04
level3/x86_64/libwvlevel3.a  Level3 Library 7284 Feb 15 2017 13:43:04
level3/x86/libwvlevel3.a  Level3 Library 4464 Feb 15 2017 14:14:55
level3/mips/libwvlevel3.a  Level3 Library 4465 Feb 15 2017 14:10:04

Test: OEMCrypto Unit tests pass on bullhead, fugu, and all 
six emulators.  A bullhead was crippled to use L3 only, and 
Play Movies worked OK.  ExoPlayer tests were also run on the 
bullhead.  L1 was re-installed on the bullhead, and Play Movies and 
ExoPlayer tests were repeated with no problems.

Bug: 18949752
Bug: 31458046

Change-Id: I8668fde1ce8a045c71bf33c566f3ff86e11821c5

libwvdrmengine/cdm/core/src/oemcrypto_adapter_dynamic.cpp

@@ -73,7 +73,7 @@ typedef OEMCryptoResult (*L1_LoadKeys_t)(
     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);
-typedef OEMCryptoResult (*L1_LoadKeys_V12_t)(
+typedef OEMCryptoResult (*L1_LoadKeys_V11_or_V12_t)(
     OEMCrypto_SESSION session, const uint8_t* message, size_t message_length,
     const uint8_t* signature, size_t signature_length,
     const uint8_t* enc_mac_key_iv, const uint8_t* enc_mac_key, size_t num_keys,
@@ -316,7 +316,7 @@ struct FunctionPointers {
   L1_GenerateRSASignature_V8_t GenerateRSASignature_V8;
   L1_GetHDCPCapability_V9_t GetHDCPCapability_V9;
   L1_LoadKeys_V9_or_V10_t LoadKeys_V9_or_V10;
-  L1_LoadKeys_V12_t LoadKeys_V12;
+  L1_LoadKeys_V11_or_V12_t LoadKeys_V11_or_V12;
   L1_DeactivateUsageEntry_V12_t DeactivateUsageEntry_V12;
 };
 
@@ -383,14 +383,24 @@ struct LevelSession {
 
 #define QUOTE_DEFINE(A) #A
 #define QUOTE(A) QUOTE_DEFINE(A)
-#define LOOKUP(Name, Function)                                           \
+// This macro looks up a function name, but only if the API version is in the
+// specified range.
+#define LOOKUP(min, max, Name, Function)                                \
+  if ((level1_.version >= min) && (level1_.version <= max)) {           \
     level1_.Name = (L1_##Name##_t)dlsym(level1_library_, QUOTE(Function)); \
     if (!level1_.Name) {                                                \
       LOGW("Could not load L1 %s. Falling Back to L3.",                 \
            QUOTE(Function));                                            \
       return false;                                                     \
+    }                                                                   \
   }
 
+// This macro looks up a function name, but only if the API version is above
+// the specified minimum.
+#define LOOKUP_ALL(min, Name, Function)                                \
+  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.
@@ -416,6 +426,8 @@ class Adapter {
      */
     wvcdm::metrics::MetricsGroup metrics;
 
+    level1_ = FunctionPointers();  // start with all null pointers.
+    level3_ = FunctionPointers();  // start with all null pointers.
     LoadLevel3();
     std::string base_path;
     wvcdm::Properties::GetDeviceFilesBasePath(wvcdm::kSecurityLevelL3,
@@ -473,30 +485,12 @@ class Adapter {
 
   bool LoadLevel1(wvcdm::metrics::MetricsGroup& metrics) {
     level1_valid_ = true;
-    LOOKUP(Initialize,               OEMCrypto_Initialize);
+    const uint32_t kMinimumVersion = 8;
-    LOOKUP(Terminate,                OEMCrypto_Terminate);
+    const uint32_t kMaximumVersion = 13;
-    LOOKUP(OpenSession,              OEMCrypto_OpenSession);
+    level1_.version = kMinimumVersion;
-    LOOKUP(CloseSession,             OEMCrypto_CloseSession);
+    LOOKUP_ALL(8, Initialize, OEMCrypto_Initialize);
-    LOOKUP(GenerateDerivedKeys,      OEMCrypto_GenerateDerivedKeys);
+    LOOKUP_ALL(8, APIVersion, OEMCrypto_APIVersion);
-    LOOKUP(GenerateNonce,            OEMCrypto_GenerateNonce);
+    LOOKUP_ALL(8, Terminate,  OEMCrypto_Terminate);
-    LOOKUP(GenerateSignature,        OEMCrypto_GenerateSignature);
-    LOOKUP(RefreshKeys,              OEMCrypto_RefreshKeys);
-    LOOKUP(SelectKey,                OEMCrypto_SelectKey);
-    LOOKUP(InstallKeybox,            OEMCrypto_InstallKeybox);
-    LOOKUP(IsKeyboxValid,            OEMCrypto_IsKeyboxValid);
-    LOOKUP(GetDeviceID,              OEMCrypto_GetDeviceID);
-    LOOKUP(GetKeyData,               OEMCrypto_GetKeyData);
-    LOOKUP(GetRandom,                OEMCrypto_GetRandom);
-    LOOKUP(WrapKeybox,               OEMCrypto_WrapKeybox);
-    LOOKUP(RewrapDeviceRSAKey,       OEMCrypto_RewrapDeviceRSAKey);
-    LOOKUP(LoadDeviceRSAKey,         OEMCrypto_LoadDeviceRSAKey);
-    LOOKUP(DeriveKeysFromSessionKey, OEMCrypto_DeriveKeysFromSessionKey);
-    LOOKUP(APIVersion,               OEMCrypto_APIVersion);
-    LOOKUP(SecurityLevel,            OEMCrypto_SecurityLevel);
-    LOOKUP(Generic_Decrypt,          OEMCrypto_Generic_Decrypt);
-    LOOKUP(Generic_Encrypt,          OEMCrypto_Generic_Encrypt);
-    LOOKUP(Generic_Sign,             OEMCrypto_Generic_Sign);
-    LOOKUP(Generic_Verify,           OEMCrypto_Generic_Verify);
     if (!level1_valid_) {
       M_RECORD(
           &metrics,
@@ -516,7 +510,6 @@ class Adapter {
       return false;
     }
     level1_.version = level1_.APIVersion();
-    const uint32_t kMinimumVersion = 8;
     M_RECORD(
         &metrics,
         oemcrypto_l1_api_version_,
@@ -534,74 +527,74 @@ class Adapter {
       level1_.Terminate();
       return false;
     }
-    if (level1_.version == 8) {
+
-      LOOKUP(LoadKeys_V8,             OEMCrypto_LoadKeys_V8);
+    // clang-format off
-      LOOKUP(GenerateRSASignature_V8, OEMCrypto_GenerateRSASignature_V8);
+    LOOKUP_ALL( 8, CloseSession,             OEMCrypto_CloseSession);
-    } else {  // version >= 9
+    LOOKUP_ALL(10, CopyBuffer,               OEMCrypto_CopyBuffer);
-      LOOKUP(GenerateRSASignature,    OEMCrypto_GenerateRSASignature);
+    LOOKUP_ALL(13, CopyOldUsageEntry,        OEMCrypto_CopyOldUsageEntry);
-      LOOKUP(SupportsUsageTable,      OEMCrypto_SupportsUsageTable);
+    LOOKUP_ALL(13, CreateNewUsageEntry,      OEMCrypto_CreateNewUsageEntry);
-      // TODO(fredgc): only use these if version < 13.
+    LOOKUP_ALL(13, CreateOldUsageEntry,      OEMCrypto_CreateOldUsageEntry);
-      LOOKUP(ReportUsage,             OEMCrypto_ReportUsage);
+    LOOKUP_ALL(13, CreateUsageTableHeader,   OEMCrypto_CreateUsageTableHeader);
-      LOOKUP(DeleteOldUsageTable,        OEMCrypto_DeleteOldUsageTable);
+    LOOKUP( 9, 12, DeactivateUsageEntry_V12, OEMCrypto_DeactivateUsageEntry_V12);
-      // TODO(fredgc): remove this hack after unit tests have been fixed.
+    LOOKUP_ALL(13, DeactivateUsageEntry,     OEMCrypto_DeactivateUsageEntry);
-      // TODO(fredgc) if (level1_.version < 13) {
+    LOOKUP( 8, 10, DecryptCTR_V10,           OEMCrypto_DecryptCTR_V10);
-      LOOKUP(UpdateUsageTable,         OEMCrypto_UpdateUsageTable);
+    LOOKUP_ALL(11, DecryptCENC,              OEMCrypto_DecryptCENC);
-      if (level1_.version < 13 ) {
+    LOOKUP_ALL( 9, DeleteOldUsageTable,      OEMCrypto_DeleteOldUsageTable);
-        LOOKUP(DeactivateUsageEntry_V12, OEMCrypto_DeactivateUsageEntry_V12);
+    LOOKUP( 9, 12, DeleteUsageEntry,         OEMCrypto_DeleteUsageEntry);
-      }
+    LOOKUP_ALL( 8, DeriveKeysFromSessionKey, OEMCrypto_DeriveKeysFromSessionKey);
-      LOOKUP(DeleteUsageEntry,         OEMCrypto_DeleteUsageEntry);
+    LOOKUP(10, 12, ForceDeleteUsageEntry,    OEMCrypto_ForceDeleteUsageEntry);
-      // TODO(fredgc): }
+    LOOKUP_ALL( 8, GenerateDerivedKeys,      OEMCrypto_GenerateDerivedKeys);
-      if (level1_.version == 9) {
+    LOOKUP_ALL( 8, GenerateNonce,            OEMCrypto_GenerateNonce);
-        LOOKUP(LoadKeys_V9_or_V10,      OEMCrypto_LoadKeys_V9_or_V10);
+    LOOKUP( 8,  8, GenerateRSASignature_V8,  OEMCrypto_GenerateRSASignature_V8);
-        LOOKUP(GetHDCPCapability_V9,    OEMCrypto_GetHDCPCapability_V9);
+    LOOKUP_ALL( 9, GenerateRSASignature,     OEMCrypto_GenerateRSASignature);
-      } else {  // version >= 10.
+    LOOKUP_ALL( 8, GenerateSignature,        OEMCrypto_GenerateSignature);
-        LOOKUP(LoadTestKeybox,          OEMCrypto_LoadTestKeybox);
+    LOOKUP_ALL( 8, Generic_Decrypt,          OEMCrypto_Generic_Decrypt);
-        LOOKUP(LoadTestRSAKey,          OEMCrypto_LoadTestRSAKey);
+    LOOKUP_ALL( 8, Generic_Encrypt,          OEMCrypto_Generic_Encrypt);
-        LOOKUP(QueryKeyControl,         OEMCrypto_QueryKeyControl);
+    LOOKUP_ALL( 8, Generic_Sign,             OEMCrypto_Generic_Sign);
-        LOOKUP(CopyBuffer,              OEMCrypto_CopyBuffer);
+    LOOKUP_ALL( 8, Generic_Verify,           OEMCrypto_Generic_Verify);
-        LOOKUP(GetHDCPCapability,       OEMCrypto_GetHDCPCapability);
+    LOOKUP_ALL(13, GetCurrentSRMVersion,     OEMCrypto_GetCurrentSRMVersion);
-        LOOKUP(IsAntiRollbackHwPresent, OEMCrypto_IsAntiRollbackHwPresent);
+    LOOKUP_ALL( 8, GetDeviceID,              OEMCrypto_GetDeviceID);
-        LOOKUP(GetNumberOfOpenSessions, OEMCrypto_GetNumberOfOpenSessions);
+    LOOKUP( 9,  9, GetHDCPCapability_V9,     OEMCrypto_GetHDCPCapability_V9);
-        LOOKUP(GetMaxNumberOfSessions,  OEMCrypto_GetMaxNumberOfSessions);
+    LOOKUP_ALL(10, GetHDCPCapability,        OEMCrypto_GetHDCPCapability);
-        // TODO(fredgc): if (level1_.version < 13) {
+    LOOKUP_ALL( 8, GetKeyData,               OEMCrypto_GetKeyData);
-          LOOKUP(ForceDeleteUsageEntry,   OEMCrypto_ForceDeleteUsageEntry);
+    LOOKUP_ALL(10, GetMaxNumberOfSessions,   OEMCrypto_GetMaxNumberOfSessions);
-          // TODO(fredgc):  }
+    LOOKUP_ALL(10, GetNumberOfOpenSessions,  OEMCrypto_GetNumberOfOpenSessions);
-        if (level1_.version == 10) {
+    LOOKUP_ALL(12, GetOEMPublicCertificate,  OEMCrypto_GetOEMPublicCertificate);
-          LOOKUP(LoadKeys_V9_or_V10,      OEMCrypto_LoadKeys_V9_or_V10);
+    LOOKUP_ALL(12, GetProvisioningMethod,    OEMCrypto_GetProvisioningMethod);
-          LOOKUP(DecryptCTR_V10,          OEMCrypto_DecryptCTR_V10);
+    LOOKUP_ALL( 8, GetRandom,                OEMCrypto_GetRandom);
-        } else {  // version >= 11.
+    LOOKUP_ALL( 8, InstallKeybox,            OEMCrypto_InstallKeybox);
-          LOOKUP(DecryptCENC,             OEMCrypto_DecryptCENC);
+    LOOKUP_ALL(10, IsAntiRollbackHwPresent,  OEMCrypto_IsAntiRollbackHwPresent);
-          LOOKUP(SecurityPatchLevel,      OEMCrypto_Security_Patch_Level);
+    LOOKUP_ALL( 8, IsKeyboxValid,            OEMCrypto_IsKeyboxValid);
-          if (level1_.version == 11) {
+    LOOKUP_ALL(13, IsSRMUpdateSupported,     OEMCrypto_IsSRMUpdateSupported);
-            LOOKUP(LoadKeys_V12,            OEMCrypto_LoadKeys_V12);
+    LOOKUP_ALL( 8, LoadDeviceRSAKey,         OEMCrypto_LoadDeviceRSAKey);
-          } else {  // version >= 12.
+    LOOKUP( 8,  8, LoadKeys_V8,              OEMCrypto_LoadKeys_V8);
-            LOOKUP(GetProvisioningMethod,   OEMCrypto_GetProvisioningMethod);
+    LOOKUP( 9, 10, LoadKeys_V9_or_V10,       OEMCrypto_LoadKeys_V9_or_V10);
-            LOOKUP(GetOEMPublicCertificate, OEMCrypto_GetOEMPublicCertificate);
+    LOOKUP(11, 12, LoadKeys_V11_or_V12,      OEMCrypto_LoadKeys_V11_or_V12);
-            LOOKUP(RewrapDeviceRSAKey30,    OEMCrypto_RewrapDeviceRSAKey30);
+    LOOKUP_ALL(13, LoadKeys,                 OEMCrypto_LoadKeys);
-            if (level1_.version == 12) {
+    LOOKUP_ALL(13, LoadSRM,                  OEMCrypto_LoadSRM);
-              LOOKUP(LoadKeys_V12,            OEMCrypto_LoadKeys_V12);
+    LOOKUP_ALL(10, LoadTestKeybox,           OEMCrypto_LoadTestKeybox);
-            } else {  // version >= 13.
+    LOOKUP_ALL(10, LoadTestRSAKey,           OEMCrypto_LoadTestRSAKey);
-              LOOKUP(LoadKeys,               OEMCrypto_LoadKeys);
+    LOOKUP_ALL(13, LoadUsageEntry,           OEMCrypto_LoadUsageEntry);
-              LOOKUP(SupportedCertificates,  OEMCrypto_SupportedCertificates);
+    LOOKUP_ALL(13, LoadUsageTableHeader,     OEMCrypto_LoadUsageTableHeader);
-              LOOKUP(IsSRMUpdateSupported,   OEMCrypto_IsSRMUpdateSupported);
+    LOOKUP_ALL(13, MoveEntry,                OEMCrypto_MoveEntry);
-              LOOKUP(GetCurrentSRMVersion,   OEMCrypto_GetCurrentSRMVersion);
+    LOOKUP_ALL( 8, OpenSession,              OEMCrypto_OpenSession);
-              LOOKUP(LoadSRM,                OEMCrypto_LoadSRM);
+    LOOKUP_ALL(10, QueryKeyControl,          OEMCrypto_QueryKeyControl);
-              LOOKUP(RemoveSRM,              OEMCrypto_RemoveSRM);
+    LOOKUP_ALL( 8, RefreshKeys,              OEMCrypto_RefreshKeys);
-              LOOKUP(CreateUsageTableHeader, OEMCrypto_CreateUsageTableHeader);
+    LOOKUP_ALL(13, RemoveSRM,                OEMCrypto_RemoveSRM);
-              LOOKUP(LoadUsageTableHeader,   OEMCrypto_LoadUsageTableHeader);
+    LOOKUP_ALL( 9, ReportUsage,              OEMCrypto_ReportUsage);
-              LOOKUP(CreateNewUsageEntry,    OEMCrypto_CreateNewUsageEntry);
+    LOOKUP_ALL( 8, RewrapDeviceRSAKey,       OEMCrypto_RewrapDeviceRSAKey);
-              LOOKUP(LoadUsageEntry,         OEMCrypto_LoadUsageEntry);
+    LOOKUP_ALL(12, RewrapDeviceRSAKey30,     OEMCrypto_RewrapDeviceRSAKey30);
-              LOOKUP(UpdateUsageEntry,       OEMCrypto_UpdateUsageEntry);
+    LOOKUP_ALL( 8, SecurityLevel,            OEMCrypto_SecurityLevel);
-              LOOKUP(DeactivateUsageEntry,   OEMCrypto_DeactivateUsageEntry);
+    LOOKUP_ALL(11, SecurityPatchLevel,       OEMCrypto_Security_Patch_Level);
-              LOOKUP(ShrinkUsageTableHeader, OEMCrypto_ShrinkUsageTableHeader);
+    LOOKUP_ALL( 8, SelectKey,                OEMCrypto_SelectKey);
-              LOOKUP(MoveEntry,              OEMCrypto_MoveEntry);
+    LOOKUP_ALL(13, ShrinkUsageTableHeader,   OEMCrypto_ShrinkUsageTableHeader);
-              LOOKUP(CopyOldUsageEntry,      OEMCrypto_CopyOldUsageEntry);
+    LOOKUP_ALL(13, SupportedCertificates,    OEMCrypto_SupportedCertificates);
-              LOOKUP(CreateOldUsageEntry,    OEMCrypto_CreateOldUsageEntry);
+    LOOKUP_ALL( 9, SupportsUsageTable,       OEMCrypto_SupportsUsageTable);
-            }
+    LOOKUP_ALL(13, UpdateUsageEntry,         OEMCrypto_UpdateUsageEntry);
-          }
+    LOOKUP( 9, 12, UpdateUsageTable,         OEMCrypto_UpdateUsageTable);
-        }
+    LOOKUP_ALL( 8, WrapKeybox,               OEMCrypto_WrapKeybox);
-      }
+    // clang-format on
-    }
+
     // If we have a valid keybox, initialization is done. We're good.
     if (OEMCrypto_SUCCESS == level1_.IsKeyboxValid()) {
       M_RECORD(
@@ -698,6 +691,7 @@ class Adapter {
   }
 
   void LoadLevel3() {
+    // clang-format off
     level3_.Terminate                = Level3_Terminate;
     level3_.OpenSession              = Level3_OpenSession;
     level3_.CloseSession             = Level3_CloseSession;
@@ -734,11 +728,8 @@ class Adapter {
     level3_.Generic_Encrypt          = Level3_Generic_Encrypt;
     level3_.Generic_Sign             = Level3_Generic_Sign;
     level3_.Generic_Verify           = Level3_Generic_Verify;
-    level3_.UpdateUsageTable = Level3_UpdateUsageTable;
     level3_.DeactivateUsageEntry     = Level3_DeactivateUsageEntry;
     level3_.ReportUsage              = Level3_ReportUsage;
-    level3_.DeleteUsageEntry = Level3_DeleteUsageEntry;
-    level3_.ForceDeleteUsageEntry = Level3_ForceDeleteUsageEntry;
     level3_.DeleteOldUsageTable      = Level3_DeleteOldUsageTable;
     level3_.GetProvisioningMethod    = Level3_GetProvisioningMethod;
     level3_.GetOEMPublicCertificate  = Level3_GetOEMPublicCertificate;
@@ -748,8 +739,7 @@ class Adapter {
     level3_.GetCurrentSRMVersion     = Level3_GetCurrentSRMVersion;
     level3_.LoadSRM                  = Level3_LoadSRM;
     level3_.RemoveSRM                = Level3_RemoveSRM;
-    // TODO(fredgc): add stub.
+    level3_.CreateUsageTableHeader   = Level3_CreateUsageTableHeader;
-    // level3_.CreateUsageTableHeader = Level3_CreateUsageTableHeader;
     level3_.LoadUsageTableHeader     = Level3_LoadUsageTableHeader;
     level3_.CreateNewUsageEntry      = Level3_CreateNewUsageEntry;
     level3_.LoadUsageEntry           = Level3_LoadUsageEntry;
@@ -757,8 +747,8 @@ class Adapter {
     level3_.ShrinkUsageTableHeader   = Level3_ShrinkUsageTableHeader;
     level3_.MoveEntry                = Level3_MoveEntry;
     level3_.CopyOldUsageEntry        = Level3_CopyOldUsageEntry;
-    // TODO(fredgc): add stub.
+    level3_.CreateOldUsageEntry      = Level3_CreateOldUsageEntry;
-    // level3_.CreateOldUsageEntry = Level3_CreateOldUsageEntry;
+    // clang-format on
 
     level3_.version = Level3_APIVersion();
   }
@@ -869,6 +859,7 @@ OEMCryptoResult OEMCrypto_CopyBuffer(
   const FunctionPointers* fcn = kAdapter->get(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;
   return fcn->CopyBuffer(data_addr, data_length, out_buffer, subsample_flags);
 }
 
@@ -878,6 +869,7 @@ OEMCryptoResult OEMCrypto_InstallKeybox(const uint8_t* keybox,
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   const FunctionPointers* fcn = kAdapter->get(level);
   if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
+  if (fcn->InstallKeybox == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return fcn->InstallKeybox(keybox, keyBoxLength);
 }
 
@@ -887,6 +879,7 @@ OEMCrypto_ProvisioningMethod OEMCrypto_GetProvisioningMethod(
   const FunctionPointers* fcn = kAdapter->get(level);
   if (!fcn) return OEMCrypto_ProvisioningError;
   if (fcn->version < 12) return OEMCrypto_Keybox;
+  if (fcn->GetProvisioningMethod == NULL) return OEMCrypto_Keybox;
   return fcn->GetProvisioningMethod();
 }
 
@@ -894,6 +887,7 @@ OEMCryptoResult OEMCrypto_IsKeyboxValid(SecurityLevel level) {
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   const FunctionPointers* fcn = kAdapter->get(level);
   if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
+  if (fcn->IsKeyboxValid == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return fcn->IsKeyboxValid();
 }
 
@@ -902,6 +896,7 @@ OEMCryptoResult OEMCrypto_GetDeviceID(uint8_t* deviceID, size_t* idLength,
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   const FunctionPointers* fcn = kAdapter->get(level);
   if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
+  if (fcn->GetDeviceID == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return fcn->GetDeviceID(deviceID, idLength);
 }
 
@@ -910,6 +905,7 @@ OEMCryptoResult OEMCrypto_GetKeyData(uint8_t* keyData, size_t* keyDataLength,
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   const FunctionPointers* fcn = kAdapter->get(level);
   if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
+  if (fcn->GetKeyData == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return fcn->GetKeyData(keyData, keyDataLength);
 }
 
@@ -917,6 +913,7 @@ uint32_t OEMCrypto_APIVersion(SecurityLevel level) {
   if (!kAdapter) return 0;
   const FunctionPointers* fcn = kAdapter->get(level);
   if (!fcn) return 0;
+  if (fcn->APIVersion == NULL) return 0;
   return fcn->APIVersion();
 }
 
@@ -925,6 +922,7 @@ uint8_t OEMCrypto_Security_Patch_Level(SecurityLevel level) {
   const FunctionPointers* fcn = kAdapter->get(level);
   if (!fcn) return 0;
   if (fcn->version < 11) return 0;
+  if (fcn->SecurityPatchLevel == NULL) return 0;
   return fcn->SecurityPatchLevel();
 }
 
@@ -932,6 +930,7 @@ const char* OEMCrypto_SecurityLevel(SecurityLevel level) {
   if (!kAdapter) return "";
   const FunctionPointers* fcn = kAdapter->get(level);
   if (!fcn) return "";
+  if (fcn->SecurityLevel == NULL) return "";
   return fcn->SecurityLevel();
 }
 
@@ -946,11 +945,15 @@ OEMCryptoResult OEMCrypto_GetHDCPCapability(
     if (current == NULL) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
     if (maximum == NULL) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
     uint8_t current_byte, maximum_byte;
-    OEMCryptoResult sts = fcn->GetHDCPCapability_V9(&current_byte, &maximum_byte);
+    if (fcn->GetHDCPCapability_V9 == NULL)
+      return OEMCrypto_ERROR_NOT_IMPLEMENTED;
+    OEMCryptoResult sts =
+        fcn->GetHDCPCapability_V9(&current_byte, &maximum_byte);
     *current = static_cast<OEMCrypto_HDCP_Capability>(current_byte);
     *maximum = static_cast<OEMCrypto_HDCP_Capability>(maximum_byte);
     return sts;
   } else {
+    if (fcn->GetHDCPCapability == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
     return fcn->GetHDCPCapability(current, maximum);
   }
 }
@@ -960,6 +963,7 @@ bool OEMCrypto_SupportsUsageTable(SecurityLevel level) {
   const FunctionPointers* fcn = kAdapter->get(level);
   if (!fcn) return false;
   if (fcn->version == 8) return false;
+  if (fcn->SupportsUsageTable == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return fcn->SupportsUsageTable();
 }
 
@@ -968,6 +972,8 @@ bool OEMCrypto_IsAntiRollbackHwPresent(SecurityLevel level) {
   const FunctionPointers* fcn = kAdapter->get(level);
   if (!fcn) return false;
   if (fcn->version < 10) return false;
+  if (fcn->IsAntiRollbackHwPresent == NULL)
+    return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return fcn->IsAntiRollbackHwPresent();
 }
 
@@ -986,6 +992,8 @@ OEMCryptoResult OEMCrypto_GetMaxNumberOfSessions(SecurityLevel level,
   const FunctionPointers* fcn = kAdapter->get(level);
   if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (fcn->version < 10) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
+  if (fcn->GetMaxNumberOfSessions == NULL)
+    return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return fcn->GetMaxNumberOfSessions(maximum);
 }
 
@@ -995,6 +1003,7 @@ uint32_t OEMCrypto_SupportedCertificates(SecurityLevel level) {
   if (!fcn) return 0;
   // Default is to support 2048 bit RSA keys.
   if (fcn->version < 13) return OEMCrypto_Supports_RSA_2048bit;
+  if (fcn->SupportedCertificates == NULL) return OEMCrypto_Supports_RSA_2048bit;
   return fcn->SupportedCertificates();
 }
 
@@ -1005,7 +1014,8 @@ OEMCryptoResult OEMCrypto_CreateUsageTableHeader(SecurityLevel level,
   const FunctionPointers* fcn = kAdapter->get(level);
   if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (fcn->version < 13) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
-  if (!fcn->CreateUsageTableHeader) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
+  if (fcn->CreateUsageTableHeader == NULL)
+    return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return fcn->CreateUsageTableHeader(header_buffer, header_buffer_length);
 }
 
@@ -1016,6 +1026,7 @@ OEMCryptoResult OEMCrypto_LoadUsageTableHeader(SecurityLevel level,
   const FunctionPointers* fcn = kAdapter->get(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;
   return fcn->LoadUsageTableHeader(buffer, buffer_length);
 }
 
@@ -1027,7 +1038,8 @@ OEMCryptoResult OEMCrypto_ShrinkUsageTableHeader(SecurityLevel level,
   const FunctionPointers* fcn = kAdapter->get(level);
   if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (fcn->version < 13) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
-  if (!fcn->ShrinkUsageTableHeader) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
+  if (fcn->ShrinkUsageTableHeader == NULL)
+    return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return fcn->ShrinkUsageTableHeader(new_table_size, header_buffer,
                                      header_buffer_length);
 }
@@ -1041,7 +1053,7 @@ OEMCryptoResult OEMCrypto_CreateOldUsageEntry(
   const FunctionPointers* fcn = kAdapter->get(level);
   if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (fcn->version < 13) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
-  if (!fcn->CreateOldUsageEntry) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
+  if (fcn->CreateOldUsageEntry == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return fcn->CreateOldUsageEntry(
       time_since_license_received, time_since_first_decrypt,
       time_since_last_decrypt, status, server_mac_key, client_mac_key, pst,
@@ -1084,6 +1096,8 @@ extern "C" OEMCryptoResult OEMCrypto_GenerateDerivedKeys(
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   LevelSession pair = kAdapter->get(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
+  if (pair.fcn->GenerateDerivedKeys == NULL)
+    return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return pair.fcn->GenerateDerivedKeys(pair.session, mac_key_context,
                                        mac_key_context_length, enc_key_context,
                                        enc_key_context_length);
@@ -1094,6 +1108,7 @@ extern "C" OEMCryptoResult OEMCrypto_GenerateNonce(OEMCrypto_SESSION session,
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   LevelSession pair = kAdapter->get(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);
 }
 
@@ -1103,6 +1118,8 @@ extern "C" OEMCryptoResult OEMCrypto_GenerateSignature(
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   LevelSession pair = kAdapter->get(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
+  if (pair.fcn->GenerateSignature == NULL)
+    return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return pair.fcn->GenerateSignature(pair.session, message, message_length,
                                      signature, signature_length);
 }
@@ -1111,15 +1128,14 @@ extern "C" OEMCryptoResult OEMCrypto_LoadKeys(
     OEMCrypto_SESSION session, const uint8_t* message, size_t message_length,
     const uint8_t* signature, size_t signature_length,
     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,
+    const OEMCrypto_KeyObject* key_array, const uint8_t* pst, size_t pst_length,
-    size_t pst_length, const uint8_t* srm_requirement) {
+    const uint8_t* srm_requirement) {
-
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   LevelSession pair = kAdapter->get(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (pair.fcn->version < 11) {
     std::vector<OEMCrypto_KeyObject_V10> key_array_v10(num_keys);
-    for(size_t i=0; i < num_keys; i++) {
+    for (size_t i = 0; i < num_keys; i++) {
       key_array_v10[i].key_id = key_array[i].key_id;
       key_array_v10[i].key_id_length = key_array[i].key_id_length;
       key_array_v10[i].key_data_iv = key_array[i].key_data_iv;
@@ -1133,27 +1149,31 @@ extern "C" OEMCryptoResult OEMCrypto_LoadKeys(
       }
     }
     if (pair.fcn->version == 8) {
+      if (pair.fcn->LoadKeys_V8 == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
       return pair.fcn->LoadKeys_V8(pair.session, message, message_length,
                                    signature, signature_length, enc_mac_key_iv,
                                    enc_mac_key, num_keys, &key_array_v10[0]);
     } else {
+      if (pair.fcn->LoadKeys_V9_or_V10 == NULL)
+        return OEMCrypto_ERROR_NOT_IMPLEMENTED;
       return pair.fcn->LoadKeys_V9_or_V10(pair.session, message, message_length,
                                           signature, signature_length,
-                                          enc_mac_key_iv, enc_mac_key,
+                                          enc_mac_key_iv, enc_mac_key, num_keys,
-                                          num_keys, &key_array_v10[0],
+                                          &key_array_v10[0], pst, pst_length);
-                                          pst, pst_length);
     }
   } else {
     if (pair.fcn->version < 13) {
-      return pair.fcn->LoadKeys_V12(pair.session, message, message_length,
+      if (pair.fcn->LoadKeys_V11_or_V12 == NULL)
+        return OEMCrypto_ERROR_NOT_IMPLEMENTED;
+      return pair.fcn->LoadKeys_V11_or_V12(
+          pair.session, message, message_length, signature, signature_length,
+          enc_mac_key_iv, enc_mac_key, num_keys, key_array, pst, pst_length);
+    } else {
+      if (pair.fcn->LoadKeys == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
+      return pair.fcn->LoadKeys(pair.session, message, message_length,
                                 signature, signature_length, enc_mac_key_iv,
                                 enc_mac_key, num_keys, key_array, pst,
-                                    pst_length);
+                                pst_length, srm_requirement);
-    }  else {
-      return pair.fcn->LoadKeys(pair.session, message, message_length, signature,
-                                signature_length, enc_mac_key_iv, enc_mac_key,
-                                num_keys, key_array, pst, pst_length,
-                                srm_requirement);
     }
   }
 }
@@ -1165,6 +1185,7 @@ extern "C" OEMCryptoResult OEMCrypto_RefreshKeys(
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   LevelSession pair = kAdapter->get(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,
                                signature_length, num_keys, key_array);
 }
@@ -1176,6 +1197,7 @@ extern "C" OEMCryptoResult OEMCrypto_QueryKeyControl(
   LevelSession pair = kAdapter->get(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;
   return pair.fcn->QueryKeyControl(pair.session, key_id, key_id_length,
                                    key_control_block, key_control_block_length);
 }
@@ -1186,6 +1208,7 @@ extern "C" OEMCryptoResult OEMCrypto_SelectKey(const OEMCrypto_SESSION session,
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   LevelSession pair = kAdapter->get(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
+  if (pair.fcn->SelectKey == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return pair.fcn->SelectKey(pair.session, key_id, key_id_length);
 }
 
@@ -1193,16 +1216,18 @@ extern "C" OEMCryptoResult OEMCrypto_DecryptCENC(
     OEMCrypto_SESSION session, const uint8_t* data_addr, size_t data_length,
     bool is_encrypted, const uint8_t* iv, size_t offset,
     OEMCrypto_DestBufferDesc* out_buffer,
-    const OEMCrypto_CENCEncryptPatternDesc* pattern,
+    const OEMCrypto_CENCEncryptPatternDesc* pattern, uint8_t subsample_flags) {
-    uint8_t subsample_flags) {
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   LevelSession pair = kAdapter->get(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (pair.fcn->version < 11) {
+    if (pair.fcn->DecryptCTR_V10 == NULL)
+      return OEMCrypto_ERROR_NOT_IMPLEMENTED;
     return pair.fcn->DecryptCTR_V10(pair.session, data_addr, data_length,
                                     is_encrypted, iv, offset, out_buffer,
                                     subsample_flags);
   } else {
+    if (pair.fcn->DecryptCENC == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
     return pair.fcn->DecryptCENC(pair.session, data_addr, data_length,
                                  is_encrypted, iv, offset, out_buffer, pattern,
                                  subsample_flags);
@@ -1225,6 +1250,7 @@ extern "C" OEMCryptoResult OEMCrypto_WrapKeybox(const uint8_t* keybox,
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   const FunctionPointers* fcn = kAdapter->get(kLevelDefault);
   if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
+  if (fcn->WrapKeybox == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return fcn->WrapKeybox(keybox, keyBoxLength, wrappedKeybox,
                          wrappedKeyBoxLength, transportKey, transportKeyLength);
 }
@@ -1239,6 +1265,7 @@ extern "C" OEMCryptoResult OEMCrypto_LoadTestKeybox() {
   const FunctionPointers* fcn = kAdapter->get(kLevelDefault);
   if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (fcn->version < 10) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
+  if (fcn->LoadTestKeybox == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return fcn->LoadTestKeybox();
 }
 
@@ -1251,13 +1278,14 @@ extern "C" OEMCrypto_ProvisioningMethod OEMCrypto_GetProvisioningMethod() {
 }
 
 extern "C" OEMCryptoResult OEMCrypto_GetOEMPublicCertificate(
-                                  OEMCrypto_SESSION session,
+    OEMCrypto_SESSION session, uint8_t* public_cert,
-                                  uint8_t *public_cert,
+    size_t* public_cert_length) {
-                                  size_t *public_cert_length) {
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   LevelSession pair = kAdapter->get(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (pair.fcn->version < 12) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
+  if (pair.fcn->GetOEMPublicCertificate == NULL)
+    return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return pair.fcn->GetOEMPublicCertificate(pair.session, public_cert,
                                            public_cert_length);
 }
@@ -1277,6 +1305,7 @@ extern "C" OEMCryptoResult OEMCrypto_GetRandom(uint8_t* randomData,
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   const FunctionPointers* fcn = kAdapter->get(kLevelDefault);
   if (!fcn) return OEMCrypto_ERROR_INVALID_SESSION;
+  if (fcn->GetRandom == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return fcn->GetRandom(randomData, dataLength);
 }
 
@@ -1294,6 +1323,8 @@ extern "C" OEMCryptoResult OEMCrypto_RewrapDeviceRSAKey30(
   LevelSession pair = kAdapter->get(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (pair.fcn->version < 12) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
+  if (pair.fcn->RewrapDeviceRSAKey30 == NULL)
+    return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return pair.fcn->RewrapDeviceRSAKey30(session, nonce, encrypted_message_key,
                                         encrypted_message_key_length,
                                         enc_rsa_key, enc_rsa_key_length,
@@ -1301,7 +1332,6 @@ extern "C" OEMCryptoResult OEMCrypto_RewrapDeviceRSAKey30(
                                         wrapped_rsa_key_length);
 }
 
-
 extern "C" OEMCryptoResult OEMCrypto_RewrapDeviceRSAKey(
     OEMCrypto_SESSION session, const uint8_t* message, size_t message_length,
     const uint8_t* signature, size_t signature_length, const uint32_t* nonce,
@@ -1311,6 +1341,8 @@ extern "C" OEMCryptoResult OEMCrypto_RewrapDeviceRSAKey(
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   LevelSession pair = kAdapter->get(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
+  if (pair.fcn->RewrapDeviceRSAKey == NULL)
+    return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return pair.fcn->RewrapDeviceRSAKey(
       pair.session, message, message_length, signature, signature_length, nonce,
       enc_rsa_key, enc_rsa_key_length, enc_rsa_key_iv, wrapped_rsa_key,
@@ -1323,6 +1355,8 @@ extern "C" OEMCryptoResult OEMCrypto_LoadDeviceRSAKey(
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   LevelSession pair = kAdapter->get(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
+  if (pair.fcn->LoadDeviceRSAKey == NULL)
+    return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return pair.fcn->LoadDeviceRSAKey(pair.session, wrapped_rsa_key,
                                     wrapped_rsa_key_length);
 }
@@ -1332,6 +1366,7 @@ extern "C" OEMCryptoResult OEMCrypto_LoadTestRSAKey() {
   const FunctionPointers* fcn = kAdapter->get(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;
   return fcn->LoadTestRSAKey();
 }
 
@@ -1343,9 +1378,13 @@ extern "C" OEMCryptoResult OEMCrypto_GenerateRSASignature(
   LevelSession pair = kAdapter->get(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (pair.fcn->version == 8) {
+    if (pair.fcn->GenerateRSASignature_V8 == NULL)
+      return OEMCrypto_ERROR_NOT_IMPLEMENTED;
     return pair.fcn->GenerateRSASignature_V8(
         pair.session, message, message_length, signature, signature_length);
   } else {
+    if (pair.fcn->GenerateRSASignature == NULL)
+      return OEMCrypto_ERROR_NOT_IMPLEMENTED;
     return pair.fcn->GenerateRSASignature(pair.session, message, message_length,
                                           signature, signature_length,
                                           padding_scheme);
@@ -1360,6 +1399,8 @@ extern "C" OEMCryptoResult OEMCrypto_DeriveKeysFromSessionKey(
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   LevelSession pair = kAdapter->get(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
+  if (pair.fcn->DeriveKeysFromSessionKey == NULL)
+    return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return pair.fcn->DeriveKeysFromSessionKey(
       pair.session, enc_session_key, enc_session_key_length, mac_key_context,
       mac_key_context_length, enc_key_context, enc_key_context_length);
@@ -1408,20 +1449,19 @@ extern "C" OEMCryptoResult OEMCrypto_Generic_Encrypt(
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   LevelSession pair = kAdapter->get(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
+  if (pair.fcn->Generic_Encrypt == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   OEMCryptoResult status = OEMCrypto_SUCCESS;
   std::vector<uint8_t> current_iv(iv, iv + wvcdm::KEY_IV_SIZE);
   while (buffer_length > 0 && status == OEMCrypto_SUCCESS) {
-    const size_t chunk_size = std::min(buffer_length,
+    const size_t chunk_size =
-                                       kMaxGenericEncryptChunkSize);
+        std::min(buffer_length, kMaxGenericEncryptChunkSize);
     status = pair.fcn->Generic_Encrypt(pair.session, in_buffer, chunk_size,
-                                       &current_iv[0],
+                                       &current_iv[0], algorithm, out_buffer);
-                                       algorithm, out_buffer);
     buffer_length -= chunk_size;
     in_buffer += chunk_size;
     out_buffer += chunk_size;
     if (buffer_length > 0) {
-      current_iv.assign(out_buffer - wvcdm::KEY_IV_SIZE,
+      current_iv.assign(out_buffer - wvcdm::KEY_IV_SIZE, out_buffer);
-                        out_buffer);
     }
   }
   return status;
@@ -1433,20 +1473,19 @@ extern "C" OEMCryptoResult OEMCrypto_Generic_Decrypt(
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   LevelSession pair = kAdapter->get(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
+  if (pair.fcn->Generic_Decrypt == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   OEMCryptoResult status = OEMCrypto_SUCCESS;
   std::vector<uint8_t> current_iv(iv, iv + wvcdm::KEY_IV_SIZE);
   while (buffer_length > 0 && status == OEMCrypto_SUCCESS) {
-    const size_t chunk_size = std::min(buffer_length,
+    const size_t chunk_size =
-                                       kMaxGenericEncryptChunkSize);
+        std::min(buffer_length, kMaxGenericEncryptChunkSize);
     status = pair.fcn->Generic_Decrypt(pair.session, in_buffer, chunk_size,
-                                        &current_iv[0],
+                                       &current_iv[0], algorithm, out_buffer);
-                                        algorithm, out_buffer);
     buffer_length -= chunk_size;
     in_buffer += chunk_size;
     out_buffer += chunk_size;
     if (buffer_length > 0) {
-      current_iv.assign(in_buffer - wvcdm::KEY_IV_SIZE,
+      current_iv.assign(in_buffer - wvcdm::KEY_IV_SIZE, in_buffer);
-                        in_buffer);
     }
   }
   return status;
@@ -1472,32 +1511,24 @@ extern "C" OEMCryptoResult OEMCrypto_Generic_Verify(
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   LevelSession pair = kAdapter->get(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,
                                   algorithm, signature, signature_length);
 }
 
-// TODO(fredgc): remove this function when cdm layer doesn't need it.
 extern "C" OEMCryptoResult OEMCrypto_UpdateUsageTable() {
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   const FunctionPointers* fcn1 = kAdapter->get(kLevelDefault);
-  const FunctionPointers* fcn3 = kAdapter->get(kLevel3);
   OEMCryptoResult sts = OEMCrypto_ERROR_NOT_IMPLEMENTED;
-  if (fcn3 && fcn3->version > 8 && fcn3->version < 13) {
+  if ((fcn1 != NULL) && (fcn1->UpdateUsageTable != NULL) &&
-    sts = fcn3->UpdateUsageTable();
+      (fcn1->version > 8) && (fcn1->version < 13)) {
-  }
-  if (fcn1 && fcn1 != fcn3 && fcn1->version > 8 && fcn1->version < 13) {
     sts = fcn1->UpdateUsageTable();
-  } else {
-    // TODO(fredgc): Remove this after unit tests, haystack, and mock
-    // have been updated to v13.  RED:  REMOVE BEFORE FLIGHT -->
-    if (fcn1) sts = fcn1->UpdateUsageTable();
   }
   return sts;
 }
 
-extern "C" OEMCryptoResult OEMCrypto_DeactivateUsageEntry(OEMCrypto_SESSION session,
+extern "C" OEMCryptoResult OEMCrypto_DeactivateUsageEntry(
-                                                          const uint8_t* pst,
+    OEMCrypto_SESSION session, const uint8_t* pst, size_t pst_length) {
-                                                          size_t pst_length) {
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   LevelSession pair = kAdapter->get(session);
   if (!pair.fcn) {
@@ -1508,7 +1539,7 @@ extern "C" OEMCryptoResult OEMCrypto_DeactivateUsageEntry(OEMCrypto_SESSION sess
     const FunctionPointers* fcn3 = kAdapter->get(kLevel3);
     OEMCryptoResult sts = OEMCrypto_ERROR_INVALID_SESSION;
     if (fcn1) {
-      if(fcn1->version < 13) {
+      if (fcn1->version < 13) {
         if (fcn1->DeactivateUsageEntry_V12) {
           sts = fcn1->DeactivateUsageEntry_V12(pst, pst_length);
         } else {
@@ -1524,7 +1555,7 @@ extern "C" OEMCryptoResult OEMCrypto_DeactivateUsageEntry(OEMCrypto_SESSION sess
     }
     if (OEMCrypto_SUCCESS != sts) {
       if (fcn3 && fcn1 != fcn3) {
-        if(fcn3->version < 13) {
+        if (fcn3->version < 13) {
           if (fcn3->DeactivateUsageEntry_V12) {
             sts = fcn3->DeactivateUsageEntry_V12(pst, pst_length);
           } else {
@@ -1546,8 +1577,8 @@ extern "C" OEMCryptoResult OEMCrypto_DeactivateUsageEntry(OEMCrypto_SESSION sess
   if (pair.fcn->version < 9) {
     return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   }
-  if(pair.fcn->version < 13) {
+  if (pair.fcn->version < 13) {
-    if (pair.fcn->DeactivateUsageEntry_V12 ) {
+    if (pair.fcn->DeactivateUsageEntry_V12) {
       return pair.fcn->DeactivateUsageEntry_V12(pst, pst_length);
     } else {
       LOGE("TODO(fredgc):  problem picking function!\n");
@@ -1571,6 +1602,7 @@ extern "C" OEMCryptoResult OEMCrypto_ReportUsage(OEMCrypto_SESSION session,
   LevelSession pair = kAdapter->get(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (pair.fcn->version > 8) {
+    if (pair.fcn->ReportUsage == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
     return pair.fcn->ReportUsage(pair.session, pst, pst_length, buffer,
                                  buffer_length);
   } else {
@@ -1596,18 +1628,20 @@ extern "C" OEMCryptoResult OEMCrypto_DeleteUsageEntry(
   }
 }
 
-extern "C" OEMCryptoResult OEMCrypto_ForceDeleteUsageEntry(
+extern "C" OEMCryptoResult OEMCrypto_ForceDeleteUsageEntry(const uint8_t* pst,
-    const uint8_t* pst, size_t pst_length) {
+                                                           size_t pst_length) {
   LOGE("TODO(fredgc): remove ForceDeleteUsageEntry.");
 
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   const FunctionPointers* fcn1 = kAdapter->get(kLevelDefault);
   const FunctionPointers* fcn3 = kAdapter->get(kLevel3);
   OEMCryptoResult sts = OEMCrypto_ERROR_NOT_IMPLEMENTED;
-  if (fcn3 && fcn3->version > 9) {
+  if (fcn3 && (fcn3->version > 9) && (fcn3->version < 13) &&
+      fcn3->ForceDeleteUsageEntry != NULL) {
     sts = fcn3->ForceDeleteUsageEntry(pst, pst_length);
   }
-  if (fcn1 && fcn1 != fcn3 && fcn1->version > 9) {
+  if (fcn1 && fcn1 != fcn3 && (fcn1->version > 9) && (fcn1->version < 13) &&
+      (fcn1->ForceDeleteUsageEntry != NULL)) {
     OEMCryptoResult sts1 = fcn1->ForceDeleteUsageEntry(pst, pst_length);
     if ((sts1 != OEMCrypto_SUCCESS) && (sts == OEMCrypto_SUCCESS)) {
       sts = sts1;
@@ -1617,133 +1651,137 @@ extern "C" OEMCryptoResult OEMCrypto_ForceDeleteUsageEntry(
 }
 
 extern "C" OEMCryptoResult OEMCrypto_DeleteOldUsageTable() {
-
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   const FunctionPointers* fcn1 = kAdapter->get(kLevelDefault);
   const FunctionPointers* fcn3 = kAdapter->get(kLevel3);
   OEMCryptoResult sts = OEMCrypto_ERROR_NOT_IMPLEMENTED;
-  if (fcn3 && fcn3->version > 8) sts = fcn3->DeleteOldUsageTable();
+  if (fcn3 && (fcn3->version > 8) && (fcn3->DeleteOldUsageTable != NULL)) {
-  if (fcn1 && fcn1 != fcn3 && fcn1->version > 8) sts = fcn1->DeleteOldUsageTable();
+    sts = fcn3->DeleteOldUsageTable();
+  }
+  if (fcn1 && fcn1 != fcn3 &&
+      (fcn1->version > 8) && (fcn1->DeleteOldUsageTable != NULL)) {
+    sts = fcn1->DeleteOldUsageTable();
+  }
   return sts;
 }
 
-extern "C"
+extern "C" bool OEMCrypto_IsSRMUpdateSupported() {
-bool OEMCrypto_IsSRMUpdateSupported() {
   if (!kAdapter) return false;
   // Level 3 can't load an SRM, so this just checkes Level 1.
   const FunctionPointers* fcn = kAdapter->get(kLevelDefault);
   if (!fcn) return false;
   if (fcn->version < 13) return false;
+  if (fcn->IsSRMUpdateSupported == NULL) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return fcn->IsSRMUpdateSupported();
 }
 
-extern "C"
+extern "C" OEMCryptoResult OEMCrypto_GetCurrentSRMVersion(uint16_t* version) {
-OEMCryptoResult OEMCrypto_GetCurrentSRMVersion(uint16_t* version) {
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   // Level 3 can't load an SRM, so this just checkes Level 1.
   const FunctionPointers* fcn = kAdapter->get(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;
   return fcn->GetCurrentSRMVersion(version);
 }
 
-extern "C"
+extern "C" OEMCryptoResult OEMCrypto_LoadSRM(const uint8_t* buffer,
-OEMCryptoResult OEMCrypto_LoadSRM(const uint8_t* buffer,
                                              size_t buffer_length) {
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   // Level 3 can't load an SRM, so this just checkes Level 1.
   const FunctionPointers* fcn = kAdapter->get(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;
   return fcn->LoadSRM(buffer, buffer_length);
 }
 
-extern "C"
+extern "C" OEMCryptoResult OEMCrypto_RemoveSRM() {
-OEMCryptoResult OEMCrypto_RemoveSRM() {
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   // Level 3 can't load an SRM, so this just checkes Level 1.
   const FunctionPointers* fcn = kAdapter->get(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;
   return fcn->RemoveSRM();
 }
 
-extern "C"
+extern "C" OEMCryptoResult OEMCrypto_CreateUsageTableHeader(
-OEMCryptoResult OEMCrypto_CreateUsageTableHeader(uint8_t* header_buffer,
+    uint8_t* header_buffer, size_t* header_buffer_length) {
-                                                 size_t* header_buffer_length) {
   return OEMCrypto_CreateUsageTableHeader(kLevelDefault, header_buffer,
                                           header_buffer_length);
 }
 
-extern "C"
+extern "C" OEMCryptoResult OEMCrypto_LoadUsageTableHeader(
-OEMCryptoResult OEMCrypto_LoadUsageTableHeader(const uint8_t* buffer,
+    const uint8_t* buffer, size_t buffer_length) {
-                                               size_t buffer_length) {
   return OEMCrypto_LoadUsageTableHeader(kLevelDefault, buffer, buffer_length);
 }
 
-extern "C"
+extern "C" OEMCryptoResult OEMCrypto_CreateNewUsageEntry(
-OEMCryptoResult OEMCrypto_CreateNewUsageEntry(OEMCrypto_SESSION session,
+    OEMCrypto_SESSION session, uint32_t* usage_entry_number) {
-                                              uint32_t *usage_entry_number) {
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   LevelSession pair = kAdapter->get(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (pair.fcn->version < 13) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
+  if (pair.fcn->CreateNewUsageEntry == NULL)
+    return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return pair.fcn->CreateNewUsageEntry(pair.session, usage_entry_number);
 }
 
-extern "C"
+extern "C" OEMCryptoResult OEMCrypto_LoadUsageEntry(OEMCrypto_SESSION session,
-OEMCryptoResult OEMCrypto_LoadUsageEntry(OEMCrypto_SESSION session,
                                                     uint32_t index,
-                                         const uint8_t *buffer,
+                                                    const uint8_t* buffer,
                                                     size_t buffer_size) {
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   LevelSession pair = kAdapter->get(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;
   return pair.fcn->LoadUsageEntry(pair.session, index, buffer, buffer_size);
 }
 
-extern "C"
+extern "C" OEMCryptoResult OEMCrypto_UpdateUsageEntry(
-OEMCryptoResult OEMCrypto_UpdateUsageEntry(OEMCrypto_SESSION session,
+    OEMCrypto_SESSION session, uint8_t* header_buffer,
-                                           uint8_t* header_buffer,
+    size_t* header_buffer_length, uint8_t* entry_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 (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (pair.fcn->version < 13) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
+  if (pair.fcn->UpdateUsageEntry == NULL)
+    return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return pair.fcn->UpdateUsageEntry(pair.session, header_buffer,
                                     header_buffer_length, entry_buffer,
                                     entry_buffer_length);
 }
 
-extern "C"
+extern "C" OEMCryptoResult OEMCrypto_ShrinkUsageTableHeader(
-OEMCryptoResult OEMCrypto_ShrinkUsageTableHeader(uint32_t new_table_size,
+    uint32_t new_table_size, uint8_t* header_buffer,
-                                                 uint8_t* header_buffer,
     size_t* header_buffer_length) {
+  if (OEMCrypto_ShrinkUsageTableHeader == NULL)
+    return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return OEMCrypto_ShrinkUsageTableHeader(kLevelDefault, new_table_size,
                                           header_buffer, header_buffer_length);
 }
 
-extern "C"
+extern "C" OEMCryptoResult OEMCrypto_MoveEntry(OEMCrypto_SESSION session,
-OEMCryptoResult OEMCrypto_MoveEntry(OEMCrypto_SESSION session,
                                                uint32_t new_index) {
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   LevelSession pair = kAdapter->get(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;
   return pair.fcn->MoveEntry(pair.session, new_index);
 }
 
-extern "C"
+extern "C" OEMCryptoResult OEMCrypto_CopyOldUsageEntry(
-OEMCryptoResult OEMCrypto_CopyOldUsageEntry(OEMCrypto_SESSION session,
+    OEMCrypto_SESSION session, const uint8_t* pst, size_t pst_length) {
-                                            const uint8_t*pst,
-                                            size_t pst_length) {
   if (!kAdapter) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
   LevelSession pair = kAdapter->get(session);
   if (!pair.fcn) return OEMCrypto_ERROR_INVALID_SESSION;
   if (pair.fcn->version < 13) return OEMCrypto_ERROR_NOT_IMPLEMENTED;
+  if (pair.fcn->CopyOldUsageEntry == NULL)
+    return OEMCrypto_ERROR_NOT_IMPLEMENTED;
   return pair.fcn->CopyOldUsageEntry(pair.session, pst, pst_length);
 }
 

libwvdrmengine/level3/arm64/Android.mk

@@ -0,0 +1,11 @@
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+LOCAL_MODULE := libwvlevel3
+LOCAL_MODULE_CLASS := STATIC_LIBRARIES
+LOCAL_MODULE_SUFFIX := .a
+LOCAL_SRC_FILES := $(LOCAL_MODULE)$(LOCAL_MODULE_SUFFIX)
+LOCAL_PROPRIETARY_MODULE := true
+LOCAL_MODULE_TAGS := optional
+LOCAL_MODULE_OWNER := widevine
+LOCAL_MODULE_TARGET_ARCH := arm64
+include $(BUILD_PREBUILT)

libwvdrmengine/level3/mips/Android.mk

@@ -1,5 +1,4 @@
 LOCAL_PATH:= $(call my-dir)
-
 include $(CLEAR_VARS)
 LOCAL_MODULE := libwvlevel3
 LOCAL_MODULE_CLASS := STATIC_LIBRARIES

libwvdrmengine/level3/mips64/Android.mk

@@ -0,0 +1,11 @@
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+LOCAL_MODULE := libwvlevel3
+LOCAL_MODULE_CLASS := STATIC_LIBRARIES
+LOCAL_MODULE_SUFFIX := .a
+LOCAL_SRC_FILES := $(LOCAL_MODULE)$(LOCAL_MODULE_SUFFIX)
+LOCAL_PROPRIETARY_MODULE := true
+LOCAL_MODULE_TAGS := optional
+LOCAL_MODULE_OWNER := widevine
+LOCAL_MODULE_TARGET_ARCH := mips64
+include $(BUILD_PREBUILT)

libwvdrmengine/level3/x86_64/Android.mk

@@ -0,0 +1,11 @@
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+LOCAL_MODULE := libwvlevel3
+LOCAL_MODULE_CLASS := STATIC_LIBRARIES
+LOCAL_MODULE_SUFFIX := .a
+LOCAL_SRC_FILES := $(LOCAL_MODULE)$(LOCAL_MODULE_SUFFIX)
+LOCAL_PROPRIETARY_MODULE := true
+LOCAL_MODULE_TAGS := optional
+LOCAL_MODULE_OWNER := widevine
+LOCAL_MODULE_TARGET_ARCH := x86_64
+include $(BUILD_PREBUILT)

libwvdrmengine/oemcrypto/include/OEMCryptoCENC.h

@@ -370,7 +370,7 @@ typedef enum OEMCrypto_ProvisioningMethod {
 #define OEMCrypto_GetHDCPCapability        _oecc44
 #define OEMCrypto_LoadTestRSAKey           _oecc45
 #define OEMCrypto_Security_Patch_Level     _oecc46
-#define OEMCrypto_LoadKeys_V12             _oecc47
+#define OEMCrypto_LoadKeys_V11_or_V12      _oecc47
 #define OEMCrypto_DecryptCENC              _oecc48
 #define OEMCrypto_GetProvisioningMethod    _oecc49
 #define OEMCrypto_GetOEMPublicCertificate  _oecc50