OEMCrypto v16.1

Merge of http://go/wvgerrit/93404

This CL updates the Widevine CDM to support OEMCrypto v16.1

Test: Tested in 16.2 CL
Bug: 141247171
Change-Id: I69bd993500f6fb63bf6010c8b0250dc7acc3d71b

libwvdrmengine/oemcrypto/ref/src/oemcrypto_engine_ref.cpp

@@ -7,7 +7,6 @@
 #include "oemcrypto_engine_ref.h"
 
 #include <assert.h>
-#include <chrono>
 #include <string.h>
 #include <algorithm>
 #include <iostream>
@@ -17,6 +16,7 @@
 #include <openssl/aes.h>
 #include <openssl/err.h>
 
+#include "clock.h"
 #include "keys.h"
 #include "log.h"
 #include "oemcrypto_key_ref.h"
@@ -88,23 +88,26 @@ SessionContext* CryptoEngine::FindSession(SessionId sid) {
   if (it != sessions_.end()) {
     return it->second;
   }
-  return NULL;
+  return nullptr;
 }
 
-time_t CryptoEngine::OnlineTime() {
+int64_t CryptoEngine::OnlineTime() {
   // Use the monotonic clock for times that don't have to be stable across
   // device boots.
-  std::chrono::steady_clock clock;
-  return clock.now().time_since_epoch() / std::chrono::seconds(1);
+  int64_t now = wvcdm::Clock().GetCurrentTime();
+  static int64_t then = now;
+  if (now < then) now = then;
+  then = now;
+  return now;
 }
 
-time_t CryptoEngine::RollbackCorrectedOfflineTime() {
+int64_t CryptoEngine::RollbackCorrectedOfflineTime() {
   struct TimeInfo {
     // The max time recorded through this function call.
-    time_t previous_time;
+    int64_t previous_time;
     // If the wall time is rollbacked to before the previous_time, this member
     // is updated to reflect the offset.
-    time_t rollback_offset;
+    int64_t rollback_offset;
     // Pad the struct so that TimeInfo is a multiple of 16.
     uint8_t padding[16 - (2 * sizeof(time_t)) % 16];
   };
@@ -135,7 +138,7 @@ time_t CryptoEngine::RollbackCorrectedOfflineTime() {
     if (!file) {
       LOGE("RollbackCorrectedOfflineTime: File open failed: %s",
            filename.c_str());
-      return time(NULL);
+      return OnlineTime();
     }
     file->Read(reinterpret_cast<char*>(&encrypted_buffer[0]), sizeof(TimeInfo));
     // Decrypt the encrypted TimeInfo buffer.
@@ -147,9 +150,9 @@ time_t CryptoEngine::RollbackCorrectedOfflineTime() {
     memcpy(&time_info, &clear_buffer[0], sizeof(TimeInfo));
   }
 
-  time_t current_time;
+  int64_t current_time;
   // Add any time offsets in the past to the current time.
-  current_time = time(NULL) + time_info.rollback_offset;
+  current_time = OnlineTime() + time_info.rollback_offset;
   if (time_info.previous_time > current_time) {
     // Time has been rolled back.
     // Update the rollback offset.
@@ -174,7 +177,7 @@ time_t CryptoEngine::RollbackCorrectedOfflineTime() {
   if (!file) {
     LOGE("RollbackCorrectedOfflineTime: File open failed: %s",
          filename.c_str());
-    return time(NULL);
+    return OnlineTime();
   }
   file->Write(reinterpret_cast<char*>(&encrypted_buffer[0]), sizeof(TimeInfo));
 
@@ -183,9 +186,9 @@ time_t CryptoEngine::RollbackCorrectedOfflineTime() {
 }
 
 bool CryptoEngine::NonceCollision(uint32_t nonce) {
-  for (const auto & session_pair :  sessions_) {
+  for (const auto& session_pair : sessions_) {
     const SessionContext* session = session_pair.second;
-    if (session->NonceCollision(nonce)) return true;
+    if (nonce == session->nonce()) return true;
   }
   return false;
 }
@@ -199,45 +202,45 @@ OEMCrypto_HDCP_Capability CryptoEngine::config_maximum_hdcp_capability() {
 }
 
 OEMCryptoResult CryptoEngine::SetDestination(
-    OEMCrypto_DestBufferDesc* out_description, size_t data_length,
+    const OEMCrypto_DestBufferDesc& out_description, size_t data_length,
     uint8_t subsample_flags) {
   size_t max_length = 0;
-  switch (out_description->type) {
+  switch (out_description.type) {
     case OEMCrypto_BufferType_Clear:
-      destination_ = out_description->buffer.clear.address;
-      max_length = out_description->buffer.clear.max_length;
+      destination_ = out_description.buffer.clear.address;
+      max_length = out_description.buffer.clear.address_length;
       break;
     case OEMCrypto_BufferType_Secure:
       destination_ =
-          reinterpret_cast<uint8_t*>(out_description->buffer.secure.handle) +
-          out_description->buffer.secure.offset;
-      max_length = out_description->buffer.secure.max_length -
-                   out_description->buffer.secure.offset;
+          reinterpret_cast<uint8_t*>(out_description.buffer.secure.handle) +
+          out_description.buffer.secure.offset;
+      max_length = out_description.buffer.secure.handle_length -
+                   out_description.buffer.secure.offset;
       break;
     case OEMCrypto_BufferType_Direct:
       // Direct buffer type is only used on some specialized devices where
       // oemcrypto has a direct connection to the screen buffer.  It is not,
       // for example, supported on Android.
-      destination_ = NULL;
+      destination_ = nullptr;
       break;
     default:
       return OEMCrypto_ERROR_INVALID_CONTEXT;
   }
-  size_t max_allowed = max_output_size();
+  const size_t max_allowed = max_sample_size();
   if (max_allowed > 0 &&
       (max_allowed < max_length || max_allowed < data_length)) {
     LOGE("Output too large (or buffer too small).");
     return OEMCrypto_ERROR_OUTPUT_TOO_LARGE;
   }
 
-  if (out_description->type != OEMCrypto_BufferType_Direct &&
+  if (out_description.type != OEMCrypto_BufferType_Direct &&
       max_length < data_length) {
     LOGE("[SetDestination(): OEMCrypto_ERROR_SHORT_BUFFER]");
     return OEMCrypto_ERROR_SHORT_BUFFER;
   }
   adjust_destination(out_description, data_length, subsample_flags);
-  if ((out_description->type != OEMCrypto_BufferType_Direct) &&
-      (destination_ == NULL)) {
+  if ((out_description.type != OEMCrypto_BufferType_Direct) &&
+      (destination_ == nullptr)) {
     return OEMCrypto_ERROR_INVALID_CONTEXT;
   }
   return OEMCrypto_SUCCESS;