Source release 14.1.0

core/test/cdm_session_unittest.cpp

@@ -1,16 +1,30 @@
-// Copyright 2014 Google Inc. All Rights Reserved.
+// 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.
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 #include "cdm_session.h"
 #include "crypto_key.h"
+#include "metrics.pb.h"
 #include "properties.h"
 #include "scoped_ptr.h"
 #include "service_certificate.h"
 #include "string_conversions.h"
 #include "test_printers.h"
+#include "usage_table_header.h"
 #include "wv_cdm_constants.h"
 
+using ::testing::_;
+using ::testing::Eq;
+using ::testing::Invoke;
+using ::testing::NiceMock;
+using ::testing::NotNull;
+using ::testing::Return;
+using ::testing::SetArgPointee;
+using ::testing::Sequence;
+using ::testing::StrEq;
+
 namespace wvcdm {
 
 namespace {
@@ -100,10 +114,23 @@ class MockDeviceFiles : public DeviceFiles {
                                          std::string*, uint32_t*));
 };
 
+class MockUsageTableHeader : public UsageTableHeader {
+ public:
+  MockUsageTableHeader() : UsageTableHeader() {}
+
+  MOCK_METHOD2(UpdateEntry, CdmResponseType(CryptoSession* crypto_session,
+                                            CdmUsageEntry* usage_entry));
+};
+
 class MockCryptoSession : public CryptoSession {
  public:
   MockCryptoSession(metrics::CryptoMetrics* crypto_metrics)
-      : CryptoSession(crypto_metrics) { }
+      : CryptoSession(crypto_metrics) {
+    // By default, call the concrete implementation of GetUsageSupportType.
+    ON_CALL(*this, GetUsageSupportType(_))
+        .WillByDefault(
+            Invoke(this, &MockCryptoSession::BaseGetUsageSupportType));
+  }
   MOCK_METHOD1(GetClientToken, bool(std::string*));
   MOCK_METHOD1(GetProvisioningToken, bool(std::string*));
   MOCK_METHOD0(GetPreProvisionTokenType, CdmClientTokenType());
@@ -112,6 +139,12 @@ class MockCryptoSession : public CryptoSession {
   MOCK_METHOD1(Open, CdmResponseType(SecurityLevel));
   MOCK_METHOD1(LoadCertificatePrivateKey, bool(std::string&));
   MOCK_METHOD0(DeleteAllUsageReports, CdmResponseType());
+  MOCK_METHOD1(GetUsageSupportType, CdmResponseType(CdmUsageSupportType* type));
+  MOCK_METHOD0(GetUsageTableHeader, UsageTableHeader*());
+
+  CdmResponseType BaseGetUsageSupportType(CdmUsageSupportType* type) {
+    return CryptoSession::GetUsageSupportType(type);
+  }
 };
 
 class MockPolicyEngine : public PolicyEngine {
@@ -129,19 +162,11 @@ class MockCdmLicense : public CdmLicense {
   MOCK_METHOD7(Init, bool(const std::string&, CdmClientTokenType,
                           const std::string&, bool, const std::string&,
                           CryptoSession*, PolicyEngine*));
+  MOCK_METHOD0(provider_session_token, std::string());
 };
 
 }  // namespace
 
-// gmock methods
-using ::testing::_;
-using ::testing::Eq;
-using ::testing::NotNull;
-using ::testing::Return;
-using ::testing::SetArgPointee;
-using ::testing::Sequence;
-using ::testing::StrEq;
-
 class CdmSessionTest : public ::testing::Test {
  protected:
   virtual void SetUp() {
@@ -149,7 +174,7 @@ class CdmSessionTest : public ::testing::Test {
     // Inject testing mocks.
     license_parser_ = new MockCdmLicense(cdm_session_->session_id());
     cdm_session_->set_license_parser(license_parser_);
-    crypto_session_ = new MockCryptoSession(&crypto_metrics_);
+    crypto_session_ = new NiceMock<MockCryptoSession>(&crypto_metrics_);
     cdm_session_->set_crypto_session(crypto_session_);
     policy_engine_ = new MockPolicyEngine();
     cdm_session_->set_policy_engine(policy_engine_);
@@ -167,9 +192,10 @@ class CdmSessionTest : public ::testing::Test {
   scoped_ptr<CdmSession> cdm_session_;
   MockCdmLicense* license_parser_;
   metrics::CryptoMetrics crypto_metrics_;
-  MockCryptoSession* crypto_session_;
+  NiceMock<MockCryptoSession>* crypto_session_;
   MockPolicyEngine* policy_engine_;
   MockDeviceFiles* file_handle_;
+  MockUsageTableHeader usage_table_header_;
 };
 
 TEST_F(CdmSessionTest, InitWithBuiltInCertificate) {
@@ -282,4 +308,57 @@ TEST_F(CdmSessionTest, InitNeedsProvisioning) {
   ASSERT_EQ(NEED_PROVISIONING, cdm_session_->Init(NULL));
 }
 
+TEST_F(CdmSessionTest, UpdateUsageEntry) {
+  // Setup common expectations for initializing the CdmSession object.
+  Sequence crypto_session_seq;
+  CdmSecurityLevel level = kSecurityLevelL1;
+  EXPECT_CALL(*crypto_session_, Open(Eq(kLevelDefault)))
+      .InSequence(crypto_session_seq)
+      .WillOnce(Return(NO_ERROR));
+  EXPECT_CALL(*crypto_session_, GetSecurityLevel())
+      .InSequence(crypto_session_seq)
+      .WillOnce(Return(level));
+  EXPECT_CALL(*crypto_session_, GetPreProvisionTokenType())
+      .WillOnce(Return(kClientTokenKeybox));
+  EXPECT_CALL(*file_handle_, Init(Eq(level))).WillOnce(Return(true));
+  EXPECT_CALL(*file_handle_, RetrieveCertificate(NotNull(), NotNull(),
+                                                 NotNull(), _))
+      .WillOnce(DoAll(SetArgPointee<0>(kToken), SetArgPointee<1>(kWrappedKey),
+                      Return(true)));
+  EXPECT_CALL(*crypto_session_, LoadCertificatePrivateKey(StrEq(kWrappedKey)))
+      .InSequence(crypto_session_seq)
+      .WillOnce(Return(true));
+  EXPECT_CALL(*crypto_session_, GetUsageTableHeader())
+      .WillOnce(Return(&usage_table_header_));
+  EXPECT_CALL(*license_parser_,
+              Init(Eq(kToken), Eq(kClientTokenDrmCert), Eq(kEmptyString),
+                   false, Eq(kEmptyString), Eq(crypto_session_),
+                   Eq(policy_engine_)))
+      .WillOnce(Return(true));
+
+  // Set up mocks and expectations for the UpdateUsageEntryInformation call.
+  EXPECT_CALL(*crypto_session_, GetUsageSupportType(_))
+      .WillRepeatedly(DoAll(
+          SetArgPointee<0>(kUsageEntrySupport), Return(NO_ERROR)));
+  EXPECT_CALL(*license_parser_, provider_session_token())
+      .WillRepeatedly(Return("Mock provider session token"));
+  EXPECT_CALL(usage_table_header_, UpdateEntry(NotNull(), NotNull()))
+      .WillRepeatedly(Return(NO_ERROR));
+
+  EXPECT_EQ(NO_ERROR, cdm_session_->Init(NULL));
+  EXPECT_EQ(kUsageEntrySupport, cdm_session_->get_usage_support_type())
+      << "Usage support type: " << cdm_session_->get_usage_support_type();
+  EXPECT_EQ(NO_ERROR, cdm_session_->UpdateUsageEntryInformation());
+
+  // Verify the UsageEntry metric is set.
+  drm_metrics::WvCdmMetrics::SessionMetrics metrics;
+  cdm_session_->GetMetrics()->Serialize(&metrics);
+  std::string serialized_metrics;
+  ASSERT_TRUE(metrics.SerializeToString(&serialized_metrics));
+  EXPECT_GT(metrics.crypto_metrics()
+            .crypto_session_update_usage_entry_time_us().size(), 0)
+      << "Missing update usage entry metric. Metrics: "
+      << wvcdm::b2a_hex(serialized_metrics);
+}
+
 }  // namespace wvcdm