Corrections for big usage table support in L3

[ Merge of http://go/wvgerrit/26421 ]

* Corrects usage_table_header lifetime management. Earlier the
  UsageTableHeader class was a singleton tied to the CdmEngine lifetime.
  With SPOIDs there might be multiple concurrent CdmEngine objects.
  The UsageTableHeader class is now associated with OEMCrypto
  lifetime. There are two UsageTableHeader objects one for each L1 and L3.
  These get allocated/deallocated on OEMCrypto Initialization/Termination
  respectively.
* UsageTableHeader requires OEMCrypto, file read/writes and
  metric gathering to perform its required functionality. Because of the
  lifetime changes, CryptoSession, DeviceFiles and MetricsGroup objects
  need to passed to the methods rather than at Creation time.
* Miscellaneous fixes, when moving or deleteing entries.
* Adds usage_table_header_unittests.
* Addresses failures with request_license_test with secure stop in L3.

b/36858906
b/36855557
b/36048120
b/38341136
b/37100505
b/35946047

Test: Verified by unit and integration tests. Added new
      usage_table_header_unittests

Change-Id: I20e396ab2c0afbd14372dd93b969e5b0f1ccd291

libwvdrmengine/cdm/core/src/crypto_session.cpp

@@ -17,6 +17,7 @@
 #include "properties.h"
 #include "pst_report.h"
 #include "string_conversions.h"
+#include "usage_table_header.h"
 #include "wv_cdm_constants.h"
 
 namespace {
@@ -41,6 +42,8 @@ Lock CryptoSession::crypto_lock_;
 bool CryptoSession::initialized_ = false;
 int CryptoSession::session_count_ = 0;
 uint64_t CryptoSession::request_id_index_ = 0;
+UsageTableHeader* CryptoSession::usage_table_header_l1_ = NULL;
+UsageTableHeader* CryptoSession::usage_table_header_l3_ = NULL;
 
 CryptoSession::CryptoSession(metrics::MetricsGroup* metrics)
     : metrics_(metrics),
@@ -50,6 +53,7 @@ CryptoSession::CryptoSession(metrics::MetricsGroup* metrics)
       requested_security_level_(kLevelDefault),
       is_usage_support_type_valid_(false),
       usage_support_type_(kNonSecureUsageSupport),
+      usage_table_header_(NULL),
       request_id_base_(0),
       cipher_mode_(kCipherModeCtr) {
   Init();
@@ -120,6 +124,16 @@ void CryptoSession::Terminate() {
   if (OEMCrypto_SUCCESS != sts) {
     LOGE("OEMCrypto_Terminate failed: %d", sts);
   }
+
+  if (usage_table_header_l1_ != NULL) {
+    delete usage_table_header_l1_;
+    usage_table_header_l1_ = NULL;
+  }
+  if (usage_table_header_l3_ != NULL) {
+    delete usage_table_header_l3_;
+    usage_table_header_l3_ = NULL;
+  }
+
   initialized_ = false;
 }
 
@@ -210,8 +224,7 @@ bool CryptoSession::GetProvisioningToken(std::string* token) {
 }
 
 CdmSecurityLevel CryptoSession::GetSecurityLevel() {
-  LOGV("CryptoSession::GetSecurityLevel: Lock");
-  AutoLock auto_lock(crypto_lock_);
+  LOGV("CryptoSession::GetSecurityLevel");
   if (!initialized_) {
     return kSecurityLevelUninitialized;
   }
@@ -421,7 +434,8 @@ uint8_t CryptoSession::GetSecurityPatchLevel() {
 }
 
 CdmResponseType CryptoSession::Open(SecurityLevel requested_security_level) {
-  LOGV("CryptoSession::Open: Lock");
+  LOGV("CryptoSession::Open: Lock: requested_security_level: %d",
+       requested_security_level);
   AutoLock auto_lock(crypto_lock_);
   if (!initialized_) return UNKNOWN_ERROR;
   if (open_) return NO_ERROR;
@@ -461,6 +475,35 @@ CdmResponseType CryptoSession::Open(SecurityLevel requested_security_level) {
       random_sts,
       metrics::Pow2Bucket(sizeof(request_id_base_)));
   ++request_id_index_;
+
+  CdmUsageSupportType usage_support_type;
+  if (GetUsageSupportType(&usage_support_type) == NO_ERROR) {
+    if (usage_support_type == kUsageEntrySupport) {
+      CdmSecurityLevel security_level = GetSecurityLevel();
+      if (security_level == kSecurityLevelL1 ||
+          security_level == kSecurityLevelL3) {
+        UsageTableHeader* header = security_level == kSecurityLevelL1 ?
+            usage_table_header_l1_ : usage_table_header_l3_;
+        if (header == NULL) {
+          header = new UsageTableHeader();
+          // Ignore errors since we do not know when a session is opened,
+          // if it is intended to be used for offline/usage session related
+          // or otherwise.
+          if (!header->Init(security_level, this)) {
+            delete header;
+            usage_table_header_ = NULL;
+            return NO_ERROR;
+          }
+          if (security_level == kSecurityLevelL1)
+            usage_table_header_l1_ = header;
+          else
+            usage_table_header_l3_ = header;
+        }
+        usage_table_header_ = header;
+      }
+    }
+  }
+
   return NO_ERROR;
 }
 
@@ -1085,9 +1128,7 @@ CdmResponseType CryptoSession::UpdateUsageInformation() {
   AutoLock auto_lock(crypto_lock_);
   if (!initialized_) return UNKNOWN_ERROR;
 
-  CdmUsageSupportType usage_support_type;
-  if (GetUsageSupportType(&usage_support_type) == NO_ERROR &&
-      usage_support_type == kUsageEntrySupport) {
+  if (usage_table_header_ != NULL) {
     LOGV("UpdateUsageInformation: deprecated for OEMCrypto v13+");
     return NO_ERROR;
   }
@@ -1248,6 +1289,11 @@ CdmResponseType CryptoSession::ReleaseUsageInformation(
   LOGV("ReleaseUsageInformation: id=%ld", (uint32_t)oec_session_id_);
   {
     AutoLock auto_lock(crypto_lock_);
+    if (usage_table_header_ != NULL) {
+      LOGW("ReleaseUsageInformation: deprecated for OEMCrypto v13+");
+      return NO_ERROR;
+    }
+
     const uint8_t* msg = reinterpret_cast<const uint8_t*>(message.data());
     const uint8_t* sig = reinterpret_cast<const uint8_t*>(signature.data());
     const uint8_t* pst = msg + GetOffset(message, provider_session_token);