Refactor decrypt unit tests

Merge from Widevine repo of http://go/wvgerrit/169052

Refactor the decrypt unit tests into a separate file.

Bug: 253779846
Merged from https://widevine-internal-review.googlesource.com/167180

Change-Id: I10a4a987b0d597f0c6d2953c0723bea4d790fb9c

libwvdrmengine/oemcrypto/test/oemcrypto_license_test.h

@@ -10,11 +10,14 @@
 #include <gtest/gtest.h>
 
 #include "OEMCryptoCENC.h"
+#include "clock.h"
 #include "log.h"
 #include "oec_session_util.h"
 #include "oemcrypto_basic_test.h"
+#include "oemcrypto_corpus_generator_helper.h"
 #include "oemcrypto_resource_test.h"
 #include "oemcrypto_session_tests_helper.h"
+#include "wvcrc32.h"
 
 using ::testing::WithParamInterface;
 
@@ -237,6 +240,127 @@ class OEMCryptoLicenseTest : public OEMCryptoLicenseTestAPI16,
   }
 };
 
+// Test usage table functionality.
+class LicenseWithUsageEntry {
+ public:
+  LicenseWithUsageEntry(const std::string& pst = "my_pst")
+      : session_(),
+        license_messages_(&session_),
+        generic_crypto_(false),
+        time_license_received_(0),
+        time_first_decrypt_(0),
+        time_last_decrypt_(0),
+        active_(true) {
+    license_messages_.set_pst(pst);
+  }
+
+  void MakeAndLoadOnline(OEMCryptoSessionTests* test) {
+    MakeAndLoad(test,
+                wvoec::kControlNonceEnabled | wvoec::kControlNonceRequired);
+  }
+
+  // If status in not a nullptr, then creating a new entry is allowed to fail,
+  // and its error code is stored in status.
+  void MakeOfflineAndClose(OEMCryptoSessionTests* test,
+                           OEMCryptoResult* status = nullptr) {
+    MakeAndLoad(test, wvoec::kControlNonceOrEntry, status);
+    if (status != nullptr && *status != OEMCrypto_SUCCESS) {
+      ASSERT_NO_FATAL_FAILURE(session_.close());
+      return;
+    }
+    ASSERT_NO_FATAL_FAILURE(
+        session_.UpdateUsageEntry(&(test->encrypted_usage_header_)));
+    ASSERT_NO_FATAL_FAILURE(GenerateVerifyReport(kUnused));
+    ASSERT_NO_FATAL_FAILURE(session_.close());
+  }
+
+  // If status in not a nullptr, then creating a new entry is allowed to fail,
+  // and its error code is stored in status.
+  void MakeAndLoad(SessionUtil* util, uint32_t control,
+                   OEMCryptoResult* status = nullptr) {
+    license_messages_.set_control(control);
+    ASSERT_NO_FATAL_FAILURE(session_.open());
+    ASSERT_NO_FATAL_FAILURE(util->InstallTestDrmKey(&session_));
+    ASSERT_NO_FATAL_FAILURE(license_messages_.SignAndVerifyRequest());
+    if (generic_crypto_) {
+      ASSERT_NO_FATAL_FAILURE(
+          license_messages_.CreateResponseWithGenericCryptoKeys());
+    } else {
+      ASSERT_NO_FATAL_FAILURE(license_messages_.CreateDefaultResponse());
+    }
+    ASSERT_NO_FATAL_FAILURE(license_messages_.EncryptAndSignResponse());
+    ASSERT_NO_FATAL_FAILURE(session_.CreateNewUsageEntry(status));
+    if (status != nullptr && *status != OEMCrypto_SUCCESS) return;
+    ASSERT_EQ(OEMCrypto_SUCCESS, license_messages_.LoadResponse());
+    time_license_received_ = wvutil::Clock().GetCurrentTime();
+  }
+
+  void OpenAndReload(SessionUtil* util) {
+    ASSERT_NO_FATAL_FAILURE(session_.open());
+    ASSERT_NO_FATAL_FAILURE(session_.ReloadUsageEntry());
+    ASSERT_NO_FATAL_FAILURE(util->InstallTestDrmKey(&session_));
+    ASSERT_NO_FATAL_FAILURE(session_.GenerateDerivedKeysFromSessionKey());
+    ASSERT_EQ(OEMCrypto_SUCCESS, license_messages_.LoadResponse());
+  }
+
+  // Test decrypt, and update the decrypt times for the pst report.
+  void TestDecryptCTR(bool select_key_first = true,
+                      OEMCryptoResult expected_result = OEMCrypto_SUCCESS) {
+    session_.TestDecryptCTR(select_key_first, expected_result);
+    time_last_decrypt_ = wvutil::Clock().GetCurrentTime();
+    if (time_first_decrypt_ == 0) time_first_decrypt_ = time_last_decrypt_;
+  }
+
+  void DeactivateUsageEntry() {
+    active_ = false;
+    if (ShouldGenerateCorpus()) {
+      const std::string file_name =
+          GetFileName("oemcrypto_deactivate_usage_entry_fuzz_seed_corpus");
+      AppendToFile(file_name, pst().c_str(), pst().length());
+    }
+    ASSERT_EQ(
+        OEMCrypto_SUCCESS,
+        OEMCrypto_DeactivateUsageEntry(
+            session_.session_id(),
+            reinterpret_cast<const uint8_t*>(pst().c_str()), pst().length()));
+  }
+
+  void GenerateVerifyReport(OEMCrypto_Usage_Entry_Status status) {
+    ASSERT_NO_FATAL_FAILURE(session_.GenerateReport(pst()));
+    Test_PST_Report expected(pst(), status);
+    ASSERT_NO_FATAL_FAILURE(
+        session_.VerifyReport(expected, time_license_received_,
+                              time_first_decrypt_, time_last_decrypt_));
+    // The PST report was signed above.  Below we verify that the entire message
+    // that is sent to the server will be signed by the right mac keys.
+    RenewalRoundTrip renewal_messages(&license_messages_);
+    renewal_messages.set_is_release(!active_);
+    ASSERT_NO_FATAL_FAILURE(renewal_messages.SignAndVerifyRequest());
+  }
+
+  void ReloadUsageEntry() {
+    session_.ReloadUsageEntry();
+    session_.set_mac_keys(license_messages_.response_data().mac_keys);
+  }
+
+  const std::string& pst() const { return license_messages_.pst(); }
+  void set_pst(const std::string& pst) { license_messages_.set_pst(pst); }
+  LicenseRoundTrip& license_messages() { return license_messages_; }
+  Session& session() { return session_; }
+  void set_generic_crypto(bool generic_crypto) {
+    generic_crypto_ = generic_crypto;
+  }
+
+ private:
+  Session session_;
+  LicenseRoundTrip license_messages_;
+  bool generic_crypto_;
+  int64_t time_license_received_;
+  int64_t time_first_decrypt_;
+  int64_t time_last_decrypt_;
+  bool active_;
+};
+
 }  // namespace wvoec
 
 #endif  // CDM_OEMCRYPTO_LICENSE_TEST_