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/cdm/util/include/string_conversions.h

@@ -36,6 +36,8 @@ CORE_UTIL_EXPORT std::string IntToString(int value);
 CORE_UTIL_EXPORT int64_t htonll64(int64_t x);
 CORE_UTIL_EXPORT inline int64_t ntohll64(int64_t x) { return htonll64(x); }
 CORE_UTIL_EXPORT std::string BytesToString(const uint8_t* bytes, unsigned size);
+// Encode unsigned integer into a big endian formatted string
+CORE_UTIL_EXPORT std::string EncodeUint32(unsigned int u);
 
 }  // namespace wvcdm
 

libwvdrmengine/cdm/util/src/string_conversions.cpp

@@ -87,10 +87,12 @@ std::string a2bs_hex(const std::string& byte) {
 }
 
 std::string b2a_hex(const std::vector<uint8_t>& byte) {
-  return HexEncode(&byte[0], byte.size());
+  if (byte.empty()) return "";
+  return HexEncode(byte.data(), byte.size());
 }
 
 std::string b2a_hex(const std::string& byte) {
+  if (byte.empty()) return "";
   return HexEncode(reinterpret_cast<const uint8_t*>(byte.data()),
                    byte.length());
 }
@@ -251,7 +253,7 @@ std::vector<uint8_t> Base64SafeDecode(const std::string& b64_input) {
 
 std::string HexEncode(const uint8_t* in_buffer, unsigned int size) {
   static const char kHexChars[] = "0123456789ABCDEF";
-
+  if (size == 0) return "";
   // Each input byte creates two output hex characters.
   std::string out_buffer(size * 2, '\0');
 
@@ -298,4 +300,14 @@ std::string BytesToString(const uint8_t* bytes, unsigned size) {
   return std::string(char_bytes, char_bytes + size);
 }
 
+// Encode unsigned integer into a big endian formatted string
+std::string EncodeUint32(unsigned int u) {
+  std::string s;
+  s.append(1, (u >> 24) & 0xFF);
+  s.append(1, (u >> 16) & 0xFF);
+  s.append(1, (u >> 8) & 0xFF);
+  s.append(1, (u >> 0) & 0xFF);
+  return s;
+}
+
 }  // namespace wvcdm

libwvdrmengine/cdm/util/test/test_clock.cpp

@@ -0,0 +1,40 @@
+// Copyright 2013 Google Inc. All Rights Reserved.
+//
+// Clock - A fake clock just for running tests.
+
+#include "clock.h"
+
+#include <chrono>
+
+#include "test_sleep.h"
+
+namespace wvcdm {
+
+namespace {
+// A fake clock that only advances when TestSleep::Sleep is called.
+class FakeClock : public wvcdm::TestSleep::CallBack {
+ public:
+  FakeClock() {
+    auto now = std::chrono::steady_clock().now();
+    now_ = now.time_since_epoch() / std::chrono::milliseconds(1);
+    TestSleep::set_callback(this);
+  }
+  ~FakeClock() { TestSleep::set_callback(nullptr); }
+  void ElapseTime(int64_t milliseconds) { now_ += milliseconds; }
+
+  int64_t now() const { return now_; }
+
+ private:
+  int64_t now_;
+};
+
+FakeClock* g_fake_clock = nullptr;
+}  // namespace
+
+// On devices running a fake OEMCrypto, we can use a fake sleep and fake time.
+int64_t Clock::GetCurrentTime() {
+  if (g_fake_clock == nullptr) g_fake_clock = new FakeClock();
+  return g_fake_clock->now() / 1000;
+}
+
+}  // namespace wvcdm

libwvdrmengine/cdm/util/test/test_sleep.cpp

@@ -0,0 +1,44 @@
+// Copyright 2019 Google LLC. All Rights Reserved. This file and proprietary
+// source code may only be used and distributed under the Widevine Master
+// License Agreement.
+
+#include "test_sleep.h"
+
+#include <unistd.h>
+
+#include <chrono>
+
+#include "clock.h"
+
+namespace wvcdm {
+
+bool TestSleep::real_sleep_ = true;
+TestSleep::CallBack* TestSleep::callback_ = nullptr;
+
+void TestSleep::Sleep(unsigned int seconds) {
+  int64_t milliseconds = 1000 * seconds;
+  if (real_sleep_) {
+    // This next bit of logic is to avoid slow drift apart of the real clock and
+    // the fake clock.  We compute how far from the real clock has advanced in
+    // total since the start, and then compare to a running total of sleep
+    // calls. We sleep for approximately x second, and then advance the clock by
+    // the amount of time that has actually passed.
+    static auto start_real = std::chrono::steady_clock().now();
+    static int64_t fake_clock = 0;
+    sleep(seconds);
+    auto now_real = std::chrono::steady_clock().now();
+    int64_t total_real = (now_real - start_real) / std::chrono::milliseconds(1);
+    // We want to advance the fake clock by the difference between the real
+    // clock, and the previous value on the fake clock.
+    milliseconds = total_real - fake_clock;
+    fake_clock += milliseconds;
+  }
+  if (callback_ != nullptr) callback_->ElapseTime(milliseconds);
+}
+
+void TestSleep::SyncFakeClock() {
+  // Syncing can be done by sleeping 0 seconds.
+  Sleep(0);
+}
+
+}  // namespace wvcdm

libwvdrmengine/cdm/util/test/test_sleep.h

@@ -0,0 +1,49 @@
+// Copyright 2018 Google LLC. All Rights Reserved. This file and proprietary
+// source code may only be used and distributed under the Widevine Master
+// License Agreement.
+//
+// TestSleep - Controls sleep and clock adjustment during tests.
+//
+#ifndef WVCDM_UTIL_TEST_SLEEP_H_
+#define WVCDM_UTIL_TEST_SLEEP_H_
+
+#include <stdint.h>
+
+namespace wvcdm {
+
+class TestSleep {
+ public:
+  // The callback is called when the clock should be advanced.
+  class CallBack {
+   public:
+    virtual void ElapseTime(int64_t milliseconds) = 0;
+
+   protected:
+    virtual ~CallBack(){};
+  };
+
+  // If real_sleep_ is true, then this sleeps for |seconds| of time.
+  // If the callback exists, this calls the callback.
+  static void Sleep(unsigned int seconds);
+
+  // If we are using a real clock and a fake clock, then the real clock advances
+  // a little while we are doing work, but the fake one only advances when we
+  // sleep. This function advances the fake clock to be in sync with the real
+  // clock. This function should be called to prevent a slow flaky test from
+  // failing due to this drift.
+  static void SyncFakeClock();
+
+  static void set_real_sleep(bool real_sleep) { real_sleep_ = real_sleep; }
+
+  static void set_callback(CallBack* callback) { callback_ = callback; }
+
+ private:
+  // Controls if the test sleep should use real sleep.
+  static bool real_sleep_;
+  // Called when the clock should advance.
+  static CallBack* callback_;
+};
+
+}  // namespace wvcdm
+
+#endif  // WVCDM_UTIL_TEST_SLEEP_H_