Widevine CENC drm engine update: enable decryption

This import syncs to the widevine git repostiory change
commit ab3e1e43642cf36900f55169597a33f222709fdb

Change-Id: I3a6f1e2969e5fe7ed1ca12f90b0eb0a3b7899835

libwvdrmengine/cdm/core/src/cdm_session.cpp

@@ -5,10 +5,11 @@
 
 #include <iostream>
 
+#include "clock.h"
 #include "crypto_engine.h"
 #include "log.h"
+#include "properties.h"
 #include "string_conversions.h"
-#include "clock.h"
 #include "wv_cdm_constants.h"
 
 namespace wvcdm {
@@ -30,6 +31,15 @@ bool CdmSession::Init() {
   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");
+  }
+  else {
+    properties_valid_ = true;
+  }
+
   return license_parser_.Init(token, crypto_session_, &policy_engine_);
 }
 
@@ -50,20 +60,57 @@ bool CdmSession::VerifySession(const CdmKeySystem& key_system,
 
 CdmResponseType CdmSession::GenerateKeyRequest(const CdmInitData& init_data,
                                                CdmKeyMessage* key_request) {
-  crypto_session_->Open();
-  if(!license_parser_.PrepareKeyRequest(init_data, key_request)) {
-    return KEY_ERROR;
-  } else {
-    return KEY_MESSAGE;
+  if (!properties_valid_) {
+    LOGW("CdmSession::GenerateKeyRequest: Unable to access properties");
+    return UNKNOWN_ERROR;
+  }
+
+  if (!crypto_session_) {
+    LOGW("CdmSession::GenerateKeyRequest: Invalid crypto session");
+    return UNKNOWN_ERROR;
+  }
+
+  if (!crypto_session_->IsOpen()) {
+    LOGW("CdmSession::GenerateKeyRequest: Crypto session not open");
+    return UNKNOWN_ERROR;
+  }
+
+  if (license_received_) {
+    return require_explicit_renew_request_ ?
+        UNKNOWN_ERROR : GenerateRenewalRequest(key_request);
+  }
+  else {
+    if(!license_parser_.PrepareKeyRequest(init_data, key_request)) {
+      return KEY_ERROR;
+    } else {
+      return KEY_MESSAGE;
+    }
   }
 }
 
 // AddKey() - Accept license response and extract key info.
 CdmResponseType CdmSession::AddKey(const CdmKeyResponse& key_response) {
-  if (!license_parser_.HandleKeyResponse(key_response)) {
-    return KEY_ERROR;
-  } else {
-    return KEY_ADDED;
+  if (!crypto_session_) {
+    LOGW("CdmSession::AddKey: Invalid crypto session");
+    return UNKNOWN_ERROR;
+  }
+
+  if (!crypto_session_->IsOpen()) {
+    LOGW("CdmSession::AddKey: Crypto session not open");
+    return UNKNOWN_ERROR;
+  }
+
+  if (license_received_) {
+    return require_explicit_renew_request_ ?
+        UNKNOWN_ERROR : RenewKey(key_response);
+  }
+  else {
+    if (!license_parser_.HandleKeyResponse(key_response)) {
+      return KEY_ERROR;
+    } else {
+      license_received_ = true;
+      return KEY_ADDED;
+    }
   }
 }
 
@@ -79,23 +126,29 @@ CdmResponseType CdmSession::CancelKeyRequest() {
 }
 
 // Decrypt() - Accept encrypted buffer and return decrypted data.
-CdmResponseType CdmSession::Decrypt(const uint8_t* encrypted_buffer,
-                                    size_t encrypted_size,
-                                    size_t block_offset,
-                                    const std::vector<uint8_t>& iv,
+CdmResponseType CdmSession::Decrypt(bool is_encrypted,
                                     const KeyId& key_id,
-                                    uint8_t* decrypted_buffer) {
-  if (!crypto_session_)
+                                    const uint8_t* encrypt_buffer,
+                                    size_t encrypt_length,
+                                    const std::vector<uint8_t>& iv,
+                                    size_t block_offset,
+                                    void* decrypt_buffer,
+                                    bool is_video) {
+  if (!crypto_session_ || !crypto_session_->IsOpen())
     return UNKNOWN_ERROR;
 
-  if (!crypto_session_->SelectKey(key_id))
-    return UNKNOWN_ERROR;
+  // Check if key needs to be selected
+  if (key_id_.compare(key_id) != 0) {
+    if (crypto_session_->SelectKey(key_id)) {
+      key_id_ = key_id;
+    }
+    else {
+      return UNKNOWN_ERROR;
+    }
+  }
 
-  if (!crypto_session_->Decrypt(encrypted_buffer, encrypted_size,
-                                block_offset, iv, decrypted_buffer))
-    return UNKNOWN_ERROR;
-
-  return NO_ERROR;
+  return crypto_session_->Decrypt(is_encrypted, encrypt_buffer, encrypt_length, 
+                                  iv, block_offset, decrypt_buffer, is_video);
 }
 
 // License renewal