Merge Changes from CDM repository

This CL merges the following changes from the Widevine repository: Avoid CdmSession reinitialization https://widevine-internal-review.googlesource.com/#/c/10530/ Fix timer-related unit tests. https://widevine-internal-review.googlesource.com/#/c/10510/ Correct return statement bug: 15590802 https://widevine-internal-review.googlesource.com/#/c/10553/ Usage reporting fixes bug/15388863 https://widevine-internal-review.googlesource.com/#/c/10460/ Make public methods virtual https://widevine-internal-review.googlesource.com/#/c/10500/ Fix the SetTimer contract in the CDM. https://widevine-internal-review.googlesource.com/#/c/10493/ Move inline CDM methods, add OVERRIDE. https://widevine-internal-review.googlesource.com/#/c/10475/ Simplify storage APIs related cleanup. https://widevine-internal-review.googlesource.com/#/c/10473/ Duration values are not correctly reported when queried b/15592374 https://widevine-internal-review.googlesource.com/#/c/10437/ Propagate IsKeyValid() through ContentDecryptionModule. https://widevine-internal-review.googlesource.com/#/c/10483/ Minor clean up in config_test_env. https://widevine-internal-review.googlesource.com/#/c/10440/ General clean up. https://widevine-internal-review.googlesource.com/#/c/10441/ Refactor HttpSocket and simplify UrlRequest interface. https://widevine-internal-review.googlesource.com/#/c/10410/ Install good keybox at end of unit tests b/15385981 https://widevine-internal-review.googlesource.com/#/c/10374/ Privacy crypto fixes b/15475012 https://widevine-internal-review.googlesource.com/#/c/10383/ Incorporate header files to resolve build issued based on customers feedback. https://widevine-internal-review.googlesource.com/#/c/10420/ Support unprovisioning b/12247651 https://widevine-internal-review.googlesource.com/#/c/10356/ Correct usage of Host::Allocate and Cdm::Decrypt. https://widevine-internal-review.googlesource.com/#/c/10378/ Fix logging bug, arguments in wrong order. https://widevine-internal-review.googlesource.com/#/c/10380/ Rename types that look like constants. https://widevine-internal-review.googlesource.com/#/c/10379/ Fix offline test failures b/13909635 https://widevine-internal-review.googlesource.com/#/c/10348/ Add -DUNIT_TEST to the unit test makefile for Android https://widevine-internal-review.googlesource.com/#/c/10375/ Refactor privacy-crypto and add dummy version. https://widevine-internal-review.googlesource.com/#/c/10353/ Remove References to Apiary https://widevine-internal-review.googlesource.com/#/c/9924/ Delete oldest entry in usage table when full bug: 15184824 https://widevine-internal-review.googlesource.com/#/c/10295/ Port DeviceFiles to iOS. https://widevine-internal-review.googlesource.com/#/c/10355/ Make testing functions in DeviceFiles private. https://widevine-internal-review.googlesource.com/#/c/10354/ Add RSA encryption to haystack https://widevine-internal-review.googlesource.com/#/c/10280/ Add string and vector includes to CDM header. https://widevine-internal-review.googlesource.com/#/c/10352/ First version of oemcrypto logging https://widevine-internal-review.googlesource.com/#/c/10252/ Update Names of Secure Stop Methods bug: 11987015 https://widevine-internal-review.googlesource.com/#/c/10152/ Adjust timing on the Usage Table unit test https://widevine-internal-review.googlesource.com/#/c/10307/ Fix all compiler warnings in CDM source release. https://widevine-internal-review.googlesource.com/#/c/10293/ Fix memset bug: args in wrong order https://widevine-internal-review.googlesource.com/#/c/10292/ Partial revert of 'Remove refs to test prov server, Level3 support...' https://widevine-internal-review.googlesource.com/#/c/10281/ Pack structure OEMCrypto_PST_Report https://widevine-internal-review.googlesource.com/#/c/10243/ Remove refs to test prov server, Level3 support; remove dead code https://widevine-internal-review.googlesource.com/#/c/10220/ Partial revert of 'Document data strings; clean up license server parameters.' https://widevine-internal-review.googlesource.com/#/c/10188/ Document data strings; clean up license server parameters. https://widevine-internal-review.googlesource.com/#/c/10120/ Fix broken build after partner branch merge. https://widevine-internal-review.googlesource.com/#/c/10181/ TODO Cleanup - core/src, core/include https://widevine-internal-review.googlesource.com/#/c/9965/ TODO Cleanup - cdm, chromium, core/test. https://widevine-internal-review.googlesource.com/#/c/9419/ Remove unneeded properties. https://widevine-internal-review.googlesource.com/#/c/10162/ Change-Id: If2bb9d743a562a3875bebb91933c0aaadea286b2
2014-06-25 13:02:54 -07:00
parent 8a8feb747c
commit b5e8b87fed
66 changed files with 2927 additions and 1998 deletions
--- a/libwvdrmengine/oemcrypto/mock/src/oemcrypto_mock.cpp
+++ b/libwvdrmengine/oemcrypto/mock/src/oemcrypto_mock.cpp
@@ -9,23 +9,23 @@
 #include <stdio.h>
 #include <time.h>
 #include <string>
+#include <vector>
 #include "log.h"
 #include "oemcrypto_engine_mock.h"
+#include "oemcrypto_logging.h"
 #include "oemcrypto_usage_table_mock.h"
 #include "openssl/cmac.h"
 #include "openssl/evp.h"
 #include "openssl/hmac.h"
 #include "openssl/rand.h"
 #include "openssl/sha.h"
+#include "string_conversions.h"
 #include "wv_cdm_constants.h"

 namespace wvoec_mock {

 static CryptoEngine* crypto_engine = NULL;

-// Set this to true when you are generating test vectors.
-const bool trace_all_calls = false;
-
 typedef struct {
  uint8_t signature[wvcdm::MAC_KEY_SIZE];
  uint8_t context[wvcdm::MAC_KEY_SIZE];
@@ -33,39 +33,10 @@ typedef struct {
  uint8_t enc_rsa_key[];
 } WrappedRSAKey;

-static void dump_hex(std::string name, const uint8_t* vector, size_t length) {
-  printf("%s = ", name.c_str());
-  if (vector == NULL) {
-    printf("NULL;\n");
-    return;
-  }
-  for (size_t i = 0; i < length; i++) {
-    if (i == 0) {
-      printf("\n     wvcdm::a2b_hex(\"");
-    } else if (i % 32 == 0) {
-      printf("\"\n                  \"");
-    }
-    printf("%02X", vector[i]);
-  }
-  printf("\");\n");
-}
-
-void dump_array_part(std::string array, size_t index,
-                     std::string name, const uint8_t* vector, size_t length) {
-  if (vector == NULL) {
-    printf("%s[%zu].%s = NULL;\n", array.c_str(), index, name.c_str());
-    return;
-  }
-  printf("std::string s%zu_", index);
-  dump_hex(name, vector, length);
-  printf("%s[%zu].%s =  message_ptr + message.find(s%zu_%s.data());\n",
-         array.c_str(), index, name.c_str(), index, name.c_str());
-}
-
 extern "C"
 OEMCryptoResult OEMCrypto_Initialize(void) {
-  if (trace_all_calls) {
-    printf("-------------------------  OEMCrypto_Initialize(void)\n");
+  if (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {
+    LOGI("-------------------------  OEMCrypto_Initialize(void)\n");
  }

  crypto_engine = new CryptoEngine;
@@ -74,14 +45,16 @@ OEMCryptoResult OEMCrypto_Initialize(void) {
    LOGE("[OEMCrypto_Initialize(): failed]");
    return OEMCrypto_ERROR_INIT_FAILED;
  }
-  LOGD("[OEMCrypto_Initialize(): success]");
+  if (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {
+    LOGD("[OEMCrypto_Initialize(): success]");
+  }
  return OEMCrypto_SUCCESS;
 }

 extern "C"
 OEMCryptoResult OEMCrypto_Terminate(void) {
-  if (trace_all_calls) {
-    printf("----------------- OEMCryptoResult OEMCrypto_Terminate(void)\n");
+  if (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {
+    LOGI("----------------- OEMCryptoResult OEMCrypto_Terminate(void)\n");
  }

  if (!crypto_engine) {
@@ -95,31 +68,41 @@ OEMCryptoResult OEMCrypto_Terminate(void) {

  delete crypto_engine;
  crypto_engine = NULL;
-  LOGD("[OEMCrypto_Terminate(): success]");
+  if (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {
+    LOGD("[OEMCrypto_Terminate(): success]");
+  }
  return OEMCrypto_SUCCESS;
 }

 extern "C"
 OEMCryptoResult OEMCrypto_OpenSession(OEMCrypto_SESSION* session) {
-  if (trace_all_calls) {
-    printf("-- OEMCryptoResult OEMCrypto_OpenSession(OEMCrypto_SESSION *session)\n");
+  if (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {
+    LOGI("-- OEMCryptoResult OEMCrypto_OpenSession"
+         "(OEMCrypto_SESSION *session)\n");
  }
  SessionId sid = crypto_engine->CreateSession();
  *session = (OEMCrypto_SESSION)sid;
-  LOGD("[OEMCrypto_OpenSession(): SID=%08x]", sid);
+  if (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {
+    LOGD("[OEMCrypto_OpenSession(): SID=%08x]", sid);
+  }
  return OEMCrypto_SUCCESS;
 }

 extern "C"
 OEMCryptoResult OEMCrypto_CloseSession(OEMCrypto_SESSION session) {
-  if (trace_all_calls) {
-    printf("-- OEMCryptoResult OEMCrypto_CloseSession(OEMCrypto_SESSION session)\n");
+  if (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {
+    LOGI("-- OEMCryptoResult OEMCrypto_CloseSession"
+         "(OEMCrypto_SESSION session)\n");
  }
  if (!crypto_engine->DestroySession((SessionId)session)) {
-    LOGD("[OEMCrypto_CloseSession(SID=%08X): failed]", session);
+    if (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {
+      LOGD("[OEMCrypto_CloseSession(SID=%08X): failed]", session);
+    }
    return OEMCrypto_ERROR_CLOSE_SESSION_FAILED;
  } else {
-    LOGD("[OEMCrypto_CloseSession(SID=%08X): success]", session);
+    if (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {
+      LOGD("[OEMCrypto_CloseSession(SID=%08X): success]", session);
+    }
    return OEMCrypto_SUCCESS;
  }
 }
@@ -127,8 +110,9 @@ OEMCryptoResult OEMCrypto_CloseSession(OEMCrypto_SESSION session) {
 extern "C"
 OEMCryptoResult OEMCrypto_GenerateNonce(OEMCrypto_SESSION session,
                                        uint32_t* nonce) {
-  if (trace_all_calls) {
-    printf("-- OEMCryptoResult OEMCrypto_GenerateNonce(OEMCrypto_SESSION session,\n");
+  if (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {
+    LOGI("-- OEMCryptoResult OEMCrypto_GenerateNonce"
+         "(OEMCrypto_SESSION session,\n");
  }
  SessionContext* session_ctx = crypto_engine->FindSession(session);
  if (!session_ctx || !session_ctx->isValid()) {
@@ -161,8 +145,8 @@ OEMCryptoResult OEMCrypto_GenerateNonce(OEMCrypto_SESSION session,
  }
  session_ctx->AddNonce(nonce_value);
  *nonce = nonce_value;
-  if (trace_all_calls) {
-    printf("nonce = %08x\n", nonce_value);
+  if (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {
+    LOGI("nonce = %08x\n", nonce_value);
  }
  return OEMCrypto_SUCCESS;
 }
@@ -173,12 +157,14 @@ OEMCryptoResult OEMCrypto_GenerateDerivedKeys(OEMCrypto_SESSION session,
                                              uint32_t mac_key_context_length,
                                              const uint8_t* enc_key_context,
                                              uint32_t enc_key_context_length) {
-  if (trace_all_calls) {
-    printf("-- OEMCryptoResult OEMCrypto_GenerateDerivedKeys(\n");
-    dump_hex("mac_key_context", mac_key_context,
-             (size_t)mac_key_context_length);
-    dump_hex("enc_key_context", enc_key_context,
-             (size_t)enc_key_context_length);
+  if (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {
+    LOGI("-- OEMCryptoResult OEMCrypto_GenerateDerivedKeys(\n");
+    if (wvcdm::g_cutoff >= wvcdm::LOG_VERBOSE) {
+      dump_hex("mac_key_context", mac_key_context,
+               (size_t)mac_key_context_length);
+      dump_hex("enc_key_context", enc_key_context,
+               (size_t)enc_key_context_length);
+    }
  }
  if (NO_ERROR != crypto_engine->ValidateKeybox()) {
    LOGE("[OEMCrypto_GenerateDerivedKeys(): ERROR_KEYBOX_INVALID]");
@@ -201,13 +187,15 @@ OEMCryptoResult OEMCrypto_GenerateDerivedKeys(OEMCrypto_SESSION session,
                               mac_ctx_str, enc_ctx_str)) {
    return OEMCrypto_ERROR_UNKNOWN_FAILURE;
  }
-  if (trace_all_calls) {
-    dump_hex("mac_key_server", &session_ctx->mac_key_server()[0],
-             session_ctx->mac_key_server().size());
-    dump_hex("mac_key_client", &session_ctx->mac_key_client()[0],
-             session_ctx->mac_key_client().size());
-    dump_hex("enc_key", &session_ctx->encryption_key()[0],
-             session_ctx->encryption_key().size());
+  if (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {
+    if (wvcdm::g_cutoff >= wvcdm::LOG_VERBOSE) {
+      dump_hex("mac_key_server", &session_ctx->mac_key_server()[0],
+               session_ctx->mac_key_server().size());
+      dump_hex("mac_key_client", &session_ctx->mac_key_client()[0],
+               session_ctx->mac_key_client().size());
+      dump_hex("enc_key", &session_ctx->encryption_key()[0],
+               session_ctx->encryption_key().size());
+    }
  }
  return OEMCrypto_SUCCESS;
 }
@@ -219,9 +207,11 @@ OEMCryptoResult OEMCrypto_GenerateSignature(
                            size_t message_length,
                            uint8_t* signature,
                            size_t* signature_length) {
-  if (trace_all_calls) {
-    printf("-- OEMCryptoResult OEMCrypto_GenerateSignature(\n");
-    dump_hex("message", message, message_length);
+  if (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {
+    LOGI("-- OEMCryptoResult OEMCrypto_GenerateSignature(\n");
+    if (wvcdm::g_cutoff >= wvcdm::LOG_VERBOSE) {
+      dump_hex("message", message, message_length);
+    }
  }

  if (NO_ERROR != crypto_engine->ValidateKeybox()) {
@@ -250,8 +240,10 @@ OEMCryptoResult OEMCrypto_GenerateSignature(
                                     message_length,
                                     signature,
                                     signature_length)) {
-    if (trace_all_calls) {
-      dump_hex("signature", signature, *signature_length);
+    if (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {
+      if (wvcdm::g_cutoff >= wvcdm::LOG_VERBOSE) {
+        dump_hex("signature", signature, *signature_length);
+      }
    }
    return OEMCrypto_SUCCESS;
  }
@@ -281,29 +273,33 @@ OEMCryptoResult OEMCrypto_LoadKeys(OEMCrypto_SESSION session,
                                   const OEMCrypto_KeyObject* key_array,
                                   const uint8_t* pst,
                                   size_t pst_length) {
-  if (trace_all_calls) {
-    printf("-- OEMCryptoResult OEMCrypto_LoadKeys(OEMCrypto_SESSION session,\n");
-    dump_hex("message", message, message_length);
-    dump_hex("signature", signature, signature_length);
-    dump_hex("enc_mac_key_iv", enc_mac_key_iv, wvcdm::KEY_IV_SIZE);
-    dump_hex("enc_mac_keys", enc_mac_keys, 2*wvcdm::MAC_KEY_SIZE);
-    dump_hex("pst", pst, pst_length);
-    for (size_t i = 0; i < num_keys; i++) {
-      printf("key_array[%zu].key_id_length=%zu;\n", i,
-             key_array[i].key_id_length);
-      dump_array_part("key_array", i, "key_id",
-                      key_array[i].key_id, key_array[i].key_id_length);
-      dump_array_part("key_array", i, "key_data_iv",
-                      key_array[i].key_data_iv, wvcdm::KEY_IV_SIZE);
-      dump_array_part("key_array", i, "key_data",
-                      key_array[i].key_data, key_array[i].key_data_length);
-      dump_array_part("key_array", i, "key_control_iv",
-                      key_array[i].key_control_iv, wvcdm::KEY_IV_SIZE);
-      dump_array_part("key_array", i, "key_control",
-                      key_array[i].key_control, wvcdm::KEY_IV_SIZE);
+  if (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {
+    LOGI("-- OEMCryptoResult OEMCrypto_LoadKeys(OEMCrypto_SESSION session,\n");
+    if (wvcdm::g_cutoff >= wvcdm::LOG_VERBOSE) {
+      dump_hex("message", message, message_length);
+      dump_hex("signature", signature, signature_length);
+      dump_hex("enc_mac_key_iv", enc_mac_key_iv, wvcdm::KEY_IV_SIZE);
+      dump_hex("enc_mac_keys", enc_mac_keys, 2*wvcdm::MAC_KEY_SIZE);
+      dump_hex("pst", pst, pst_length);
+      for (size_t i = 0; i < num_keys; i++) {
+        LOGV("key_array[%zu].key_id_length=%zu;\n", i,
+               key_array[i].key_id_length);
+        dump_array_part("key_array", i, "key_id",
+                        key_array[i].key_id, key_array[i].key_id_length);
+        dump_array_part("key_array", i, "key_data_iv",
+                        key_array[i].key_data_iv, wvcdm::KEY_IV_SIZE);
+        dump_array_part("key_array", i, "key_data",
+                        key_array[i].key_data, key_array[i].key_data_length);
+        dump_array_part("key_array", i, "key_control_iv",
+                        key_array[i].key_control_iv, wvcdm::KEY_IV_SIZE);
+        dump_array_part("key_array", i, "key_control",
+                        key_array[i].key_control, wvcdm::KEY_IV_SIZE);
+      }
    }
  }

+
+
  if (NO_ERROR != crypto_engine->ValidateKeybox()) {
    LOGE("[OEMCrypto_LoadKeys(): ERROR_KEYBOX_INVALID]");
    return OEMCrypto_ERROR_KEYBOX_INVALID;
@@ -354,15 +350,16 @@ OEMCryptoResult OEMCrypto_LoadKeys(OEMCrypto_SESSION session,
 }

 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 (trace_all_calls) {
-    printf("-- OEMCryptoResult OEMCrypto_RefreshKeys(num_keys=%zu)\n",
+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 (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {
+    LOGI("-- OEMCryptoResult OEMCrypto_RefreshKeys(num_keys=%zu)\n",
           num_keys);
  }

@@ -415,7 +412,7 @@ OEMCryptoResult OEMCrypto_RefreshKeys(OEMCrypto_SESSION session,
                    key_array[i].key_id + key_array[i].key_id_length);
      key_control.assign(key_array[i].key_control,
                         key_array[i].key_control + wvcdm::KEY_CONTROL_SIZE);
-      if (key_array[i].key_control_iv == NULL ) {
+      if ( key_array[i].key_control_iv == NULL ) {
        key_control_iv.clear();
      } else {
        key_control_iv.assign(key_array[i].key_control_iv,
@@ -448,9 +445,12 @@ extern "C"
 OEMCryptoResult OEMCrypto_SelectKey(const OEMCrypto_SESSION session,
                                    const uint8_t* key_id,
                                    size_t key_id_length) {
-  if (trace_all_calls) {
-    printf("-- OEMCryptoResult OEMCrypto_SelectKey(const OEMCrypto_SESSION session,\n");
-    dump_hex("key_id", key_id, key_id_length);
+  if (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {
+    LOGI("-- OEMCryptoResult OEMCrypto_SelectKey"
+         "(const OEMCrypto_SESSION session,\n");
+    if (wvcdm::g_cutoff >= wvcdm::LOG_VERBOSE) {
+      dump_hex("key_id", key_id, key_id_length);
+    }
  }
 #ifndef NDEBUG
  if (NO_ERROR != crypto_engine->ValidateKeybox()) {
@@ -484,8 +484,9 @@ OEMCryptoResult OEMCrypto_DecryptCTR(OEMCrypto_SESSION session,
                                     size_t block_offset,
                                     const OEMCrypto_DestBufferDesc* out_buffer,
                                     uint8_t subsample_flags) {
-  if (trace_all_calls) {
-    printf("-- OEMCryptoResult OEMCrypto_DecryptCTR(OEMCrypto_SESSION session,\n");
+  if (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {
+    LOGI("-- OEMCryptoResult OEMCrypto_DecryptCTR"
+         "(OEMCrypto_SESSION session,\n");
  }
  wvoec_mock::BufferType buffer_type = kBufferTypeDirect;
  uint8_t* destination = NULL;
@@ -541,8 +542,8 @@ OEMCryptoResult OEMCrypto_DecryptCTR(OEMCrypto_SESSION session,
 extern "C"
 OEMCryptoResult OEMCrypto_InstallKeybox(const uint8_t* keybox,
                                        size_t keyBoxLength) {
-  if (trace_all_calls) {
-    printf("-- OEMCryptoResult OEMCrypto_InstallKeybox(const uint8_t *keybox,\n");
+  if (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {
+    LOGI("-- OEMCryptoResult OEMCrypto_InstallKeybox(const uint8_t *keybox,\n");
  }
  if (crypto_engine->keybox().InstallKeybox(keybox, keyBoxLength)) {
    return OEMCrypto_SUCCESS;
@@ -552,8 +553,8 @@ OEMCryptoResult OEMCrypto_InstallKeybox(const uint8_t* keybox,

 extern "C"
 OEMCryptoResult OEMCrypto_IsKeyboxValid(void) {
-  if (trace_all_calls) {
-    printf("-- OEMCryptoResult OEMCrypto_IsKeyboxValid(void) {\n");
+  if (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {
+    LOGI("-- OEMCryptoResult OEMCrypto_IsKeyboxValid(void) {\n");
  }
  switch(crypto_engine->ValidateKeybox()) {
    case NO_ERROR:    return OEMCrypto_SUCCESS;
@@ -567,8 +568,8 @@ OEMCryptoResult OEMCrypto_IsKeyboxValid(void) {
 extern "C"
 OEMCryptoResult OEMCrypto_GetDeviceID(uint8_t* deviceID,
                                      size_t* idLength) {
-  if (trace_all_calls) {
-    printf("-- OEMCryptoResult OEMCrypto_GetDeviceID(uint8_t* deviceID,\n");
+  if (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {
+    LOGI("-- OEMCryptoResult OEMCrypto_GetDeviceID(uint8_t* deviceID,\n");
  }
  std::vector<uint8_t> dev_id_string = crypto_engine->keybox().device_id();
  if (dev_id_string.empty()) {
@@ -585,15 +586,17 @@ OEMCryptoResult OEMCrypto_GetDeviceID(uint8_t* deviceID,
  memset(deviceID, 0, *idLength);
  memcpy(deviceID, &dev_id_string[0], dev_id_len);
  *idLength = dev_id_len;
-  LOGD("[OEMCrypto_GetDeviceId(): success]");
+  if (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {
+    LOGD("[OEMCrypto_GetDeviceId(): success]");
+  }
  return OEMCrypto_SUCCESS;
 }

 extern "C"
 OEMCryptoResult OEMCrypto_GetKeyData(uint8_t* keyData,
                                     size_t* keyDataLength) {
-  if (trace_all_calls) {
-    printf("-- OEMCryptoResult OEMCrypto_GetKeyData(uint8_t* keyData,\n");
+  if (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {
+    LOGI("-- OEMCryptoResult OEMCrypto_GetKeyData(uint8_t* keyData,\n");
  }
  size_t length = crypto_engine->keybox().key_data_length();
  if (*keyDataLength < length) {
@@ -604,14 +607,17 @@ OEMCryptoResult OEMCrypto_GetKeyData(uint8_t* keyData,
  memset(keyData, 0, *keyDataLength);
  memcpy(keyData, crypto_engine->keybox().key_data(), length);
  *keyDataLength = length;
-  LOGD("[OEMCrypto_GetKeyData(): success]");
+  if (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {
+    LOGD("[OEMCrypto_GetKeyData(): success]");
+  }
  return OEMCrypto_SUCCESS;
 }

 extern "C"
 OEMCryptoResult OEMCrypto_GetRandom(uint8_t* randomData, size_t dataLength) {
-  if (trace_all_calls) {
-    printf("-- OEMCryptoResult OEMCrypto_GetRandom(uint8_t* randomData, size_t dataLength) {\n");
+  if (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {
+    LOGI("-- OEMCryptoResult OEMCrypto_GetRandom"
+         "(uint8_t* randomData, size_t dataLength) {\n");
  }
  if (!randomData) {
    return OEMCrypto_ERROR_UNKNOWN_FAILURE;
@@ -629,8 +635,8 @@ OEMCryptoResult OEMCrypto_WrapKeybox(const uint8_t* keybox,
                                     size_t* wrappedKeyBoxLength,
                                     const uint8_t* transportKey,
                                     size_t transportKeyLength) {
-  if (trace_all_calls) {
-    printf("-- OEMCryptoResult OEMCrypto_WrapKeybox(const uint8_t *keybox,\n");
+  if (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {
+    LOGI("-- OEMCryptoResult OEMCrypto_WrapKeybox(const uint8_t *keybox,\n");
  }
  if (!keybox || !wrappedKeybox || !wrappedKeyBoxLength
      || (keyBoxLength != *wrappedKeyBoxLength)) {
@@ -654,13 +660,17 @@ OEMCryptoResult OEMCrypto_RewrapDeviceRSAKey(OEMCrypto_SESSION session,
                                             const uint8_t* enc_rsa_key_iv,
                                             uint8_t* wrapped_rsa_key,
                                             size_t*  wrapped_rsa_key_length) {
-  if (trace_all_calls) {
-    printf("-- OEMCryptoResult OEMCrypto_RewrapDeviceRSAKey()\n");
-    dump_hex("message", message, message_length);
-    dump_hex("signature", signature, signature_length);
-    printf("nonce = %08X;\n", *nonce);
-    dump_hex("enc_rsa_key", enc_rsa_key, enc_rsa_key_length);
-    dump_hex("enc_rsa_key_iv", enc_rsa_key_iv, wvcdm::KEY_IV_SIZE);
+  if (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls | kLoggingTraceNonce)) {
+    LOGI("-- OEMCryptoResult OEMCrypto_RewrapDeviceRSAKey()\n");
+    if (wvcdm::g_cutoff >= wvcdm::LOG_VERBOSE) {
+      dump_hex("message", message, message_length);
+      dump_hex("signature", signature, signature_length);
+    }
+    LOGI("nonce = %08X;\n", *nonce);
+    if (wvcdm::g_cutoff >= wvcdm::LOG_VERBOSE) {
+      dump_hex("enc_rsa_key", enc_rsa_key, enc_rsa_key_length);
+      dump_hex("enc_rsa_key_iv", enc_rsa_key_iv, wvcdm::KEY_IV_SIZE);
+    }
  }
  if (wrapped_rsa_key_length == NULL) {
    LOGE("[OEMCrypto_RewrapDeviceRSAKey(): OEMCrypto_ERROR_INVALID_CONTEXT]");
@@ -673,7 +683,9 @@ OEMCryptoResult OEMCrypto_RewrapDeviceRSAKey(OEMCrypto_SESSION session,
  size_t buffer_size = enc_rsa_key_length + sizeof(WrappedRSAKey);

  if (wrapped_rsa_key == NULL || *wrapped_rsa_key_length < buffer_size) {
-    LOGW("[OEMCrypto_RewrapDeviceRSAKey(): Wrapped Keybox Short Buffer]");
+    if (LogCategoryEnabled(kLoggingDumpDerivedKeys)) {
+      LOGW("[OEMCrypto_RewrapDeviceRSAKey(): Wrapped Keybox Short Buffer]");
+    }
    *wrapped_rsa_key_length = buffer_size;
    return OEMCrypto_ERROR_SHORT_BUFFER;
  }
@@ -777,11 +789,13 @@ OEMCryptoResult OEMCrypto_RewrapDeviceRSAKey(OEMCrypto_SESSION session,
      result = OEMCrypto_ERROR_UNKNOWN_FAILURE;
    }
  }
-  if (trace_all_calls) {
-    dump_hex("wrapped_rsa_key", wrapped_rsa_key, *wrapped_rsa_key_length);
-    dump_hex("signature", wrapped->signature, sizeof(wrapped->signature));
-    dump_hex("context", wrapped->context, sizeof(wrapped->context));
-    dump_hex("iv", wrapped->iv, sizeof(wrapped->iv));
+  if (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {
+    if (wvcdm::g_cutoff >= wvcdm::LOG_VERBOSE) {
+      dump_hex("wrapped_rsa_key", wrapped_rsa_key, *wrapped_rsa_key_length);
+      dump_hex("signature", wrapped->signature, sizeof(wrapped->signature));
+      dump_hex("context", wrapped->context, sizeof(wrapped->context));
+      dump_hex("iv", wrapped->iv, sizeof(wrapped->iv));
+    }
  }
  return result;
 }
@@ -796,12 +810,14 @@ OEMCryptoResult OEMCrypto_LoadDeviceRSAKey(OEMCrypto_SESSION session,
  }
  const WrappedRSAKey* wrapped
    = reinterpret_cast<const WrappedRSAKey*>(wrapped_rsa_key);
-  if (trace_all_calls) {
-    printf("-- OEMCryptoResult OEMCrypto_LoadDeviceRSAKey()\n");
-    dump_hex("wrapped_rsa_key", wrapped_rsa_key, wrapped_rsa_key_length);
-    dump_hex("signature", wrapped->signature, sizeof(wrapped->signature));
-    dump_hex("context", wrapped->context, sizeof(wrapped->context));
-    dump_hex("iv", wrapped->iv, sizeof(wrapped->iv));
+  if (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {
+    LOGI("-- OEMCryptoResult OEMCrypto_LoadDeviceRSAKey()\n");
+    if (wvcdm::g_cutoff >= wvcdm::LOG_VERBOSE) {
+      dump_hex("wrapped_rsa_key", wrapped_rsa_key, wrapped_rsa_key_length);
+      dump_hex("signature", wrapped->signature, sizeof(wrapped->signature));
+      dump_hex("context", wrapped->context, sizeof(wrapped->context));
+      dump_hex("iv", wrapped->iv, sizeof(wrapped->iv));
+    }
  }
  if (NO_ERROR != crypto_engine->ValidateKeybox()) {
    LOGE("[OEMCrypto_LoadDeviceRSAKey(): ERROR_KEYBOX_INVALID]");
@@ -852,15 +868,19 @@ OEMCryptoResult OEMCrypto_LoadDeviceRSAKey(OEMCrypto_SESSION session,
 }

 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 (trace_all_calls) {
-    printf("-- OEMCryptoResult OEMCrypto_GenerateRSASignature()\n");
-    dump_hex("message", message, message_length);
+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 (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {
+    LOGI("-- OEMCryptoResult OEMCrypto_GenerateRSASignature()\n");
+    if (wvcdm::g_cutoff >= wvcdm::LOG_VERBOSE) {
+      dump_hex("message", message, message_length);
+      dump_hex("message", message, message_length);
+    }
  }
  if (NO_ERROR != crypto_engine->ValidateKeybox()) {
    LOGE("[OEMCrypto_GenerateRSASignature(): ERROR_KEYBOX_INVALID]");
@@ -895,8 +915,10 @@ OEMCryptoResult OEMCrypto_GenerateRSASignature(OEMCrypto_SESSION session,
                                        signature,
                                        signature_length,
                                        padding_scheme)) {
-    if (trace_all_calls) {
-      dump_hex("signature", signature, *signature_length);
+    if (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {
+      if (wvcdm::g_cutoff >= wvcdm::LOG_VERBOSE) {
+        dump_hex("signature", signature, *signature_length);
+      }
    }
    return OEMCrypto_SUCCESS;
  }
@@ -912,13 +934,15 @@ OEMCryptoResult OEMCrypto_DeriveKeysFromSessionKey(
    size_t mac_key_context_length,
    const uint8_t* enc_key_context,
    size_t enc_key_context_length) {
-  if (trace_all_calls) {
-    printf("-- OEMCryptoResult OEMCrypto_DeriveKeysFromSessionKey(\n");
-    dump_hex("enc_session_key", enc_session_key, enc_session_key_length);
-    dump_hex("mac_key_context", mac_key_context,
-             (size_t)mac_key_context_length);
-    dump_hex("enc_key_context", enc_key_context,
-             (size_t)enc_key_context_length);
+  if (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {
+    LOGI("-- OEMCryptoResult OEMCrypto_DeriveKeysFromSessionKey(\n");
+    if (wvcdm::g_cutoff >= wvcdm::LOG_VERBOSE) {
+      dump_hex("enc_session_key", enc_session_key, enc_session_key_length);
+      dump_hex("mac_key_context", mac_key_context,
+               (size_t)mac_key_context_length);
+      dump_hex("enc_key_context", enc_key_context,
+               (size_t)enc_key_context_length);
+    }
  }
  if (NO_ERROR != crypto_engine->ValidateKeybox()) {
    LOGE("[OEMCrypto_GenerateDerivedKeys(): ERROR_KEYBOX_INVALID]");
@@ -947,13 +971,15 @@ OEMCryptoResult OEMCrypto_DeriveKeysFromSessionKey(
  if (!session_ctx->RSADeriveKeys(ssn_key_str, mac_ctx_str, enc_ctx_str)) {
    return OEMCrypto_ERROR_UNKNOWN_FAILURE;
  }
-  if (trace_all_calls) {
-    dump_hex("mac_key_server", &session_ctx->mac_key_server()[0],
-             session_ctx->mac_key_server().size());
-    dump_hex("mac_key", &session_ctx->mac_key_client()[0],
-             session_ctx->mac_key_client().size());
-    dump_hex("enc_key", &session_ctx->encryption_key()[0],
-             session_ctx->encryption_key().size());
+  if (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {
+    if (wvcdm::g_cutoff >= wvcdm::LOG_VERBOSE) {
+      dump_hex("mac_key_server", &session_ctx->mac_key_server()[0],
+               session_ctx->mac_key_server().size());
+      dump_hex("mac_key", &session_ctx->mac_key_client()[0],
+               session_ctx->mac_key_client().size());
+      dump_hex("enc_key", &session_ctx->encryption_key()[0],
+               session_ctx->encryption_key().size());
+    }
  }
  return OEMCrypto_SUCCESS;
 }
@@ -969,10 +995,11 @@ const char* OEMCrypto_SecurityLevel() {
 }

 extern "C"
-OEMCryptoResult OEMCrypto_GetHDCPCapability(OEMCrypto_HDCP_Capability *current,
-                                            OEMCrypto_HDCP_Capability *maximum) {
-  if (trace_all_calls) {
-    printf("-- OEMCryptoResult OEMCrypto_GetHDCPCapability(%p, %p)\n",
+OEMCryptoResult OEMCrypto_GetHDCPCapability(
+    OEMCrypto_HDCP_Capability *current,
+    OEMCrypto_HDCP_Capability *maximum) {
+  if (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {
+    LOGI("-- OEMCryptoResult OEMCrypto_GetHDCPCapability(%p, %p)\n",
           current, maximum);
  }
  if (current == NULL) return OEMCrypto_ERROR_UNKNOWN_FAILURE;
@@ -989,12 +1016,13 @@ OEMCryptoResult OEMCrypto_Generic_Encrypt(OEMCrypto_SESSION session,
                                          const uint8_t* iv,
                                          OEMCrypto_Algorithm algorithm,
                                          uint8_t* out_buffer) {
-
-  if (trace_all_calls) {
-    printf("-- OEMCryptoResult OEMCrypto_Generic_Encrypt( algorithm=%d\n",
+  if (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {
+    LOGI("-- OEMCryptoResult OEMCrypto_Generic_Encrypt( algorithm=%d\n",
           algorithm);
-    dump_hex("in_buffer", in_buffer, buffer_length);
-    dump_hex("iv", iv, wvcdm::KEY_IV_SIZE);
+    if (wvcdm::g_cutoff >= wvcdm::LOG_VERBOSE) {
+      dump_hex("in_buffer", in_buffer, buffer_length);
+      dump_hex("iv", iv, wvcdm::KEY_IV_SIZE);
+    }
  }
  if (NO_ERROR != crypto_engine->ValidateKeybox()) {
    LOGE("[OEMCrypto_Generic_Enrypt(): ERROR_KEYBOX_INVALID]");
@@ -1013,8 +1041,10 @@ OEMCryptoResult OEMCrypto_Generic_Encrypt(OEMCrypto_SESSION session,
  OEMCryptoResult sts =
      session_ctx->Generic_Encrypt(in_buffer, buffer_length, iv, algorithm,
                                   out_buffer);
-  if (trace_all_calls) {
-    dump_hex("out_buffer", out_buffer, buffer_length);
+  if (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {
+    if (wvcdm::g_cutoff >= wvcdm::LOG_VERBOSE) {
+      dump_hex("out_buffer", out_buffer, buffer_length);
+    }
  }
  return sts;
 }
@@ -1026,11 +1056,13 @@ OEMCryptoResult OEMCrypto_Generic_Decrypt(OEMCrypto_SESSION session,
                                          const uint8_t* iv,
                                          OEMCrypto_Algorithm algorithm,
                                          uint8_t* out_buffer) {
-  if (trace_all_calls) {
-    printf("-- OEMCryptoResult OEMCrypto_Generic_Decrypt( algorithm=%d\n",
+  if (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {
+    LOGI("-- OEMCryptoResult OEMCrypto_Generic_Decrypt( algorithm=%d\n",
           algorithm);
-    dump_hex("in_buffer", in_buffer, buffer_length);
-    dump_hex("iv", iv, wvcdm::KEY_IV_SIZE);
+    if (wvcdm::g_cutoff >= wvcdm::LOG_VERBOSE) {
+      dump_hex("in_buffer", in_buffer, buffer_length);
+      dump_hex("iv", iv, wvcdm::KEY_IV_SIZE);
+    }
  }
  if (NO_ERROR != crypto_engine->ValidateKeybox()) {
    LOGE("[OEMCrypto_Generic_Decrypt(): ERROR_KEYBOX_INVALID]");
@@ -1049,8 +1081,10 @@ OEMCryptoResult OEMCrypto_Generic_Decrypt(OEMCrypto_SESSION session,
  OEMCryptoResult sts =
      session_ctx->Generic_Decrypt(in_buffer, buffer_length, iv, algorithm,
                                   out_buffer);
-  if (trace_all_calls) {
-    dump_hex("out_buffer", out_buffer, buffer_length);
+  if (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {
+    if (wvcdm::g_cutoff >= wvcdm::LOG_VERBOSE){
+      dump_hex("out_buffer", out_buffer, buffer_length);
+    }
  }
  return sts;
 }
@@ -1062,10 +1096,12 @@ OEMCryptoResult OEMCrypto_Generic_Sign(OEMCrypto_SESSION session,
                                       OEMCrypto_Algorithm algorithm,
                                       uint8_t* signature,
                                       size_t* signature_length) {
-  if (trace_all_calls) {
-    printf("-- OEMCryptoResult OEMCrypto_Generic_Sign( algorithm=%d\n",
+  if (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {
+    LOGI("-- OEMCryptoResult OEMCrypto_Generic_Sign( algorithm=%d\n",
           algorithm);
-    dump_hex("in_buffer", in_buffer, buffer_length);
+    if (wvcdm::g_cutoff >= wvcdm::LOG_VERBOSE) {
+      dump_hex("in_buffer", in_buffer, buffer_length);
+    }
  }
  if (NO_ERROR != crypto_engine->ValidateKeybox()) {
    LOGE("[OEMCrypto_Generic_Sign(): ERROR_KEYBOX_INVALID]");
@@ -1087,8 +1123,10 @@ OEMCryptoResult OEMCrypto_Generic_Sign(OEMCrypto_SESSION session,
  OEMCryptoResult sts =
      session_ctx->Generic_Sign(in_buffer, buffer_length, algorithm,
                                signature, signature_length);
-  if (trace_all_calls) {
-    dump_hex("signature", signature, *signature_length);
+  if (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {
+    if (wvcdm::g_cutoff >= wvcdm::LOG_VERBOSE) {
+      dump_hex("signature", signature, *signature_length);
+    }
  }
  return sts;
 }
@@ -1100,11 +1138,13 @@ OEMCryptoResult OEMCrypto_Generic_Verify(OEMCrypto_SESSION session,
                                         OEMCrypto_Algorithm algorithm,
                                         const uint8_t* signature,
                                         size_t signature_length) {
-  if (trace_all_calls) {
-    printf("-- OEMCryptoResult OEMCrypto_Generic_Verify( algorithm=%d\n",
+  if (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {
+    LOGI("-- OEMCryptoResult OEMCrypto_Generic_Verify( algorithm=%d\n",
           algorithm);
-    dump_hex("in_buffer", in_buffer, buffer_length);
-    dump_hex("signature", signature, signature_length);
+    if (wvcdm::g_cutoff >= wvcdm::LOG_VERBOSE) {
+      dump_hex("in_buffer", in_buffer, buffer_length);
+      dump_hex("signature", signature, signature_length);
+    }
  }
  if (NO_ERROR != crypto_engine->ValidateKeybox()) {
    LOGE("[OEMCrypto_Generic_Verify(): ERROR_KEYBOX_INVALID]");
@@ -1128,15 +1168,15 @@ OEMCryptoResult OEMCrypto_Generic_Verify(OEMCrypto_SESSION session,

 extern "C"
 bool OEMCrypto_SupportsUsageTable() {
-  if (trace_all_calls) {
-    printf("-- bool OEMCrypto_SupportsUsageTable(); // returns true.\n");
+  if (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {
+    LOGI("-- bool OEMCrypto_SupportsUsageTable(); // returns true.\n");
  }
  return true;
 }
 extern "C"
 OEMCryptoResult OEMCrypto_UpdateUsageTable() {
-  if (trace_all_calls) {
-    printf("-- OEMCryptoResult OEMCrypto_UpdateUsageTable();\n");
+  if (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {
+    LOGI("-- OEMCryptoResult OEMCrypto_UpdateUsageTable();\n");
  }
  return crypto_engine->usage_table()->UpdateTable();
 }
@@ -1144,9 +1184,11 @@ OEMCryptoResult OEMCrypto_UpdateUsageTable() {
 extern "C"
 OEMCryptoResult OEMCrypto_DeactivateUsageEntry(const uint8_t *pst,
                                               size_t pst_length) {
-  if (trace_all_calls) {
-    printf("-- OEMCryptoResult OEMCrypto_DeactivateUsageEntry(\n");
-    dump_hex("pst", pst, pst_length);
+  if (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {
+    LOGI("-- OEMCryptoResult OEMCrypto_DeactivateUsageEntry(\n");
+    if (wvcdm::g_cutoff >= wvcdm::LOG_VERBOSE) {
+      dump_hex("pst", pst, pst_length);
+    }
  }
  std::vector<uint8_t> pstv(pst, pst + pst_length);
  return crypto_engine->usage_table()->DeactivateEntry(pstv);
@@ -1158,9 +1200,11 @@ OEMCryptoResult OEMCrypto_ReportUsage(OEMCrypto_SESSION session,
                                      size_t pst_length,
                                      OEMCrypto_PST_Report *buffer,
                                      size_t *buffer_length) {
-  if (trace_all_calls) {
-    printf("-- OEMCryptoResult OEMCrypto_ReportUsage(\n");
-    dump_hex("pst", pst, pst_length);
+  if (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {
+    LOGI("-- OEMCryptoResult OEMCrypto_ReportUsage(\n");
+    if (wvcdm::g_cutoff >= wvcdm::LOG_VERBOSE) {
+      dump_hex("pst", pst, pst_length);
+    }
  }
  SessionContext* session_ctx = crypto_engine->FindSession(session);
  if (!session_ctx || !session_ctx->isValid()) {
@@ -1176,9 +1220,11 @@ OEMCryptoResult OEMCrypto_ReportUsage(OEMCrypto_SESSION session,
  OEMCryptoResult sts =
      entry->ReportUsage(session_ctx, pstv, buffer, buffer_length);
  crypto_engine->usage_table()->UpdateTable();
-  if (trace_all_calls) {
-    dump_hex("usage buffer", reinterpret_cast<uint8_t*>(buffer),
-             *buffer_length);
+  if (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {
+    if (wvcdm::g_cutoff >= wvcdm::LOG_VERBOSE) {
+      dump_hex("usage buffer", reinterpret_cast<uint8_t*>(buffer),
+               *buffer_length);
+    }
  }
  return sts;
 }
@@ -1191,11 +1237,13 @@ OEMCryptoResult OEMCrypto_DeleteUsageEntry(OEMCrypto_SESSION session,
                                           size_t message_length,
                                           const uint8_t *signature,
                                           size_t signature_length) {
-  if (trace_all_calls) {
-    printf("-- OEMCryptoResult OEMCrypto_DeleteUsageEntry(\n");
-    dump_hex("pst", pst, pst_length);
-    dump_hex("message", message, message_length);
-    dump_hex("signature", signature, signature_length);
+  if (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {
+    LOGI("-- OEMCryptoResult OEMCrypto_DeleteUsageEntry(\n");
+    if (wvcdm::g_cutoff >= wvcdm::LOG_VERBOSE) {
+      dump_hex("pst", pst, pst_length);
+      dump_hex("message", message, message_length);
+      dump_hex("signature", signature, signature_length);
+    }
  }
  SessionContext* session_ctx = crypto_engine->FindSession(session);
  if (!session_ctx || !session_ctx->isValid()) {
@@ -1226,8 +1274,8 @@ OEMCryptoResult OEMCrypto_DeleteUsageEntry(OEMCrypto_SESSION session,

 extern "C"
 OEMCryptoResult OEMCrypto_DeleteUsageTable() {
-  if (trace_all_calls) {
-    printf("-- OEMCryptoResult OEMCrypto_DeleteUsageTable()\n");
+  if (LogCategoryEnabled(kLoggingTraceOEMCryptoCalls)) {
+    LOGI("-- OEMCryptoResult OEMCrypto_DeleteUsageTable()\n");
  }
  if (crypto_engine->usage_table()->Clear()) {
    return OEMCrypto_SUCCESS;