Merge changes I442b7919,Ie5b4ff75

* changes:
  Improve android MediaDrm property latency
  Delay OEMCrypto Termination

libwvdrmengine/cdm/core/include/crypto_session.h

@@ -44,11 +44,11 @@ class CryptoSessionFactory;
 class CryptoSession {
  public:
   using HdcpCapability = OEMCrypto_HDCP_Capability;
-  typedef enum {
+  enum UsageDurationStatus {
     kUsageDurationsInvalid = 0,
     kUsageDurationPlaybackNotBegun = 1,
     kUsageDurationsValid = 2,
-  } UsageDurationStatus;
+  };
 
   struct SupportedCertificateTypes {
     bool rsa_2048_bit;
@@ -64,6 +64,17 @@ class CryptoSession {
 
   virtual ~CryptoSession();
 
+  // This method will try to terminate OEMCrypto if |session_size_| is 0.
+  // A platform configured property |delay_oem_crypto_termination| will
+  // determine if termination occurs immediately or after a delay.
+  // If termination is delayed, a countdown mechanism is employed.
+  // Call |TryTerminate| periodically until it no longer returns true.
+  // To immediately terminate call |DisableDelayedTermination| before calling
+  // |TryTerminate|.
+  static bool TryTerminate();
+
+  static void DisableDelayedTermination();
+
   virtual CdmResponseType GetProvisioningToken(std::string* client_token);
   virtual CdmClientTokenType GetPreProvisionTokenType() {
     return pre_provision_token_type_;
@@ -282,7 +293,6 @@ class CryptoSession {
   }
 
   void Init();
-  void Terminate();
   CdmResponseType GetTokenFromKeybox(std::string* token);
   CdmResponseType GetTokenFromOemCert(std::string* token);
   static bool ExtractSystemIdFromOemCert(const std::string& oem_cert,
@@ -385,6 +395,7 @@ class CryptoSession {
 
   static bool initialized_;
   static int session_count_;
+  static int termination_counter_;
 
   metrics::CryptoMetrics* metrics_;
   metrics::TimerMetric life_span_;

libwvdrmengine/cdm/core/include/properties.h

@@ -61,6 +61,9 @@ class Properties {
   static void set_provisioning_messages_are_binary(bool flag) {
     provisioning_messages_are_binary_ = flag;
   }
+  static inline bool delay_oem_crypto_termination() {
+    return delay_oem_crypto_termination_;
+  }
   static bool GetCompanyName(std::string* company_name);
   static bool GetModelName(std::string* model_name);
   static bool GetArchitectureName(std::string* arch_name);
@@ -147,6 +150,7 @@ class Properties {
   static bool allow_service_certificate_requests_;
   static bool device_files_is_a_real_filesystem_;
   static bool allow_restore_of_offline_licenses_with_release_;
+  static bool delay_oem_crypto_termination_;
   static std::unique_ptr<CdmClientPropertySetMap> session_property_set_;
 
   CORE_DISALLOW_COPY_AND_ASSIGN(Properties);

libwvdrmengine/cdm/core/src/crypto_session.cpp

@@ -60,6 +60,7 @@ const size_t kOemCryptoApiVersionSupportsSwitchingCipherMode = 14;
 
 // Constants and utility objects relating to OEM Certificates
 const char* const kWidevineSystemIdExtensionOid = "1.3.6.1.4.1.11129.4.1.1";
+constexpr int kMaxTerminateCountDown = 5;
 
 const std::string kStringNotAvailable = "NA";
 
@@ -96,6 +97,7 @@ shared_mutex CryptoSession::static_field_mutex_;
 shared_mutex CryptoSession::oem_crypto_mutex_;
 bool CryptoSession::initialized_ = false;
 int CryptoSession::session_count_ = 0;
+int CryptoSession::termination_counter_ = 0;
 UsageTableHeader* CryptoSession::usage_table_header_l1_ = nullptr;
 UsageTableHeader* CryptoSession::usage_table_header_l3_ = nullptr;
 std::atomic<uint64_t> CryptoSession::request_id_index_source_(0);
@@ -189,7 +191,15 @@ CryptoSession::~CryptoSession() {
   if (open_) {
     Close();
   }
-  Terminate();
+  WithStaticFieldWriteLock("~CryptoSession", [&] {
+    if (session_count_ > 0) {
+      --session_count_;
+    } else {
+      LOGE("Invalid crypto session count: session_count_ = %d", session_count_);
+    }
+  });
+
+  TryTerminate();
   M_RECORD(metrics_, crypto_session_life_span_, life_span_.AsMs());
 }
 
@@ -244,6 +254,9 @@ void CryptoSession::Init() {
         LOGE("OEMCrypto_Initialize failed: status = %d", static_cast<int>(sts));
         return;
       }
+      termination_counter_ = Properties::delay_oem_crypto_termination()
+                                 ? kMaxTerminateCountDown
+                                 : 0;
       initialized_ = true;
       initialized = true;
     }
@@ -273,17 +286,20 @@ void CryptoSession::Init() {
   }
 }
 
-void CryptoSession::Terminate() {
+bool CryptoSession::TryTerminate() {
   LOGV("Terminating crypto session");
-  WithStaticFieldWriteLock("Terminate", [&] {
-    LOGV("Terminating crypto session: initialized_ = %s, session_count_ = %d",
-         initialized_ ? "true" : "false", session_count_);
-    if (session_count_ > 0) {
-      session_count_ -= 1;
-    } else {
-      LOGE("Invalid crypto session count: session_count_ = %d", session_count_);
+  WithStaticFieldWriteLock("TryTerminate", [&] {
+    LOGV(
+        "Terminating crypto session: initialized_ = %s, session_count_ = %d, "
+        "termination_counter_ = %d",
+        initialized_ ? "true" : "false", session_count_, termination_counter_);
+
+    if (termination_counter_ > 0) {
+      --termination_counter_;
     }
-    if (session_count_ > 0 || !initialized_) return;
+    if (session_count_ > 0 || termination_counter_ > 0 || !initialized_)
+      return false;
+
     OEMCryptoResult sts;
     WithOecWriteLock("Terminate", [&] { sts = OEMCrypto_Terminate(); });
     if (OEMCrypto_SUCCESS != sts) {
@@ -300,7 +316,15 @@ void CryptoSession::Terminate() {
     }
 
     initialized_ = false;
+    return true;
   });
+  return true;
+}
+
+void CryptoSession::DisableDelayedTermination() {
+  LOGV("Disable delayed termination");
+  WithStaticFieldWriteLock("DisableDelayedTermination",
+                           [&] { termination_counter_ = 0; });
 }
 
 CdmResponseType CryptoSession::GetTokenFromKeybox(std::string* token) {
@@ -687,6 +711,11 @@ CdmResponseType CryptoSession::Open(SecurityLevel requested_security_level) {
     return MapOEMCryptoResult(sts, OPEN_CRYPTO_SESSION_ERROR, "Open");
   }
 
+  WithStaticFieldWriteLock("Open() termination_counter", [&] {
+    termination_counter_ =
+        Properties::delay_oem_crypto_termination() ? kMaxTerminateCountDown : 0;
+  });
+
   oec_session_id_ = static_cast<CryptoSessionId>(sid);
   LOGV("Opened session: id = %u", oec_session_id_);
   open_ = true;

libwvdrmengine/cdm/core/src/properties.cpp

@@ -21,6 +21,7 @@ bool Properties::provisioning_messages_are_binary_;
 bool Properties::allow_service_certificate_requests_;
 bool Properties::device_files_is_a_real_filesystem_;
 bool Properties::allow_restore_of_offline_licenses_with_release_;
+bool Properties::delay_oem_crypto_termination_;
 std::unique_ptr<CdmClientPropertySetMap> Properties::session_property_set_;
 
 bool Properties::AddSessionPropertySet(const CdmSessionId& session_id,