Widevine CENC drm engine update

bug: 8601053

This import syncs to the widevine git repository change
commit 6a99ad1b59ad39495f62954b3065ddc22b78da49

It includes the following changes from the widevine git
repository, which complete the jb-mr2 features

    Fix Unit Test Makefile
    Adds support for device certificate provisioning.
    Support application parameters
    Certificate based licensing
    Proto for client files
    Implement Property Query API
    Add Device Query For Unique ID
    Implement Generic Crypto in DrmEngine
    Do not validate Key IDs on clear playback
    Allow OEMCrypto_DecryptCTR with clear content and no key
    Add a case to the MediaDrm API test to repro b/8594163
    Implement requiresSecureDecoderComponent
    Implement Eventing API
    Add end-to-end decryption test with vectors
    Refactoring of properties class
    Refactor OEMCrypto unittest.
    Fix for b/8567853: License renewal doesn't renew license.
    Add KEY_ERROR callback to WvContentDecryptionModule() ctor.
    Merged certificate_provisioning.proto and
      client_identification.proto to license_protocol.proto.
    Fix nonce check failure after a malformed key in OEC Mock.
    asynchronize decryption
    Allow querying of control information
    make debugging AddKey & Decrypt statuses easier
    Revert "Revert "Send KEY_ERROR event to app on license
      expiration or failure""
    Revert "Send KEY_ERROR event to app on license expiration
      or failure"
    Send KEY_ERROR event to app on license expiration or failure
    remove extra session id copy
    use KeyError constants directly
    replace variable-length arrays with std::vector and fixed-sized array
    pass session ids as const references
    refactor key extraction and update keys on renewal
    Updates to enable renewals and signaling license expiration.
    fix error constant in OEMCrypto_DecryptCTR

Change-Id: I5f7236c7bdff1d5ece6115fd2893f8a1e1e07c50

libwvdrmengine/cdm/core/src/cdm_session.cpp

@@ -4,6 +4,7 @@
 #include "cdm_session.h"
 
 #include <iostream>
+#include <sstream>
 
 #include "clock.h"
 #include "crypto_engine.h"
@@ -16,31 +17,32 @@ namespace wvcdm {
 
 typedef std::set<WvCdmEventListener*>::iterator CdmEventListenerIter;
 
-bool CdmSession::Init() {
+CdmResponseType CdmSession::Init() {
   CryptoEngine* crypto_engine = CryptoEngine::GetInstance();
   if (!crypto_engine) {
     LOGE("CdmSession::Init failed to get CryptoEngine instance.");
-    return false;
+    return UNKNOWN_ERROR;
   }
 
   crypto_session_ = crypto_engine->CreateSession(session_id_);
   if (!crypto_session_) {
-    return false;
+    return UNKNOWN_ERROR;
   }
 
   std::string token;
-  if (!crypto_engine->GetToken(&token)) return false;
-
-  if (!Properties::GetInstance()->GetProperty(
-      kPropertyKeyRequireExplicitRenewRequest,
-      require_explicit_renew_request_)) {
-    LOGE("CdmSession::Init: Unable to access property - require explicit renew");
+  if (Properties::use_certificates_as_identification()) {
+    if (!LoadDeviceCertificate(&token, &wrapped_key_))
+      return NEED_PROVISIONING;
   }
   else {
-    properties_valid_ = true;
+    if (!crypto_engine->GetToken(&token))
+      return UNKNOWN_ERROR;
   }
 
-  return license_parser_.Init(token, crypto_session_, &policy_engine_);
+  if (license_parser_.Init(token, crypto_session_, &policy_engine_))
+    return NO_ERROR;
+  else
+    return UNKNOWN_ERROR;
 }
 
 bool CdmSession::DestroySession() {
@@ -58,13 +60,11 @@ bool CdmSession::VerifySession(const CdmKeySystem& key_system,
   return true;
 }
 
-CdmResponseType CdmSession::GenerateKeyRequest(const CdmInitData& init_data,
-                                               CdmKeyMessage* key_request) {
-  if (!properties_valid_) {
-    LOGW("CdmSession::GenerateKeyRequest: Unable to access properties");
-    return UNKNOWN_ERROR;
-  }
-
+CdmResponseType CdmSession::GenerateKeyRequest(
+    const CdmInitData& pssh_data,
+    const CdmLicenseType license_type,
+    CdmAppParameterMap& app_parameters,
+    CdmKeyMessage* key_request) {
   if (!crypto_session_) {
     LOGW("CdmSession::GenerateKeyRequest: Invalid crypto session");
     return UNKNOWN_ERROR;
@@ -76,11 +76,19 @@ CdmResponseType CdmSession::GenerateKeyRequest(const CdmInitData& init_data,
   }
 
   if (license_received_) {
-    return require_explicit_renew_request_ ?
+    return Properties::require_explicit_renew_request() ?
         UNKNOWN_ERROR : GenerateRenewalRequest(key_request);
   }
   else {
-    if(!license_parser_.PrepareKeyRequest(init_data, key_request)) {
+    if (Properties::use_certificates_as_identification()) {
+      if (!crypto_session_->LoadCertificatePrivateKey(wrapped_key_))
+        return NEED_PROVISIONING;
+    }
+
+    if (!license_parser_.PrepareKeyRequest(pssh_data,
+                                           license_type,
+                                           app_parameters,
+                                           key_request)) {
       return KEY_ERROR;
     } else {
       return KEY_MESSAGE;
@@ -101,16 +109,16 @@ CdmResponseType CdmSession::AddKey(const CdmKeyResponse& key_response) {
   }
 
   if (license_received_) {
-    return require_explicit_renew_request_ ?
+    return Properties::require_explicit_renew_request() ?
         UNKNOWN_ERROR : RenewKey(key_response);
   }
   else {
-    if (!license_parser_.HandleKeyResponse(key_response)) {
-      return KEY_ERROR;
-    } else {
+    CdmResponseType sts = license_parser_.HandleKeyResponse(key_response);
+
+    if (sts == KEY_ADDED)
       license_received_ = true;
-      return KEY_ADDED;
-    }
+
+    return sts;
   }
 }
 
@@ -118,6 +126,16 @@ CdmResponseType CdmSession::QueryKeyStatus(CdmQueryMap* key_info) {
   return policy_engine_.Query(key_info);
 }
 
+CdmResponseType CdmSession::QueryKeyControlInfo(CdmQueryMap* key_info) {
+  if ((!crypto_session_) || (!crypto_session_->IsOpen()))
+    return UNKNOWN_ERROR;
+
+  std::stringstream ss;
+  ss << crypto_session_->oec_session_id();
+  (*key_info)[QUERY_KEY_OEMCRYPTO_SESSION_ID] = ss.str();
+  return NO_ERROR;
+}
+
 // CancelKeyRequest() - Cancel session.
 CdmResponseType CdmSession::CancelKeyRequest() {
   // TODO(gmorgan): cancel and clean up session
@@ -144,12 +162,12 @@ CdmResponseType CdmSession::Decrypt(bool is_encrypted,
         key_id_ = key_id;
       }
       else {
-        return UNKNOWN_ERROR;
+        return NEED_KEY;
       }
     }
   }
 
-  return crypto_session_->Decrypt(is_encrypted, encrypt_buffer, encrypt_length, 
+  return crypto_session_->Decrypt(is_encrypted, encrypt_buffer, encrypt_length,
                                   iv, block_offset, decrypt_buffer, is_video);
 }
 
@@ -157,7 +175,7 @@ CdmResponseType CdmSession::Decrypt(bool is_encrypted,
 // GenerateRenewalRequest() - Construct valid renewal request for the current
 // session keys.
 CdmResponseType CdmSession::GenerateRenewalRequest(CdmKeyMessage* key_request) {
-  if(!license_parser_.PrepareKeyRenewalRequest(key_request)) {
+  if (!license_parser_.PrepareKeyRenewalRequest(key_request)) {
     return KEY_ERROR;
   } else {
     return KEY_MESSAGE;
@@ -166,11 +184,7 @@ CdmResponseType CdmSession::GenerateRenewalRequest(CdmKeyMessage* key_request) {
 
 // RenewKey() - Accept renewal response and update key info.
 CdmResponseType CdmSession::RenewKey(const CdmKeyResponse& key_response) {
-  if (!license_parser_.HandleKeyRenewalResponse(key_response)) {
-    return KEY_ERROR;
-  } else {
-    return KEY_ADDED;
-  }
+  return license_parser_.HandleKeyRenewalResponse(key_response);
 }
 
 bool CdmSession::IsKeyValid(const KeyId& key_id) {
@@ -187,6 +201,12 @@ CdmSessionId CdmSession::GenerateSessionId() {
   return kSessionPrefix + IntToString(++session_num);
 }
 
+bool CdmSession::LoadDeviceCertificate(std::string* certificate,
+                                       std::string* wrapped_key) {
+  // TODO(edwingwong,rfrias): Need to read in the private key
+  return false;
+}
+
 bool CdmSession::AttachEventListener(WvCdmEventListener* listener) {
   std::pair<CdmEventListenerIter, bool> result = listeners_.insert(listener);
   return result.second;