Check for open session when initializing usage table.

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

There was an issue encountered by some vendors with how the usage
table was initialized on some devices.  Previously, the CDM would
open an OEMCrypto session first, then initialize the usage table
(loading existing or creating a new one).  On these devices,
OEMCrypto_CreateUsageTableHeader() and OEMCrypto_LoadUsageTableHeader()
would fail if there were any open sessions.

This CL changes the initialization process to create/load the usage
table before opening an OEMCrypto session.

This change also lays the ground work for another usage table fix
to address GTS tests failure.

In the process, several of the functions for the usage table have been
split up into smaller chunks of code.  This required additional changes
to the usage table unittest to keep them up to date.

Bug: 169195093
Bug: 180639135
Test: Linux unittests and MediaDrmTest
Change-Id: Ifbf35f5d8cff5b89fea9b16edb998c84803f4fbe

libwvdrmengine/cdm/core/include/crypto_session.h

@@ -293,7 +293,7 @@ class CryptoSession {
   // exist as long as the new CryptoSession exists.
   explicit CryptoSession(metrics::CryptoMetrics* crypto_metrics);
 
-  int session_count() { return session_count_; }
+  int session_count() const { return session_count_; }
 
  private:
   friend class CryptoSessionForTest;
@@ -313,6 +313,13 @@ class CryptoSession {
   }
 
   void Init();
+
+  // Will set up the UsageTableHeader for this session.  This may require
+  // creating a new UsageTableHeader if the global instance has not
+  // been initialized.
+  // Note:  This function will lock the global static field lock in write mode.
+  bool SetUpUsageTableHeader(SecurityLevel requested_security_level);
+
   CdmResponseType GetTokenFromKeybox(std::string* token);
   CdmResponseType GetTokenFromOemCert(std::string* token);
   static bool ExtractSystemIdFromOemCert(const std::string& oem_cert,
@@ -355,9 +362,15 @@ class CryptoSession {
   // These methods should be used to take the various CryptoSession mutexes in
   // preference to taking the mutexes directly.
   //
-  // A lock should be taken on the Static Field Mutex before accessing any of
-  // CryptoSession's non-atomic static fields. It can be taken as a reader or as
-  // a writer, depending on how you will be accessing the static fields.
+  // A lock should be taken on the Static Field Mutex before accessing
+  // any of CryptoSession's non-atomic static fields with the exception
+  // of the Usage Table Mutex.  The Static Field Mutex can be taken as
+  // a reader or as a writer, depending on how you will be accessing
+  // the static fields.  The Usage Table Mutex should be taken when
+  // reading and writing to the static usage table fields (creating,
+  // destroying or taking a pointer of the handles).  The purpose of
+  // having a separate mutex for usage table is due to the recursive
+  // nature of initializing the global usage table.
   //
   // Before calling into OEMCrypto, code must take locks on the OEMCrypto Mutex
   // and/or the OEMCrypto Session Mutex. Which of them should be taken and how
@@ -414,6 +427,9 @@ class CryptoSession {
   static shared_mutex static_field_mutex_;
   static shared_mutex oem_crypto_mutex_;
   std::mutex oem_crypto_session_mutex_;
+  // Usage table mutex used only when performing write operations on
+  // the static usage table pointers.
+  static std::recursive_mutex usage_table_mutex_;
 
   static bool initialized_;
   static int session_count_;
@@ -446,8 +462,10 @@ class CryptoSession {
   // Open session-cached result of OEMCrypto_SupportsUsageTable().
   CachedBooleanProperty has_usage_info_support_ = kBooleanUnset;
   UsageTableHeader* usage_table_header_ = nullptr;
-  static UsageTableHeader* usage_table_header_l1_;
-  static UsageTableHeader* usage_table_header_l3_;
+  // These fields are protected by |usage_table_mutex_| and not
+  // |static_field_mutex_|.
+  static std::unique_ptr<UsageTableHeader> usage_table_header_l1_;
+  static std::unique_ptr<UsageTableHeader> usage_table_header_l3_;
 
   std::string request_id_;
   static std::atomic<uint64_t> request_id_index_source_;