clang-format core/test files

[ Merge of http://go/wvgerrit/88006 ]

Certain test files have yet to be formatted since we introduced
clang-formatting.

Test: android unit/integration tests
Bug: 134365840
Change-Id: I2d30ad367d76a9dfbf389614e1b31ed39fa17c72

libwvdrmengine/cdm/core/test/buffer_reader_test.cpp

@@ -2,9 +2,9 @@
 // source code may only be used and distributed under the Widevine Master
 // License Agreement.
 
-#include <string>
 #include <errno.h>
 #include <gtest/gtest.h>
+#include <string>
 
 #include "buffer_reader.h"
 
@@ -836,4 +836,4 @@ TEST_F(BufferReaderTest, SkipBytesTooLarge) {
   ASSERT_TRUE(ValidateData(raw_data, sizeof(raw_data)));
   ASSERT_TRUE(ValidateReader(reader, raw_data, sizeof(raw_data), 0));
 }
-}  // namespace
+}  // namespace wvcdm

libwvdrmengine/cdm/core/test/cdm_engine_metrics_decorator_unittest.cpp

@@ -29,10 +29,8 @@ using ::wvcdm::metrics::EngineMetrics;
 
 namespace wvcdm {
 
-
 class MockCdmClientPropertySet : public CdmClientPropertySet {
  public:
-
   MOCK_CONST_METHOD0(security_level, const std::string&());
   MOCK_CONST_METHOD0(use_privacy_mode, bool());
   MOCK_CONST_METHOD0(service_certificate, const std::string&());
@@ -57,11 +55,11 @@ class MockCdmEngineImpl : public CdmEngine {
                     std::shared_ptr<EngineMetrics> metrics,
                     const std::string& spoid)
       : CdmEngine(file_system, metrics, spoid) {}
-  MOCK_METHOD4(OpenSession, CdmResponseType(
+  MOCK_METHOD4(OpenSession,
-      const CdmKeySystem&, CdmClientPropertySet*,
+               CdmResponseType(const CdmKeySystem&, CdmClientPropertySet*,
                                const CdmSessionId&, WvCdmEventListener*));
-  MOCK_METHOD4(OpenSession, CdmResponseType(
+  MOCK_METHOD4(OpenSession,
-      const CdmKeySystem&, CdmClientPropertySet*,
+               CdmResponseType(const CdmKeySystem&, CdmClientPropertySet*,
                                WvCdmEventListener*, CdmSessionId*));
   MOCK_METHOD1(CloseSession, CdmResponseType(const CdmSessionId&));
   MOCK_METHOD3(OpenKeySetSession,
@@ -71,28 +69,31 @@ class MockCdmEngineImpl : public CdmEngine {
                CdmResponseType(const CdmSessionId&, const CdmKeySetId&,
                                const InitializationData&, const CdmLicenseType,
                                CdmAppParameterMap&, CdmKeyRequest*));
-  MOCK_METHOD4(AddKey, CdmResponseType(
+  MOCK_METHOD4(AddKey,
-      const CdmSessionId&, const CdmKeyResponse&,
+               CdmResponseType(const CdmSessionId&, const CdmKeyResponse&,
                                CdmLicenseType*, CdmKeySetId*));
-  MOCK_METHOD2(RestoreKey, CdmResponseType(const CdmSessionId&,
+  MOCK_METHOD2(RestoreKey,
-                                           const CdmKeySetId&));
+               CdmResponseType(const CdmSessionId&, const CdmKeySetId&));
   MOCK_METHOD1(RemoveKeys, CdmResponseType(const CdmSessionId&));
-  MOCK_METHOD2(QueryKeyStatus, CdmResponseType(const CdmSessionId&,
+  MOCK_METHOD2(QueryKeyStatus,
-                                               CdmQueryMap*));
+               CdmResponseType(const CdmSessionId&, CdmQueryMap*));
-  MOCK_METHOD5(GetProvisioningRequest, CdmResponseType(
+  MOCK_METHOD5(GetProvisioningRequest,
-        CdmCertificateType, const std::string&, const std::string&,
+               CdmResponseType(CdmCertificateType, const std::string&,
-        CdmProvisioningRequest*, std::string*));
+                               const std::string&, CdmProvisioningRequest*,
-  MOCK_METHOD3(HandleProvisioningResponse, CdmResponseType(
+                               std::string*));
-        const CdmProvisioningResponse&, std::string*, std::string*));
+  MOCK_METHOD3(HandleProvisioningResponse,
+               CdmResponseType(const CdmProvisioningResponse&, std::string*,
+                               std::string*));
   MOCK_METHOD1(Unprovision, CdmResponseType(CdmSecurityLevel));
-  MOCK_METHOD4(ListUsageIds, CdmResponseType(
+  MOCK_METHOD4(ListUsageIds,
-        const std::string&, CdmSecurityLevel,
+               CdmResponseType(const std::string&, CdmSecurityLevel,
-        std::vector<std::string>*, std::vector<std::string>*));
+                               std::vector<std::string>*,
+                               std::vector<std::string>*));
   MOCK_METHOD1(RemoveAllUsageInfo, CdmResponseType(const std::string&));
-  MOCK_METHOD2(RemoveAllUsageInfo, CdmResponseType(const std::string&,
+  MOCK_METHOD2(RemoveAllUsageInfo,
-                                                   CdmSecurityLevel));
+               CdmResponseType(const std::string&, CdmSecurityLevel));
-  MOCK_METHOD2(RemoveUsageInfo, CdmResponseType(const std::string&,
+  MOCK_METHOD2(RemoveUsageInfo,
-                                                const CdmSecureStopId&));
+               CdmResponseType(const std::string&, const CdmSecureStopId&));
   MOCK_METHOD1(ReleaseUsageInfo,
                CdmResponseType(const CdmUsageInfoReleaseMessage&));
   MOCK_METHOD2(Decrypt, CdmResponseType(const CdmSessionId&,
@@ -108,7 +109,6 @@ class WvCdmEngineMetricsImplTest : public ::testing::Test {
     test_cdm_metrics_engine_.reset(
         new CdmEngineMetricsImpl<StrictMock<MockCdmEngineImpl>>(
             file_system_.get(), engine_metrics));
-
   }
 
  protected:
@@ -121,9 +121,9 @@ TEST_F(WvCdmEngineMetricsImplTest, OpenSession_Overload1) {
   MockCdmClientPropertySet property_set;
   MockWvCdmEventListener event_listener;
 
-  EXPECT_CALL(*test_cdm_metrics_engine_,
+  EXPECT_CALL(
-      OpenSession(
+      *test_cdm_metrics_engine_,
-          StrEq("foo"), Eq(&property_set),
+      OpenSession(StrEq("foo"), Eq(&property_set),
                   Matcher<const CdmSessionId&>(Eq("bar")), Eq(&event_listener)))
       .WillOnce(Return(wvcdm::UNKNOWN_ERROR));
 
@@ -134,9 +134,10 @@ TEST_F(WvCdmEngineMetricsImplTest, OpenSession_Overload1) {
   drm_metrics::WvCdmMetrics metrics_proto;
   test_cdm_metrics_engine_->GetMetricsSnapshot(&metrics_proto);
   ASSERT_EQ(1, metrics_proto.engine_metrics().cdm_engine_open_session_size());
-  EXPECT_EQ(wvcdm::UNKNOWN_ERROR,
+  EXPECT_EQ(wvcdm::UNKNOWN_ERROR, metrics_proto.engine_metrics()
-            metrics_proto.engine_metrics()
+                                      .cdm_engine_open_session(0)
-                .cdm_engine_open_session(0).attributes().error_code());
+                                      .attributes()
+                                      .error_code());
 }
 
 TEST_F(WvCdmEngineMetricsImplTest, OpenSession_Overload2) {
@@ -145,9 +146,8 @@ TEST_F(WvCdmEngineMetricsImplTest, OpenSession_Overload2) {
   CdmSessionId session_id;
 
   EXPECT_CALL(*test_cdm_metrics_engine_,
-      OpenSession(
+              OpenSession(StrEq("foo"), Eq(&property_set), Eq(&event_listener),
-          StrEq("foo"), Eq(&property_set),
+                          Matcher<CdmSessionId*>(Eq(&session_id))))
-          Eq(&event_listener), Matcher<CdmSessionId*>(Eq(&session_id))))
       .WillOnce(Return(wvcdm::UNKNOWN_ERROR));
 
   ASSERT_EQ(wvcdm::UNKNOWN_ERROR,
@@ -157,9 +157,10 @@ TEST_F(WvCdmEngineMetricsImplTest, OpenSession_Overload2) {
   drm_metrics::WvCdmMetrics metrics_proto;
   test_cdm_metrics_engine_->GetMetricsSnapshot(&metrics_proto);
   ASSERT_EQ(1, metrics_proto.engine_metrics().cdm_engine_open_session_size());
-  EXPECT_EQ(wvcdm::UNKNOWN_ERROR,
+  EXPECT_EQ(wvcdm::UNKNOWN_ERROR, metrics_proto.engine_metrics()
-            metrics_proto.engine_metrics()
+                                      .cdm_engine_open_session(0)
-                .cdm_engine_open_session(0).attributes().error_code());
+                                      .attributes()
+                                      .error_code());
 }
 
 TEST_F(WvCdmEngineMetricsImplTest, CloseSession) {
@@ -175,30 +176,32 @@ TEST_F(WvCdmEngineMetricsImplTest, CloseSession) {
   drm_metrics::WvCdmMetrics metrics_proto;
   test_cdm_metrics_engine_->GetMetricsSnapshot(&metrics_proto);
   ASSERT_EQ(1, metrics_proto.engine_metrics().cdm_engine_close_session_size());
-  EXPECT_EQ(wvcdm::UNKNOWN_ERROR,
+  EXPECT_EQ(wvcdm::UNKNOWN_ERROR, metrics_proto.engine_metrics()
-            metrics_proto.engine_metrics()
+                                      .cdm_engine_close_session(0)
-                .cdm_engine_close_session(0).attributes().error_code());
+                                      .attributes()
+                                      .error_code());
 }
 
 TEST_F(WvCdmEngineMetricsImplTest, OpenKeySetSession) {
   MockCdmClientPropertySet property_set;
   MockWvCdmEventListener event_listener;
 
-  EXPECT_CALL(*test_cdm_metrics_engine_,
+  EXPECT_CALL(
+      *test_cdm_metrics_engine_,
       OpenKeySetSession(Eq("bar"), Eq(&property_set), Eq(&event_listener)))
       .WillOnce(Return(wvcdm::UNKNOWN_ERROR));
 
-  ASSERT_EQ(wvcdm::UNKNOWN_ERROR,
+  ASSERT_EQ(wvcdm::UNKNOWN_ERROR, test_cdm_metrics_engine_->OpenKeySetSession(
-            test_cdm_metrics_engine_->OpenKeySetSession("bar", &property_set,
+                                      "bar", &property_set, &event_listener));
-                                                        &event_listener));
 
   drm_metrics::WvCdmMetrics metrics_proto;
   test_cdm_metrics_engine_->GetMetricsSnapshot(&metrics_proto);
   ASSERT_EQ(
       1, metrics_proto.engine_metrics().cdm_engine_open_key_set_session_size());
-  EXPECT_EQ(wvcdm::UNKNOWN_ERROR,
+  EXPECT_EQ(wvcdm::UNKNOWN_ERROR, metrics_proto.engine_metrics()
-            metrics_proto.engine_metrics()
+                                      .cdm_engine_open_key_set_session(0)
-                .cdm_engine_open_key_set_session(0).attributes().error_code());
+                                      .attributes()
+                                      .error_code());
 }
 
 TEST_F(WvCdmEngineMetricsImplTest, GenerateKeyRequest) {
@@ -206,25 +209,26 @@ TEST_F(WvCdmEngineMetricsImplTest, GenerateKeyRequest) {
   CdmAppParameterMap app_parameters;
   CdmKeyRequest key_request;
 
-  EXPECT_CALL(*test_cdm_metrics_engine_,
+  EXPECT_CALL(
+      *test_cdm_metrics_engine_,
       GenerateKeyRequest(Eq("foo"), Eq("bar"), _, Eq(kLicenseTypeStreaming),
                          Eq(app_parameters), Eq(&key_request)))
       .WillOnce(Return(wvcdm::UNKNOWN_ERROR));
 
   ASSERT_EQ(wvcdm::UNKNOWN_ERROR,
             test_cdm_metrics_engine_->GenerateKeyRequest(
-                "foo", "bar", initialization_data,
+                "foo", "bar", initialization_data, kLicenseTypeStreaming,
-                kLicenseTypeStreaming, app_parameters, &key_request));
+                app_parameters, &key_request));
 
   drm_metrics::WvCdmMetrics metrics_proto;
   test_cdm_metrics_engine_->GetMetricsSnapshot(&metrics_proto);
-  ASSERT_EQ(
+  ASSERT_EQ(1, metrics_proto.engine_metrics()
-      1, metrics_proto.engine_metrics()
                    .cdm_engine_generate_key_request_time_us_size());
   EXPECT_EQ(wvcdm::UNKNOWN_ERROR,
             metrics_proto.engine_metrics()
                 .cdm_engine_generate_key_request_time_us(0)
-                .attributes().error_code());
+                .attributes()
+                .error_code());
 }
 
 TEST_F(WvCdmEngineMetricsImplTest, AddKey) {
@@ -232,24 +236,22 @@ TEST_F(WvCdmEngineMetricsImplTest, AddKey) {
   CdmKeySetId key_set_id;
 
   EXPECT_CALL(*test_cdm_metrics_engine_,
-      AddKey(Eq("fake session id"), Eq("fake response"), Eq(&license_type),
+              AddKey(Eq("fake session id"), Eq("fake response"),
-             Eq(&key_set_id)))
+                     Eq(&license_type), Eq(&key_set_id)))
       .WillOnce(Return(wvcdm::UNKNOWN_ERROR));
 
   ASSERT_EQ(wvcdm::UNKNOWN_ERROR,
-            test_cdm_metrics_engine_->AddKey(
+            test_cdm_metrics_engine_->AddKey("fake session id", "fake response",
-                "fake session id", "fake response",
                                              &license_type, &key_set_id));
 
   drm_metrics::WvCdmMetrics metrics_proto;
   test_cdm_metrics_engine_->GetMetricsSnapshot(&metrics_proto);
-  ASSERT_EQ(
+  ASSERT_EQ(1,
-      1, metrics_proto.engine_metrics()
+            metrics_proto.engine_metrics().cdm_engine_add_key_time_us_size());
-          .cdm_engine_add_key_time_us_size());
+  EXPECT_EQ(wvcdm::UNKNOWN_ERROR, metrics_proto.engine_metrics()
-  EXPECT_EQ(wvcdm::UNKNOWN_ERROR,
-            metrics_proto.engine_metrics()
                                       .cdm_engine_add_key_time_us(0)
-                .attributes().error_code());
+                                      .attributes()
+                                      .error_code());
 }
 
 TEST_F(WvCdmEngineMetricsImplTest, RestoreKey) {
@@ -257,24 +259,21 @@ TEST_F(WvCdmEngineMetricsImplTest, RestoreKey) {
               RestoreKey(Eq("fake session id"), Eq("fake key set id")))
       .WillOnce(Return(wvcdm::UNKNOWN_ERROR));
 
-  ASSERT_EQ(wvcdm::UNKNOWN_ERROR,
+  ASSERT_EQ(wvcdm::UNKNOWN_ERROR, test_cdm_metrics_engine_->RestoreKey(
-            test_cdm_metrics_engine_->RestoreKey(
                                       "fake session id", "fake key set id"));
 
   drm_metrics::WvCdmMetrics metrics_proto;
   test_cdm_metrics_engine_->GetMetricsSnapshot(&metrics_proto);
   ASSERT_EQ(
-      1, metrics_proto.engine_metrics()
+      1, metrics_proto.engine_metrics().cdm_engine_restore_key_time_us_size());
-          .cdm_engine_restore_key_time_us_size());
+  EXPECT_EQ(wvcdm::UNKNOWN_ERROR, metrics_proto.engine_metrics()
-  EXPECT_EQ(wvcdm::UNKNOWN_ERROR,
-            metrics_proto.engine_metrics()
                                       .cdm_engine_restore_key_time_us(0)
-                .attributes().error_code());
+                                      .attributes()
+                                      .error_code());
 }
 
 TEST_F(WvCdmEngineMetricsImplTest, RemoveKeys) {
-  EXPECT_CALL(*test_cdm_metrics_engine_,
+  EXPECT_CALL(*test_cdm_metrics_engine_, RemoveKeys(Eq("fake session id")))
-      RemoveKeys(Eq("fake session id")))
       .WillOnce(Return(wvcdm::UNKNOWN_ERROR));
 
   ASSERT_EQ(wvcdm::UNKNOWN_ERROR,
@@ -282,13 +281,11 @@ TEST_F(WvCdmEngineMetricsImplTest, RemoveKeys) {
 
   drm_metrics::WvCdmMetrics metrics_proto;
   test_cdm_metrics_engine_->GetMetricsSnapshot(&metrics_proto);
-  ASSERT_EQ(
+  ASSERT_EQ(1, metrics_proto.engine_metrics().cdm_engine_remove_keys_size());
-      1, metrics_proto.engine_metrics()
+  EXPECT_EQ(wvcdm::UNKNOWN_ERROR, metrics_proto.engine_metrics()
-          .cdm_engine_remove_keys_size());
-  EXPECT_EQ(wvcdm::UNKNOWN_ERROR,
-            metrics_proto.engine_metrics()
                                       .cdm_engine_remove_keys(0)
-                .attributes().error_code());
+                                      .attributes()
+                                      .error_code());
 }
 
 TEST_F(WvCdmEngineMetricsImplTest, QueryKeyStatus) {
@@ -297,19 +294,17 @@ TEST_F(WvCdmEngineMetricsImplTest, QueryKeyStatus) {
               QueryKeyStatus(Eq("fake session id"), Eq(&query_response)))
       .WillOnce(Return(wvcdm::UNKNOWN_ERROR));
 
-  ASSERT_EQ(wvcdm::UNKNOWN_ERROR,
+  ASSERT_EQ(wvcdm::UNKNOWN_ERROR, test_cdm_metrics_engine_->QueryKeyStatus(
-            test_cdm_metrics_engine_->QueryKeyStatus("fake session id",
+                                      "fake session id", &query_response));
-                                                     &query_response));
 
   drm_metrics::WvCdmMetrics metrics_proto;
   test_cdm_metrics_engine_->GetMetricsSnapshot(&metrics_proto);
-  ASSERT_EQ(
+  ASSERT_EQ(1, metrics_proto.engine_metrics()
-      1, metrics_proto.engine_metrics()
                    .cdm_engine_query_key_status_time_us_size());
-  EXPECT_EQ(wvcdm::UNKNOWN_ERROR,
+  EXPECT_EQ(wvcdm::UNKNOWN_ERROR, metrics_proto.engine_metrics()
-            metrics_proto.engine_metrics()
                                       .cdm_engine_query_key_status_time_us(0)
-                .attributes().error_code());
+                                      .attributes()
+                                      .error_code());
 }
 
 TEST_F(WvCdmEngineMetricsImplTest, GetProvisioningRequest) {
@@ -330,13 +325,13 @@ TEST_F(WvCdmEngineMetricsImplTest, GetProvisioningRequest) {
 
   drm_metrics::WvCdmMetrics metrics_proto;
   test_cdm_metrics_engine_->GetMetricsSnapshot(&metrics_proto);
-  ASSERT_EQ(
+  ASSERT_EQ(1, metrics_proto.engine_metrics()
-      1, metrics_proto.engine_metrics()
                    .cdm_engine_get_provisioning_request_time_us_size());
   EXPECT_EQ(wvcdm::UNKNOWN_ERROR,
             metrics_proto.engine_metrics()
                 .cdm_engine_get_provisioning_request_time_us(0)
-                .attributes().error_code());
+                .attributes()
+                .error_code());
 }
 
 TEST_F(WvCdmEngineMetricsImplTest, HandleProvisioningResponse) {
@@ -355,18 +350,17 @@ TEST_F(WvCdmEngineMetricsImplTest, HandleProvisioningResponse) {
 
   drm_metrics::WvCdmMetrics metrics_proto;
   test_cdm_metrics_engine_->GetMetricsSnapshot(&metrics_proto);
-  ASSERT_EQ(
+  ASSERT_EQ(1, metrics_proto.engine_metrics()
-      1, metrics_proto.engine_metrics()
                    .cdm_engine_handle_provisioning_response_time_us_size());
   EXPECT_EQ(wvcdm::UNKNOWN_ERROR,
             metrics_proto.engine_metrics()
                 .cdm_engine_handle_provisioning_response_time_us(0)
-                .attributes().error_code());
+                .attributes()
+                .error_code());
 }
 
 TEST_F(WvCdmEngineMetricsImplTest, Unprovision) {
-  EXPECT_CALL(*test_cdm_metrics_engine_,
+  EXPECT_CALL(*test_cdm_metrics_engine_, Unprovision(Eq(kSecurityLevelL2)))
-      Unprovision(Eq(kSecurityLevelL2)))
       .WillOnce(Return(wvcdm::UNKNOWN_ERROR));
 
   ASSERT_EQ(wvcdm::UNKNOWN_ERROR,
@@ -374,18 +368,15 @@ TEST_F(WvCdmEngineMetricsImplTest, Unprovision) {
 
   drm_metrics::WvCdmMetrics metrics_proto;
   test_cdm_metrics_engine_->GetMetricsSnapshot(&metrics_proto);
-  ASSERT_EQ(
+  ASSERT_EQ(1, metrics_proto.engine_metrics().cdm_engine_unprovision_size());
-      1, metrics_proto.engine_metrics()
+  EXPECT_EQ(wvcdm::UNKNOWN_ERROR, metrics_proto.engine_metrics()
-          .cdm_engine_unprovision_size());
-  EXPECT_EQ(wvcdm::UNKNOWN_ERROR,
-            metrics_proto.engine_metrics()
                                       .cdm_engine_unprovision(0)
-                .attributes().error_code());
+                                      .attributes()
+                                      .error_code());
 }
 
 TEST_F(WvCdmEngineMetricsImplTest, RemoveAllUsageInfo_Overload1) {
-  EXPECT_CALL(*test_cdm_metrics_engine_,
+  EXPECT_CALL(*test_cdm_metrics_engine_, RemoveAllUsageInfo(Eq("fake app id")))
-      RemoveAllUsageInfo(Eq("fake app id")))
       .WillOnce(Return(wvcdm::UNKNOWN_ERROR));
 
   ASSERT_EQ(wvcdm::UNKNOWN_ERROR,
@@ -394,12 +385,12 @@ TEST_F(WvCdmEngineMetricsImplTest, RemoveAllUsageInfo_Overload1) {
   drm_metrics::WvCdmMetrics metrics_proto;
   test_cdm_metrics_engine_->GetMetricsSnapshot(&metrics_proto);
   ASSERT_EQ(
-      1, metrics_proto.engine_metrics()
+      1,
-          .cdm_engine_remove_all_usage_info_size());
+      metrics_proto.engine_metrics().cdm_engine_remove_all_usage_info_size());
-  EXPECT_EQ(wvcdm::UNKNOWN_ERROR,
+  EXPECT_EQ(wvcdm::UNKNOWN_ERROR, metrics_proto.engine_metrics()
-            metrics_proto.engine_metrics()
                                       .cdm_engine_remove_all_usage_info(0)
-                .attributes().error_code());
+                                      .attributes()
+                                      .error_code());
 }
 
 TEST_F(WvCdmEngineMetricsImplTest, RemoveAllUsageInfo_Overload2) {
@@ -407,40 +398,36 @@ TEST_F(WvCdmEngineMetricsImplTest, RemoveAllUsageInfo_Overload2) {
               RemoveAllUsageInfo(Eq("fake app id"), Eq(kSecurityLevelL2)))
       .WillOnce(Return(wvcdm::UNKNOWN_ERROR));
 
-  ASSERT_EQ(wvcdm::UNKNOWN_ERROR,
+  ASSERT_EQ(wvcdm::UNKNOWN_ERROR, test_cdm_metrics_engine_->RemoveAllUsageInfo(
-            test_cdm_metrics_engine_->RemoveAllUsageInfo("fake app id",
+                                      "fake app id", kSecurityLevelL2));
-                                                         kSecurityLevelL2));
 
   drm_metrics::WvCdmMetrics metrics_proto;
   test_cdm_metrics_engine_->GetMetricsSnapshot(&metrics_proto);
   ASSERT_EQ(
-      1, metrics_proto.engine_metrics()
+      1,
-          .cdm_engine_remove_all_usage_info_size());
+      metrics_proto.engine_metrics().cdm_engine_remove_all_usage_info_size());
-  EXPECT_EQ(wvcdm::UNKNOWN_ERROR,
+  EXPECT_EQ(wvcdm::UNKNOWN_ERROR, metrics_proto.engine_metrics()
-            metrics_proto.engine_metrics()
                                       .cdm_engine_remove_all_usage_info(0)
-                .attributes().error_code());
+                                      .attributes()
+                                      .error_code());
 }
 
-
 TEST_F(WvCdmEngineMetricsImplTest, RemoveUsageInfo) {
   EXPECT_CALL(*test_cdm_metrics_engine_,
               RemoveUsageInfo(Eq("fake app id"), Eq("fake secure stop id")))
       .WillOnce(Return(wvcdm::UNKNOWN_ERROR));
 
-  ASSERT_EQ(wvcdm::UNKNOWN_ERROR,
+  ASSERT_EQ(wvcdm::UNKNOWN_ERROR, test_cdm_metrics_engine_->RemoveUsageInfo(
-            test_cdm_metrics_engine_->RemoveUsageInfo("fake app id",
+                                      "fake app id", "fake secure stop id"));
-                                                      "fake secure stop id"));
 
   drm_metrics::WvCdmMetrics metrics_proto;
   test_cdm_metrics_engine_->GetMetricsSnapshot(&metrics_proto);
-  ASSERT_EQ(
+  ASSERT_EQ(1,
-      1, metrics_proto.engine_metrics()
+            metrics_proto.engine_metrics().cdm_engine_remove_usage_info_size());
-          .cdm_engine_remove_usage_info_size());
+  EXPECT_EQ(wvcdm::UNKNOWN_ERROR, metrics_proto.engine_metrics()
-  EXPECT_EQ(wvcdm::UNKNOWN_ERROR,
-            metrics_proto.engine_metrics()
                                       .cdm_engine_remove_usage_info(0)
-                .attributes().error_code());
+                                      .attributes()
+                                      .error_code());
 }
 
 TEST_F(WvCdmEngineMetricsImplTest, ReleaseUsageInfo) {
@@ -454,12 +441,11 @@ TEST_F(WvCdmEngineMetricsImplTest, ReleaseUsageInfo) {
   drm_metrics::WvCdmMetrics metrics_proto;
   test_cdm_metrics_engine_->GetMetricsSnapshot(&metrics_proto);
   ASSERT_EQ(
-      1, metrics_proto.engine_metrics()
+      1, metrics_proto.engine_metrics().cdm_engine_release_usage_info_size());
-          .cdm_engine_release_usage_info_size());
+  EXPECT_EQ(wvcdm::UNKNOWN_ERROR, metrics_proto.engine_metrics()
-  EXPECT_EQ(wvcdm::UNKNOWN_ERROR,
-            metrics_proto.engine_metrics()
                                       .cdm_engine_release_usage_info(0)
-                .attributes().error_code());
+                                      .attributes()
+                                      .error_code());
 }
 
 TEST_F(WvCdmEngineMetricsImplTest, ListUsageIds) {
@@ -467,24 +453,22 @@ TEST_F(WvCdmEngineMetricsImplTest, ListUsageIds) {
   std::vector<std::string> provider_session_tokens;
 
   EXPECT_CALL(*test_cdm_metrics_engine_,
-      ListUsageIds(Eq("fake app id"), Eq(kSecurityLevelL2),
+              ListUsageIds(Eq("fake app id"), Eq(kSecurityLevelL2), Eq(&ksids),
-                   Eq(&ksids), Eq(&provider_session_tokens)))
+                           Eq(&provider_session_tokens)))
       .WillOnce(Return(wvcdm::UNKNOWN_ERROR));
 
-  ASSERT_EQ(wvcdm::UNKNOWN_ERROR,
+  ASSERT_EQ(wvcdm::UNKNOWN_ERROR, test_cdm_metrics_engine_->ListUsageIds(
-            test_cdm_metrics_engine_->ListUsageIds(
                                       "fake app id", kSecurityLevelL2, &ksids,
                                       &provider_session_tokens));
 
   drm_metrics::WvCdmMetrics metrics_proto;
   test_cdm_metrics_engine_->GetMetricsSnapshot(&metrics_proto);
   ASSERT_EQ(
-      1, metrics_proto.engine_metrics()
+      1, metrics_proto.engine_metrics().cdm_engine_get_secure_stop_ids_size());
-          .cdm_engine_get_secure_stop_ids_size());
+  EXPECT_EQ(wvcdm::UNKNOWN_ERROR, metrics_proto.engine_metrics()
-  EXPECT_EQ(wvcdm::UNKNOWN_ERROR,
-            metrics_proto.engine_metrics()
                                       .cdm_engine_get_secure_stop_ids(0)
-                .attributes().error_code());
+                                      .attributes()
+                                      .error_code());
 }
 
 TEST_F(WvCdmEngineMetricsImplTest, FindSessionForKey) {
@@ -494,17 +478,17 @@ TEST_F(WvCdmEngineMetricsImplTest, FindSessionForKey) {
               FindSessionForKey(Eq("fake key id"), Eq(&session_id)))
       .WillOnce(Return(true));
 
-  ASSERT_TRUE(test_cdm_metrics_engine_->FindSessionForKey("fake key id",
+  ASSERT_TRUE(
-                                                          &session_id));
+      test_cdm_metrics_engine_->FindSessionForKey("fake key id", &session_id));
 
   drm_metrics::WvCdmMetrics metrics_proto;
   test_cdm_metrics_engine_->GetMetricsSnapshot(&metrics_proto);
   ASSERT_EQ(
-      1, metrics_proto.engine_metrics()
+      1, metrics_proto.engine_metrics().cdm_engine_find_session_for_key_size());
-          .cdm_engine_find_session_for_key_size());
   EXPECT_TRUE(metrics_proto.engine_metrics()
                   .cdm_engine_find_session_for_key(0)
-                 .attributes().error_code_bool());
+                  .attributes()
+                  .error_code_bool());
 }
 
 TEST_F(WvCdmEngineMetricsImplTest, Decrypt) {
@@ -517,13 +501,12 @@ TEST_F(WvCdmEngineMetricsImplTest, Decrypt) {
 
   drm_metrics::WvCdmMetrics metrics_proto;
   test_cdm_metrics_engine_->GetMetricsSnapshot(&metrics_proto);
-  ASSERT_EQ(
+  ASSERT_EQ(1,
-      1, metrics_proto.engine_metrics()
+            metrics_proto.engine_metrics().cdm_engine_decrypt_time_us_size());
-          .cdm_engine_decrypt_time_us_size());
+  EXPECT_EQ(wvcdm::UNKNOWN_ERROR, metrics_proto.engine_metrics()
-  EXPECT_EQ(wvcdm::UNKNOWN_ERROR,
-            metrics_proto.engine_metrics()
                                       .cdm_engine_decrypt_time_us(0)
-                .attributes().error_code());
+                                      .attributes()
+                                      .error_code());
 }
 
 }  // namespace wvcdm

libwvdrmengine/cdm/core/test/cdm_engine_test.cpp

@@ -11,15 +11,15 @@
 
 #include <string>
 
+#include "OEMCryptoCENC.h"
 #include "cdm_engine.h"
 #include "config_test_env.h"
 #include "device_files.h"
-#include "initialization_data.h"
 #include "file_store.h"
+#include "initialization_data.h"
 #include "license_request.h"
 #include "log.h"
 #include "metrics.pb.h"
-#include "OEMCryptoCENC.h"
 #include "properties.h"
 #include "string_conversions.h"
 #include "test_base.h"
@@ -181,8 +181,8 @@ class WvCdmEngineTest : public WvCdmEnginePreProvTest {
     CdmKeyRequest key_request;
 
     CdmResponseType result = cdm_engine_.GenerateKeyRequest(
-        session_id_, key_set_id, init_data, license_type,
+        session_id_, key_set_id, init_data, license_type, app_parameters,
-        app_parameters, &key_request);
+        &key_request);
     EXPECT_EQ(KEY_MESSAGE, result);
 
     key_msg_ = key_request.message;
@@ -261,16 +261,14 @@ class WvCdmEngineTest : public WvCdmEnginePreProvTest {
 
     EXPECT_EQ(KEY_ADDED, status);
     EXPECT_EQ(expected_license_type, license_type);
-    VerifyLicenseRequestLatency(kKeyRequestTypeInitial,
+    VerifyLicenseRequestLatency(kKeyRequestTypeInitial, *dummy_engine_metrics_);
-                                *dummy_engine_metrics_);
   }
 
   void VerifyRenewalKeyResponse(const std::string& server_url,
                                 const std::string& client_auth) {
     std::string resp = GetKeyRequestResponse(server_url, client_auth);
     EXPECT_EQ(KEY_ADDED, cdm_engine_.RenewKey(session_id_, resp));
-    VerifyLicenseRequestLatency(kKeyRequestTypeRenewal,
+    VerifyLicenseRequestLatency(kKeyRequestTypeRenewal, *dummy_engine_metrics_);
-                                *dummy_engine_metrics_);
   }
 
   void VerifyLicenseRequestLatency(
@@ -342,14 +340,10 @@ TEST_F(WvCdmEngineTest, SetLicensingServiceInvalidCertificate) {
 
 TEST_F(WvCdmEnginePreProvTestStaging, ProvisioningTest) { Provision(); }
 
-TEST_F(WvCdmEnginePreProvTestUatBinary, ProvisioningTest) {
+TEST_F(WvCdmEnginePreProvTestUatBinary, ProvisioningTest) { Provision(); }
-  Provision();
-}
 
 // Test that provisioning works.
-TEST_F(WvCdmEngineTest, ProvisioningTest) {
+TEST_F(WvCdmEngineTest, ProvisioningTest) { Provision(); }
-  Provision();
-}
 
 // Test that provisioning works, even if device is already provisioned.
 TEST_F(WvCdmEngineTest, ReprovisioningTest) {
@@ -418,7 +412,6 @@ TEST_F(WvCdmEngineTest, LicenseRenewal) {
 }
 
 TEST_F(WvCdmEngineTest, ParseDecryptHashStringTest) {
-
   CdmSessionId session_id;
   uint32_t frame_number;
   std::string hash;
@@ -428,13 +421,14 @@ TEST_F(WvCdmEngineTest, ParseDecryptHashStringTest) {
   const std::string test_frame_number_string =
       std::to_string(test_frame_number);
   const std::string test_invalid_hash = "an invalid hash";
-  std::vector<uint8_t> binary_hash{ 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0xFF };
+  std::vector<uint8_t> binary_hash{0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0xFF};
   const std::string test_valid_decoded_hash(binary_hash.begin(),
                                             binary_hash.end());
   const std::string test_valid_hash = b2a_hex(binary_hash);
   const std::string test_invalid_hash_string = "sample hash string";
   const std::string test_valid_hash_string = test_session_id + kComma +
-      test_frame_number_string + kComma + test_valid_hash;
+                                             test_frame_number_string + kComma +
+                                             test_valid_hash;
 
   // invalid parameters
   EXPECT_EQ(PARAMETER_NULL,
@@ -444,9 +438,8 @@ TEST_F(WvCdmEngineTest, ParseDecryptHashStringTest) {
             CdmEngine::ParseDecryptHashString(test_valid_hash_string,
                                               &session_id, nullptr, &hash));
   EXPECT_EQ(PARAMETER_NULL,
-            CdmEngine::ParseDecryptHashString(test_valid_hash_string,
+            CdmEngine::ParseDecryptHashString(
-                                              &session_id, &frame_number,
+                test_valid_hash_string, &session_id, &frame_number, nullptr));
-                                              nullptr));
 
   // Too few or too many parameters
   EXPECT_EQ(INVALID_DECRYPT_HASH_FORMAT,
@@ -500,15 +493,15 @@ TEST_F(WvCdmEngineTest, ParseDecryptHashStringTest) {
   EXPECT_EQ(INVALID_DECRYPT_HASH_FORMAT,
             CdmEngine::ParseDecryptHashString(hash_data, &session_id,
                                               &frame_number, &hash));
-  hash_data = test_session_id + kComma + test_frame_number_string + kComma +
+  hash_data =
-      kComma;
+      test_session_id + kComma + test_frame_number_string + kComma + kComma;
   EXPECT_EQ(INVALID_DECRYPT_HASH_FORMAT,
             CdmEngine::ParseDecryptHashString(hash_data, &session_id,
                                               &frame_number, &hash));
 
   // Invalid parameters (frame number, hash)
-  hash_data = test_session_id + kComma + test_session_id + kComma +
+  hash_data =
-      test_valid_hash;
+      test_session_id + kComma + test_session_id + kComma + test_valid_hash;
   EXPECT_EQ(INVALID_DECRYPT_HASH_FORMAT,
             CdmEngine::ParseDecryptHashString(hash_data, &session_id,
                                               &frame_number, &hash));
@@ -520,13 +513,11 @@ TEST_F(WvCdmEngineTest, ParseDecryptHashStringTest) {
 
   // valid data
   EXPECT_EQ(NO_ERROR,
-            CdmEngine::ParseDecryptHashString(test_valid_hash_string,
+            CdmEngine::ParseDecryptHashString(
-                                              &session_id, &frame_number,
+                test_valid_hash_string, &session_id, &frame_number, &hash));
-                                              &hash));
   EXPECT_EQ(test_session_id, session_id);
   EXPECT_EQ(test_frame_number, frame_number);
   EXPECT_EQ(test_valid_decoded_hash, hash);
 }
 
-
 }  // namespace wvcdm

libwvdrmengine/cdm/core/test/cdm_session_unittest.cpp

@@ -25,8 +25,8 @@ using ::testing::Invoke;
 using ::testing::NiceMock;
 using ::testing::NotNull;
 using ::testing::Return;
-using ::testing::SetArgPointee;
 using ::testing::Sequence;
+using ::testing::SetArgPointee;
 using ::testing::StrEq;
 
 namespace wvcdm {
@@ -114,8 +114,8 @@ class MockDeviceFiles : public DeviceFiles {
   MockDeviceFiles() : DeviceFiles(nullptr) {}
 
   MOCK_METHOD1(Init, bool(CdmSecurityLevel));
-  MOCK_METHOD4(RetrieveCertificate, bool(std::string*, std::string*,
+  MOCK_METHOD4(RetrieveCertificate,
-                                         std::string*, uint32_t*));
+               bool(std::string*, std::string*, std::string*, uint32_t*));
 };
 
 class MockUsageTableHeader : public UsageTableHeader {
@@ -161,12 +161,11 @@ class MockPolicyEngine : public PolicyEngine {
 
 class MockCdmLicense : public CdmLicense {
  public:
-  MockCdmLicense(const CdmSessionId& session_id)
+  MockCdmLicense(const CdmSessionId& session_id) : CdmLicense(session_id) {}
-      : CdmLicense(session_id) {}
 
-  MOCK_METHOD7(Init, bool(const std::string&, CdmClientTokenType,
+  MOCK_METHOD7(Init,
-                          const std::string&, bool, const std::string&,
+               bool(const std::string&, CdmClientTokenType, const std::string&,
-                          CryptoSession*, PolicyEngine*));
+                    bool, const std::string&, CryptoSession*, PolicyEngine*));
   MOCK_METHOD0(provider_session_token, std::string());
 };
 
@@ -216,8 +215,8 @@ TEST_F(CdmSessionTest, InitWithBuiltInCertificate) {
       .WillOnce(Return(level));
   EXPECT_CALL(*crypto_session_, GetPreProvisionTokenType())
       .WillOnce(Return(kClientTokenDrmCert));
-  EXPECT_CALL(*file_handle_, RetrieveCertificate(NotNull(), NotNull(),
+  EXPECT_CALL(*file_handle_,
-                                                 NotNull(), _))
+              RetrieveCertificate(NotNull(), NotNull(), NotNull(), _))
       .WillOnce(DoAll(SetArgPointee<0>(kToken), SetArgPointee<1>(kWrappedKey),
                       Return(true)));
   EXPECT_CALL(*crypto_session_, LoadCertificatePrivateKey(StrEq(kWrappedKey)))
@@ -225,9 +224,8 @@ TEST_F(CdmSessionTest, InitWithBuiltInCertificate) {
       .WillOnce(Return(NO_ERROR));
   EXPECT_CALL(*file_handle_, Init(Eq(level))).WillOnce(Return(true));
   EXPECT_CALL(*license_parser_,
-              Init(Eq(kToken), Eq(kClientTokenDrmCert), Eq(kEmptyString),
+              Init(Eq(kToken), Eq(kClientTokenDrmCert), Eq(kEmptyString), false,
-                   false, Eq(kEmptyString), Eq(crypto_session_),
+                   Eq(kEmptyString), Eq(crypto_session_), Eq(policy_engine_)))
-                   Eq(policy_engine_)))
       .WillOnce(Return(true));
 
   ASSERT_EQ(NO_ERROR, cdm_session_->Init(nullptr));
@@ -245,17 +243,16 @@ TEST_F(CdmSessionTest, InitWithCertificate) {
   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(),
+  EXPECT_CALL(*file_handle_,
-                                                 NotNull(), _))
+              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(NO_ERROR));
   EXPECT_CALL(*license_parser_,
-              Init(Eq(kToken), Eq(kClientTokenDrmCert), Eq(kEmptyString),
+              Init(Eq(kToken), Eq(kClientTokenDrmCert), Eq(kEmptyString), false,
-                   false, Eq(kEmptyString), Eq(crypto_session_),
+                   Eq(kEmptyString), Eq(crypto_session_), Eq(policy_engine_)))
-                   Eq(policy_engine_)))
       .WillOnce(Return(true));
 
   ASSERT_EQ(NO_ERROR, cdm_session_->Init(nullptr));
@@ -273,8 +270,8 @@ TEST_F(CdmSessionTest, ReInitFail) {
   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(),
+  EXPECT_CALL(*file_handle_,
-                                                 NotNull(), _))
+              RetrieveCertificate(NotNull(), NotNull(), NotNull(), _))
       .WillOnce(DoAll(SetArgPointee<0>(kToken), SetArgPointee<1>(kWrappedKey),
                       Return(true)));
   EXPECT_CALL(*crypto_session_, LoadCertificatePrivateKey(StrEq(kWrappedKey)))
@@ -308,8 +305,8 @@ TEST_F(CdmSessionTest, InitNeedsProvisioning) {
   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(),
+  EXPECT_CALL(*file_handle_,
-                                                 NotNull(), _))
+              RetrieveCertificate(NotNull(), NotNull(), NotNull(), _))
       .WillOnce(Return(false));
 
   ASSERT_EQ(NEED_PROVISIONING, cdm_session_->Init(nullptr));
@@ -328,8 +325,8 @@ TEST_F(CdmSessionTest, UpdateUsageEntry) {
   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(),
+  EXPECT_CALL(*file_handle_,
-                                                 NotNull(), _))
+              RetrieveCertificate(NotNull(), NotNull(), NotNull(), _))
       .WillOnce(DoAll(SetArgPointee<0>(kToken), SetArgPointee<1>(kWrappedKey),
                       Return(true)));
   EXPECT_CALL(*crypto_session_, LoadCertificatePrivateKey(StrEq(kWrappedKey)))
@@ -338,15 +335,14 @@ TEST_F(CdmSessionTest, UpdateUsageEntry) {
   EXPECT_CALL(*crypto_session_, GetUsageTableHeader())
       .WillOnce(Return(&usage_table_header_));
   EXPECT_CALL(*license_parser_,
-              Init(Eq(kToken), Eq(kClientTokenDrmCert), Eq(kEmptyString),
+              Init(Eq(kToken), Eq(kClientTokenDrmCert), Eq(kEmptyString), false,
-                   false, Eq(kEmptyString), Eq(crypto_session_),
+                   Eq(kEmptyString), Eq(crypto_session_), Eq(policy_engine_)))
-                   Eq(policy_engine_)))
       .WillOnce(Return(true));
 
   // Set up mocks and expectations for the UpdateUsageEntryInformation call.
   EXPECT_CALL(*crypto_session_, GetUsageSupportType(_))
-      .WillRepeatedly(DoAll(
+      .WillRepeatedly(
-          SetArgPointee<0>(kUsageEntrySupport), Return(NO_ERROR)));
+          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()))
@@ -362,8 +358,9 @@ TEST_F(CdmSessionTest, UpdateUsageEntry) {
   cdm_session_->GetMetrics()->Serialize(&metrics);
   std::string serialized_metrics;
   ASSERT_TRUE(metrics.SerializeToString(&serialized_metrics));
-  EXPECT_GT(metrics.crypto_metrics()
+  EXPECT_GT(
-            .usage_table_header_update_entry_time_us().size(), 0)
+      metrics.crypto_metrics().usage_table_header_update_entry_time_us().size(),
+      0)
       << "Missing update usage entry metric. Metrics: "
       << wvcdm::b2a_hex(serialized_metrics);
 }

libwvdrmengine/cdm/core/test/config_test_env.cpp

@@ -123,8 +123,7 @@ const std::string kCpProductionServiceCertificate =
 // Testing should be directed to this server. The only exception
 // is when testing against a new server feature that is not yet
 // deployed to this server (which would be directed to staging).
-const std::string kCpUatLicenseServer =
+const std::string kCpUatLicenseServer = "https://proxy.uat.widevine.com/proxy";
-    "https://proxy.uat.widevine.com/proxy";
 // NOTE: Provider ID = staging.google.com
 const std::string kCpUatServiceCertificate =
     "0ABF020803121028703454C008F63618ADE7443DB6C4C8188BE7F9900522"
@@ -263,7 +262,8 @@ const ConfigTestEnv::LicenseServerConfiguration license_servers[] = {
 
     {kContentProtectionUatServer, kCpUatLicenseServer, kCpUatServiceCertificate,
      kCpClientAuth, kCpKeyId, kCpOfflineKeyId,
-     // TODO(rfrias): replace when b/62880305 is addressed. For now use production
+     // TODO(rfrias): replace when b/62880305 is addressed. For now use
+     // production
      kCpProductionProvisioningServerUrl,
      kCpProductionProvisioningServiceCertificate},
 
@@ -306,7 +306,7 @@ ConfigTestEnv::ConfigTestEnv(ServerConfigurationId server_id, bool streaming,
   }
 }
 
-ConfigTestEnv& ConfigTestEnv::operator=(const ConfigTestEnv &other) {
+ConfigTestEnv& ConfigTestEnv::operator=(const ConfigTestEnv& other) {
   this->server_id_ = other.server_id_;
   this->client_auth_ = other.client_auth_;
   this->key_id_ = other.key_id_;

libwvdrmengine/cdm/core/test/crypto_session_unittest.cpp

@@ -12,9 +12,9 @@
 #include "key_session.h"
 #include "license_protocol.pb.h"
 #include "log.h"
-#include "platform.h"
 #include "metrics.pb.h"
 #include "metrics_collections.h"
+#include "platform.h"
 #include "test_base.h"
 #include "test_printers.h"
 #include "wv_cdm_types.h"
@@ -249,7 +249,7 @@ class CryptoSessionForTest : public TestCryptoSession, public WvCdmTestBase {
 
   void SetUp() {}
 
-  KeySession *key_session() { return key_session_.get(); }
+  KeySession* key_session() { return key_session_.get(); }
 
  private:
   static metrics::SessionMetrics metrics_;
@@ -258,7 +258,7 @@ class CryptoSessionForTest : public TestCryptoSession, public WvCdmTestBase {
 metrics::SessionMetrics CryptoSessionForTest::metrics_;
 
 TEST(CryptoSessionTest, CanExtractSystemIdFromOemCertificate) {
-  std::string oem_cert(reinterpret_cast<const char *>(kOemCert),
+  std::string oem_cert(reinterpret_cast<const char*>(kOemCert),
                        sizeof(kOemCert));
   uint32_t system_id;
   ASSERT_TRUE(
@@ -274,7 +274,7 @@ class CryptoSessionMetricsTest : public WvCdmTestBase {
     size_t key_data_len = sizeof(key_data);
     sts = OEMCrypto_GetKeyData(key_data, &key_data_len, kLevelDefault);
     if (sts != OEMCrypto_SUCCESS) return 0;
-    uint32_t *data = reinterpret_cast<uint32_t *>(key_data);
+    uint32_t* data = reinterpret_cast<uint32_t*>(key_data);
     uint32_t system_id = htonl(data[1]);
     return system_id;
   }

libwvdrmengine/cdm/core/test/device_files_unittest.cpp

@@ -2064,9 +2064,9 @@ class DeviceFilesSecurityLevelTest
     : public DeviceFilesTest,
       public ::testing::WithParamInterface<CdmSecurityLevel> {};
 
-class DeviceFilesUsageInfoListTest
+class DeviceFilesUsageInfoListTest : public DeviceFilesTest,
-    : public DeviceFilesTest,
+                                     public ::testing::WithParamInterface<int> {
-      public ::testing::WithParamInterface<int> {};
+};
 
 class DeviceFilesUsageInfoTest : public DeviceFilesTest,
                                  public ::testing::WithParamInterface<int> {};
@@ -2210,9 +2210,8 @@ TEST_F(DeviceCertificateTest, DISABLED_ReadCertificate) {
   std::string certificate, wrapped_private_key;
   std::string serial_number;
   uint32_t system_id = 0;
-  ASSERT_TRUE(
+  ASSERT_TRUE(device_files.RetrieveCertificate(
-      device_files.RetrieveCertificate(&certificate, &wrapped_private_key,
+      &certificate, &wrapped_private_key, &serial_number, &system_id));
-                                       &serial_number, &system_id));
   EXPECT_EQ(kTestCertificate, b2a_hex(certificate));
   EXPECT_EQ(kTestWrappedPrivateKey, b2a_hex(wrapped_private_key));
 }
@@ -2658,8 +2657,8 @@ TEST_F(DeviceFilesUsageInfoTest, ListUsageIds) {
 
   std::vector<std::string> key_set_ids;
   std::vector<std::string> provider_session_tokens;
-  EXPECT_TRUE(device_files.ListUsageIds(
+  EXPECT_TRUE(device_files.ListUsageIds(app_id, &key_set_ids,
-      app_id, &key_set_ids, &provider_session_tokens));
+                                        &provider_session_tokens));
 
   EXPECT_EQ(key_set_ids.size(), provider_session_tokens.size());
   if (index >= 0) {
@@ -2669,8 +2668,7 @@ TEST_F(DeviceFilesUsageInfoTest, ListUsageIds) {
         if (app_id == kUsageInfoTestData[j].app_id &&
             kUsageInfoTestData[j].usage_data.provider_session_token ==
                 provider_session_tokens[i] &&
-            kUsageInfoTestData[j].usage_data.key_set_id ==
+            kUsageInfoTestData[j].usage_data.key_set_id == key_set_ids[i]) {
-            key_set_ids[i]) {
           found = true;
         }
       }
@@ -2855,8 +2853,7 @@ TEST_P(DeviceFilesUsageInfoTest, ListKeySetIds) {
       bool found = false;
       for (int j = 0; !found && j <= index; ++j) {
         if (app_id == kUsageInfoTestData[j].app_id &&
-            kUsageInfoTestData[j].usage_data.key_set_id ==
+            kUsageInfoTestData[j].usage_data.key_set_id == key_set_ids[i]) {
-            key_set_ids[i]) {
           found = true;
         }
       }
@@ -3223,8 +3220,7 @@ TEST_P(DeviceFilesUsageTableTest, Read) {
               usage_entry_info[i].storage_type);
     EXPECT_EQ(kUsageEntriesTestData[i].key_set_id,
               usage_entry_info[i].key_set_id);
-    EXPECT_EQ(
+    EXPECT_EQ(kUsageEntriesTestData[i].usage_info_file_name,
-        kUsageEntriesTestData[i].usage_info_file_name,
               usage_entry_info[i].usage_info_file_name);
   }
 }

libwvdrmengine/cdm/core/test/generic_crypto_unittest.cpp

@@ -95,9 +95,7 @@ class WvGenericCryptoTest : public WvCdmTestBase {
   std::string iv_;
 };
 
-TEST_F(WvGenericCryptoTest, LoadSpecialKeys) {
+TEST_F(WvGenericCryptoTest, LoadSpecialKeys) { holder_.SignAndLoadLicense(); }
-  holder_.SignAndLoadLicense();
-}
 
 TEST_F(WvGenericCryptoTest, GenericEncryptGood) {
   CdmResponseType cdm_sts;
@@ -220,9 +218,9 @@ TEST_F(WvGenericCryptoTest, GenericVerifyKeyNotAllowed) {
   std::string signature = SignHMAC(in_buffer_, siggy_key_);
 
   holder_.SignAndLoadLicense();
-  cdm_sts = cdm_engine_.GenericVerify(holder_.session_id(), in_buffer_, key_id,
+  cdm_sts =
-                                      wvcdm::kSigningAlgorithmHmacSha256,
+      cdm_engine_.GenericVerify(holder_.session_id(), in_buffer_, key_id,
-                                      signature);
+                                wvcdm::kSigningAlgorithmHmacSha256, signature);
   EXPECT_EQ(UNKNOWN_ERROR, cdm_sts);
 }
 
@@ -231,8 +229,8 @@ TEST_F(WvGenericCryptoTest, GenericVerifyBadSignautre) {
   std::string signature(MAC_KEY_SIZE, 's');
 
   holder_.SignAndLoadLicense();
-  cdm_sts = cdm_engine_.GenericVerify(
+  cdm_sts =
-      holder_.session_id(), in_buffer_, vou_id_,
+      cdm_engine_.GenericVerify(holder_.session_id(), in_buffer_, vou_id_,
                                 wvcdm::kSigningAlgorithmHmacSha256, signature);
   // OEMCrypto error is OEMCrypto_ERROR_SIGNATURE_FAILURE
   EXPECT_EQ(UNKNOWN_ERROR, cdm_sts);

libwvdrmengine/cdm/core/test/http_socket.cpp

@@ -4,11 +4,11 @@
 
 #include "http_socket.h"
 
-#include <cstring>
 #include <errno.h>
 #include <fcntl.h>
 #include <stdlib.h>
 #include <string.h>
+#include <cstring>
 
 #ifdef _WIN32
 #  include "winsock2.h"
@@ -60,15 +60,14 @@ SSL_CTX* InitSslContext() {
   return ctx;
 }
 
-static int LogBoringSslError(
+static int LogBoringSslError(const char* message, size_t length,
-    const char* message, size_t length, void* /* user_data */) {
+                             void* /* user_data */) {
   LOGE("  BoringSSL Error: %s", message);
   return length;
 }
 
 bool IsRetryableSslError(int ssl_error) {
-  return ssl_error != SSL_ERROR_ZERO_RETURN &&
+  return ssl_error != SSL_ERROR_ZERO_RETURN && ssl_error != SSL_ERROR_SYSCALL &&
-      ssl_error != SSL_ERROR_SYSCALL &&
          ssl_error != SSL_ERROR_SSL;
 }
 
@@ -262,8 +261,8 @@ bool HttpSocket::Connect(int timeout_in_ms) {
   hints.ai_flags = AI_NUMERICSERV | AI_ADDRCONFIG;
 
   struct addrinfo* addr_info = nullptr;
-  int ret = getaddrinfo(domain_name_.c_str(), port_.c_str(), &hints,
+  int ret =
-                        &addr_info);
+      getaddrinfo(domain_name_.c_str(), port_.c_str(), &hints, &addr_info);
   if (ret != 0) {
     LOGE("getaddrinfo failed, errno = %d", ret);
     return false;
@@ -308,7 +307,8 @@ bool HttpSocket::Connect(int timeout_in_ms) {
   } else {
     if (GetError() != ERROR_ASYNC_COMPLETE) {
       // failed right away.
-      LOGE("cannot connect to %s, errno = %d", domain_name_.c_str(), GetError());
+      LOGE("cannot connect to %s, errno = %d", domain_name_.c_str(),
+           GetError());
       CloseSocket();
       return false;
     } else {

libwvdrmengine/cdm/core/test/http_socket_test.cpp

@@ -25,7 +25,7 @@ std::string gTestData("Hello");
 // Arbitrary buffer size and timeout settings.
 const int kHttpBufferSize = 4096;
 const int kTimeout = 3000;
-}
+}  // namespace
 
 class HttpSocketTest : public testing::Test {
  public:

libwvdrmengine/cdm/core/test/initialization_data_unittest.cpp

@@ -501,7 +501,6 @@ class HlsParseTest : public ::testing::TestWithParam<HlsAttributeVariant> {};
 
 class HlsTest : public ::testing::Test {};
 
-
 TEST_F(InitializationDataTest, BadType) {
   InitializationData init_data("bad", kWidevinePssh);
   EXPECT_TRUE(init_data.IsEmpty());

libwvdrmengine/cdm/core/test/license_keys_unittest.cpp

@@ -64,20 +64,15 @@ static const KeyId ck_NO_HDCP_dual_res = "ck_NO_HDCP_dual_res";
 // protobuf generated classes.
 using video_widevine::License;
 using video_widevine::LicenseIdentification;
-using video_widevine::STREAMING;
 using video_widevine::OFFLINE;
+using video_widevine::STREAMING;
 
 using KeyContainer = ::video_widevine::License::KeyContainer;
 using VideoResolutionConstraint = KeyContainer::VideoResolutionConstraint;
 
 class LicenseKeysTest : public ::testing::Test {
  protected:
-
+  enum KeyFlag { kKeyFlagNull, kKeyFlagFalse, kKeyFlagTrue };
-  enum KeyFlag {
-    kKeyFlagNull,
-    kKeyFlagFalse,
-    kKeyFlagTrue
-  };
 
   static const KeyFlag kEncryptNull = kKeyFlagNull;
   static const KeyFlag kEncryptFalse = kKeyFlagFalse;
@@ -122,14 +117,15 @@ class LicenseKeysTest : public ::testing::Test {
       pro->set_hdcp(hdcp_value);
     }
     if (set_constraints) {
-      for (std::vector<VideoResolutionConstraint>::iterator
+      for (std::vector<VideoResolutionConstraint>::iterator it =
-               it = constraints->begin(); it != constraints->end(); ++it) {
+               constraints->begin();
+           it != constraints->end(); ++it) {
         VideoResolutionConstraint* constraint =
             key->add_video_resolution_constraints();
         constraint->set_min_resolution_pixels(it->min_resolution_pixels());
         constraint->set_max_resolution_pixels(it->max_resolution_pixels());
-        constraint->mutable_required_protection()->
+        constraint->mutable_required_protection()->set_hdcp(
-            set_hdcp(it->required_protection().hdcp());
+            it->required_protection().hdcp());
       }
     }
     key->set_id(key_id);
@@ -149,10 +145,12 @@ class LicenseKeysTest : public ::testing::Test {
         ->set_type(KeyContainer::ENTITLEMENT);
   }
 
-  virtual void AddOperatorSessionKey(
+  virtual void AddOperatorSessionKey(const KeyId& key_id,
-      const KeyId& key_id, bool set_perms = false,
+                                     bool set_perms = false,
-      KeyFlag encrypt = kKeyFlagNull, KeyFlag decrypt = kKeyFlagNull,
+                                     KeyFlag encrypt = kKeyFlagNull,
-      KeyFlag sign = kKeyFlagNull, KeyFlag verify = kKeyFlagNull) {
+                                     KeyFlag decrypt = kKeyFlagNull,
+                                     KeyFlag sign = kKeyFlagNull,
+                                     KeyFlag verify = kKeyFlagNull) {
     KeyContainer* non_content_key = license_.add_key();
     non_content_key->set_type(KeyContainer::OPERATOR_SESSION);
     non_content_key->set_id(key_id);
@@ -192,8 +190,8 @@ class LicenseKeysTest : public ::testing::Test {
     EXPECT_FALSE(key_usage.generic_verify);
   }
 
-  virtual void ExpectAllowedUsageOperator(
+  virtual void ExpectAllowedUsageOperator(const CdmKeyAllowedUsage& key_usage,
-      const CdmKeyAllowedUsage& key_usage, KeyFlag encrypt, KeyFlag decrypt,
+                                          KeyFlag encrypt, KeyFlag decrypt,
                                           KeyFlag sign, KeyFlag verify) {
     EXPECT_FALSE(key_usage.decrypt_to_secure_buffer);
     EXPECT_FALSE(key_usage.decrypt_to_clear_buffer);
@@ -203,9 +201,7 @@ class LicenseKeysTest : public ::testing::Test {
     EXPECT_EQ(key_usage.generic_verify, verify == kKeyFlagTrue);
   }
 
-  virtual int NumContentKeys() {
+  virtual int NumContentKeys() { return content_key_count_; }
-    return content_key_count_;
-  }
 
   virtual void StageContentKeys() {
     content_key_count_ = 0;
@@ -223,20 +219,20 @@ class LicenseKeysTest : public ::testing::Test {
   }
 
   virtual void StageOperatorSessionKeys() {
-    AddOperatorSessionKey(osk_decrypt, true,
+    AddOperatorSessionKey(osk_decrypt, true, kEncryptNull, kDecryptTrue,
-                          kEncryptNull, kDecryptTrue, kSignNull, kVerifyNull);
+                          kSignNull, kVerifyNull);
-    AddOperatorSessionKey(osk_encrypt, true,
+    AddOperatorSessionKey(osk_encrypt, true, kEncryptTrue, kDecryptNull,
-                          kEncryptTrue, kDecryptNull, kSignNull, kVerifyNull);
+                          kSignNull, kVerifyNull);
-    AddOperatorSessionKey(osk_sign, true,
+    AddOperatorSessionKey(osk_sign, true, kEncryptNull, kDecryptNull, kSignTrue,
-                          kEncryptNull, kDecryptNull, kSignTrue, kVerifyNull);
+                          kVerifyNull);
-    AddOperatorSessionKey(osk_verify, true,
+    AddOperatorSessionKey(osk_verify, true, kEncryptNull, kDecryptNull,
-                          kEncryptNull, kDecryptNull, kSignNull, kVerifyTrue);
+                          kSignNull, kVerifyTrue);
-    AddOperatorSessionKey(osk_encrypt_decrypt, true,
+    AddOperatorSessionKey(osk_encrypt_decrypt, true, kEncryptTrue, kDecryptTrue,
-                          kEncryptTrue, kDecryptTrue, kSignNull, kVerifyNull);
+                          kSignNull, kVerifyNull);
-    AddOperatorSessionKey(osk_sign_verify, true,
+    AddOperatorSessionKey(osk_sign_verify, true, kEncryptNull, kDecryptNull,
-                          kEncryptNull, kDecryptNull, kSignTrue, kVerifyTrue);
+                          kSignTrue, kVerifyTrue);
-    AddOperatorSessionKey(osk_all, true,
+    AddOperatorSessionKey(osk_all, true, kEncryptTrue, kDecryptTrue, kSignTrue,
-                          kEncryptTrue, kDecryptTrue, kSignTrue, kVerifyTrue);
+                          kVerifyTrue);
     license_keys_->SetFromLicense(license_);
   }
 
@@ -310,8 +306,8 @@ class LicenseKeysTest : public ::testing::Test {
     constraints.clear();
     AddConstraint(constraints, key_hi_res_min, key_hi_res_max);
 
-    AddContentKey(
+    AddContentKey(ck_HDCP_NO_OUTPUT_hi_res, true,
-        ck_HDCP_NO_OUTPUT_hi_res, true, KeyContainer::SW_SECURE_CRYPTO, true,
+                  KeyContainer::SW_SECURE_CRYPTO, true,
                   KeyContainer::OutputProtection::HDCP_NO_DIGITAL_OUTPUT, true,
                   &constraints);
     content_key_count_++;
@@ -372,15 +368,12 @@ class LicenseKeysTest : public ::testing::Test {
     }
   }
 
-
   size_t content_key_count_;
   std::unique_ptr<LicenseKeys> license_keys_;
   License license_;
 };
 
-TEST_F(LicenseKeysTest, Empty) {
+TEST_F(LicenseKeysTest, Empty) { EXPECT_TRUE(license_keys_->Empty()); }
-  EXPECT_TRUE(license_keys_->Empty());
-}
 
 TEST_F(LicenseKeysTest, NotEmpty) {
   const KeyId c_key = "content_key";
@@ -474,15 +467,15 @@ TEST_F(LicenseKeysTest, CanDecrypt) {
   EXPECT_FALSE(license_keys_->CanDecryptContent(e_key));
   bool new_usable_keys = false;
   bool any_change = false;
-  any_change = license_keys_->ApplyStatusChange(kKeyStatusUsable,
+  any_change =
-                                               &new_usable_keys);
+      license_keys_->ApplyStatusChange(kKeyStatusUsable, &new_usable_keys);
   EXPECT_TRUE(any_change);
   EXPECT_TRUE(new_usable_keys);
   EXPECT_TRUE(license_keys_->CanDecryptContent(c_key));
   EXPECT_FALSE(license_keys_->CanDecryptContent(os_key));
 
-  any_change = license_keys_->ApplyStatusChange(kKeyStatusExpired,
+  any_change =
-                                               &new_usable_keys);
+      license_keys_->ApplyStatusChange(kKeyStatusExpired, &new_usable_keys);
   EXPECT_TRUE(any_change);
   EXPECT_FALSE(new_usable_keys);
   EXPECT_FALSE(license_keys_->CanDecryptContent(c_key));
@@ -538,13 +531,13 @@ TEST_F(LicenseKeysTest, AllowedUsageContent) {
 
   CdmKeyAllowedUsage u_hw_decode;
   EXPECT_TRUE(license_keys_->GetAllowedUsage(ck_hw_decode, &u_hw_decode));
-  ExpectAllowedUsageContent(u_hw_decode, kContentSecureTrue,
+  ExpectAllowedUsageContent(u_hw_decode, kContentSecureTrue, kContentClearFalse,
-                            kContentClearFalse, kHardwareSecureDecode);
+                            kHardwareSecureDecode);
 
   CdmKeyAllowedUsage u_hw_secure;
   EXPECT_TRUE(license_keys_->GetAllowedUsage(ck_hw_secure, &u_hw_secure));
-  ExpectAllowedUsageContent(u_hw_secure, kContentSecureTrue,
+  ExpectAllowedUsageContent(u_hw_secure, kContentSecureTrue, kContentClearFalse,
-                            kContentClearFalse, kHardwareSecureAll);
+                            kHardwareSecureAll);
 }
 
 TEST_F(LicenseKeysTest, AllowedUsageOperatorSession) {
@@ -570,8 +563,8 @@ TEST_F(LicenseKeysTest, AllowedUsageOperatorSession) {
                              kVerifyTrue);
 
   CdmKeyAllowedUsage u_encrypt_decrypt;
-  EXPECT_TRUE(license_keys_->GetAllowedUsage(osk_encrypt_decrypt,
+  EXPECT_TRUE(
-                                            &u_encrypt_decrypt));
+      license_keys_->GetAllowedUsage(osk_encrypt_decrypt, &u_encrypt_decrypt));
   ExpectAllowedUsageOperator(u_encrypt_decrypt, kEncryptTrue, kDecryptTrue,
                              kSignFalse, kVerifyFalse);
 
@@ -609,8 +602,8 @@ TEST_F(LicenseKeysTest, KeyStatusChanges) {
   ExpectKeyStatusesEqual(key_status_map, kKeyStatusInternalError);
 
   // change to pending
-  any_change = license_keys_->ApplyStatusChange(kKeyStatusPending,
+  any_change =
-                                               &new_usable_keys);
+      license_keys_->ApplyStatusChange(kKeyStatusPending, &new_usable_keys);
   EXPECT_TRUE(any_change);
   EXPECT_FALSE(new_usable_keys);
   EXPECT_FALSE(license_keys_->CanDecryptContent(ck_sw_crypto));
@@ -633,8 +626,8 @@ TEST_F(LicenseKeysTest, KeyStatusChanges) {
   ExpectKeyStatusesEqual(key_status_map, kKeyStatusUsableInFuture);
 
   // change to usable
-  any_change = license_keys_->ApplyStatusChange(kKeyStatusUsable,
+  any_change =
-                                               &new_usable_keys);
+      license_keys_->ApplyStatusChange(kKeyStatusUsable, &new_usable_keys);
   EXPECT_TRUE(any_change);
   EXPECT_TRUE(new_usable_keys);
   EXPECT_TRUE(license_keys_->CanDecryptContent(ck_sw_crypto));
@@ -645,8 +638,8 @@ TEST_F(LicenseKeysTest, KeyStatusChanges) {
   ExpectKeyStatusesEqual(key_status_map, kKeyStatusUsable);
 
   // change to usable (again)
-  any_change = license_keys_->ApplyStatusChange(kKeyStatusUsable,
+  any_change =
-                                               &new_usable_keys);
+      license_keys_->ApplyStatusChange(kKeyStatusUsable, &new_usable_keys);
   EXPECT_FALSE(any_change);
   EXPECT_FALSE(new_usable_keys);
   EXPECT_TRUE(license_keys_->CanDecryptContent(ck_sw_crypto));
@@ -657,8 +650,8 @@ TEST_F(LicenseKeysTest, KeyStatusChanges) {
   ExpectKeyStatusesEqual(key_status_map, kKeyStatusUsable);
 
   // change to expired
-  any_change = license_keys_->ApplyStatusChange(kKeyStatusExpired,
+  any_change =
-                                               &new_usable_keys);
+      license_keys_->ApplyStatusChange(kKeyStatusExpired, &new_usable_keys);
   EXPECT_TRUE(any_change);
   EXPECT_FALSE(new_usable_keys);
   EXPECT_FALSE(license_keys_->CanDecryptContent(ck_sw_crypto));
@@ -675,8 +668,8 @@ TEST_F(LicenseKeysTest, HdcpChanges) {
   CdmKeyStatusMap key_status_map;
   StageHdcpKeys();
 
-  any_change = license_keys_->ApplyStatusChange(kKeyStatusUsable,
+  any_change =
-                                               &new_usable_keys);
+      license_keys_->ApplyStatusChange(kKeyStatusUsable, &new_usable_keys);
   EXPECT_TRUE(any_change);
   EXPECT_TRUE(new_usable_keys);
   EXPECT_TRUE(license_keys_->CanDecryptContent(ck_sw_crypto_NO_HDCP));
@@ -702,8 +695,8 @@ TEST_F(LicenseKeysTest, HdcpChanges) {
   EXPECT_TRUE(license_keys_->MeetsConstraints(ck_hw_secure_HDCP_NO_OUTPUT));
 
   license_keys_->ApplyConstraints(100, HDCP_NONE);
-  any_change = license_keys_->ApplyStatusChange(kKeyStatusUsable,
+  any_change =
-                                               &new_usable_keys);
+      license_keys_->ApplyStatusChange(kKeyStatusUsable, &new_usable_keys);
 
   EXPECT_TRUE(any_change);
   EXPECT_FALSE(new_usable_keys);
@@ -750,8 +743,8 @@ TEST_F(LicenseKeysTest, HdcpChanges) {
                        kKeyStatusOutputNotAllowed);
 
   license_keys_->ApplyConstraints(100, HDCP_V1);
-  any_change = license_keys_->ApplyStatusChange(kKeyStatusUsable,
+  any_change =
-                                               &new_usable_keys);
+      license_keys_->ApplyStatusChange(kKeyStatusUsable, &new_usable_keys);
 
   EXPECT_FALSE(any_change);
   EXPECT_FALSE(new_usable_keys);
@@ -798,8 +791,8 @@ TEST_F(LicenseKeysTest, HdcpChanges) {
                        kKeyStatusOutputNotAllowed);
 
   license_keys_->ApplyConstraints(100, HDCP_V2_1);
-  any_change = license_keys_->ApplyStatusChange(kKeyStatusUsable,
+  any_change =
-                                               &new_usable_keys);
+      license_keys_->ApplyStatusChange(kKeyStatusUsable, &new_usable_keys);
 
   EXPECT_TRUE(any_change);
   EXPECT_TRUE(new_usable_keys);
@@ -846,8 +839,8 @@ TEST_F(LicenseKeysTest, HdcpChanges) {
                        kKeyStatusOutputNotAllowed);
 
   license_keys_->ApplyConstraints(100, HDCP_V2_2);
-  any_change = license_keys_->ApplyStatusChange(kKeyStatusUsable,
+  any_change =
-                                               &new_usable_keys);
+      license_keys_->ApplyStatusChange(kKeyStatusUsable, &new_usable_keys);
 
   EXPECT_TRUE(any_change);
   EXPECT_TRUE(new_usable_keys);
@@ -894,8 +887,8 @@ TEST_F(LicenseKeysTest, HdcpChanges) {
                        kKeyStatusOutputNotAllowed);
 
   license_keys_->ApplyConstraints(100, HDCP_V2_3);
-  any_change = license_keys_->ApplyStatusChange(kKeyStatusUsable,
+  any_change =
-                                               &new_usable_keys);
+      license_keys_->ApplyStatusChange(kKeyStatusUsable, &new_usable_keys);
 
   EXPECT_TRUE(any_change);
   EXPECT_TRUE(new_usable_keys);
@@ -942,8 +935,8 @@ TEST_F(LicenseKeysTest, HdcpChanges) {
                        kKeyStatusOutputNotAllowed);
 
   license_keys_->ApplyConstraints(100, HDCP_NO_DIGITAL_OUTPUT);
-  any_change = license_keys_->ApplyStatusChange(kKeyStatusUsable,
+  any_change =
-                                               &new_usable_keys);
+      license_keys_->ApplyStatusChange(kKeyStatusUsable, &new_usable_keys);
 
   EXPECT_TRUE(any_change);
   EXPECT_TRUE(new_usable_keys);
@@ -982,8 +975,8 @@ TEST_F(LicenseKeysTest, HdcpChanges) {
                        kKeyStatusUsable);
 
   license_keys_->ApplyConstraints(100, HDCP_NONE);
-  any_change = license_keys_->ApplyStatusChange(kKeyStatusUsable,
+  any_change =
-                                               &new_usable_keys);
+      license_keys_->ApplyStatusChange(kKeyStatusUsable, &new_usable_keys);
 
   EXPECT_TRUE(any_change);
   EXPECT_FALSE(new_usable_keys);
@@ -1037,8 +1030,8 @@ TEST_F(LicenseKeysTest, ConstraintChanges) {
   StageConstraintKeys();
 
   // No constraints set by device
-  any_change = license_keys_->ApplyStatusChange(kKeyStatusUsable,
+  any_change =
-                                               &new_usable_keys);
+      license_keys_->ApplyStatusChange(kKeyStatusUsable, &new_usable_keys);
   EXPECT_TRUE(any_change);
   EXPECT_TRUE(new_usable_keys);
   EXPECT_TRUE(license_keys_->CanDecryptContent(ck_NO_HDCP_lo_res));
@@ -1057,8 +1050,8 @@ TEST_F(LicenseKeysTest, ConstraintChanges) {
 
   // Low-res device, no HDCP support
   license_keys_->ApplyConstraints(dev_lo_res, HDCP_NONE);
-  any_change = license_keys_->ApplyStatusChange(kKeyStatusUsable,
+  any_change =
-                                               &new_usable_keys);
+      license_keys_->ApplyStatusChange(kKeyStatusUsable, &new_usable_keys);
 
   EXPECT_TRUE(any_change);
   EXPECT_FALSE(new_usable_keys);
@@ -1098,8 +1091,8 @@ TEST_F(LicenseKeysTest, ConstraintChanges) {
 
   // Hi-res device, HDCP_V1 support
   license_keys_->ApplyConstraints(dev_hi_res, HDCP_V1);
-  any_change = license_keys_->ApplyStatusChange(kKeyStatusUsable,
+  any_change =
-                                               &new_usable_keys);
+      license_keys_->ApplyStatusChange(kKeyStatusUsable, &new_usable_keys);
 
   EXPECT_TRUE(any_change);
   EXPECT_TRUE(new_usable_keys);
@@ -1139,8 +1132,8 @@ TEST_F(LicenseKeysTest, ConstraintChanges) {
 
   // Lo-res device, HDCP V2.2 support
   license_keys_->ApplyConstraints(dev_lo_res, HDCP_V2_2);
-  any_change = license_keys_->ApplyStatusChange(kKeyStatusUsable,
+  any_change =
-                                               &new_usable_keys);
+      license_keys_->ApplyStatusChange(kKeyStatusUsable, &new_usable_keys);
 
   EXPECT_TRUE(any_change);
   EXPECT_TRUE(new_usable_keys);
@@ -1178,8 +1171,8 @@ TEST_F(LicenseKeysTest, ConstraintChanges) {
 
   // Hi-res device, Maximal HDCP support
   license_keys_->ApplyConstraints(dev_hi_res, HDCP_NO_DIGITAL_OUTPUT);
-  any_change = license_keys_->ApplyStatusChange(kKeyStatusUsable,
+  any_change =
-                                               &new_usable_keys);
+      license_keys_->ApplyStatusChange(kKeyStatusUsable, &new_usable_keys);
 
   EXPECT_TRUE(any_change);
   EXPECT_TRUE(new_usable_keys);
@@ -1217,8 +1210,8 @@ TEST_F(LicenseKeysTest, ConstraintChanges) {
 
   // Lo-res device, no HDCP support
   license_keys_->ApplyConstraints(dev_lo_res, HDCP_NONE);
-  any_change = license_keys_->ApplyStatusChange(kKeyStatusUsable,
+  any_change =
-                                               &new_usable_keys);
+      license_keys_->ApplyStatusChange(kKeyStatusUsable, &new_usable_keys);
 
   EXPECT_TRUE(any_change);
   EXPECT_TRUE(new_usable_keys);
@@ -1239,10 +1232,8 @@ TEST_F(LicenseKeysTest, ConstraintChanges) {
   EXPECT_TRUE(license_keys_->MeetsConstraints(ck_NO_HDCP_dual_res));
 
   license_keys_->ExtractKeyStatuses(&key_status_map);
-  ExpectKeyStatusEqual(key_status_map, ck_sw_crypto_NO_HDCP,
+  ExpectKeyStatusEqual(key_status_map, ck_sw_crypto_NO_HDCP, kKeyStatusUsable);
-                       kKeyStatusUsable);
+  ExpectKeyStatusEqual(key_status_map, ck_hw_secure_NO_HDCP, kKeyStatusUsable);
-  ExpectKeyStatusEqual(key_status_map, ck_hw_secure_NO_HDCP,
-                       kKeyStatusUsable);
   ExpectKeyStatusEqual(key_status_map, ck_sw_crypto_HDCP_V2_1,
                        kKeyStatusOutputNotAllowed);
   ExpectKeyStatusEqual(key_status_map, ck_hw_secure_HDCP_V2_1,
@@ -1262,8 +1253,8 @@ TEST_F(LicenseKeysTest, ConstraintChanges) {
 
   // Too-high-res -- all keys rejected
   license_keys_->ApplyConstraints(dev_top_res, HDCP_NONE);
-  any_change = license_keys_->ApplyStatusChange(kKeyStatusUsable,
+  any_change =
-                                               &new_usable_keys);
+      license_keys_->ApplyStatusChange(kKeyStatusUsable, &new_usable_keys);
 
   EXPECT_TRUE(any_change);
   EXPECT_FALSE(new_usable_keys);
@@ -1282,10 +1273,8 @@ TEST_F(LicenseKeysTest, ConstraintChanges) {
   EXPECT_FALSE(license_keys_->MeetsConstraints(ck_NO_HDCP_dual_res));
 
   license_keys_->ExtractKeyStatuses(&key_status_map);
-  ExpectKeyStatusEqual(key_status_map, ck_sw_crypto_NO_HDCP,
+  ExpectKeyStatusEqual(key_status_map, ck_sw_crypto_NO_HDCP, kKeyStatusUsable);
-                       kKeyStatusUsable);
+  ExpectKeyStatusEqual(key_status_map, ck_hw_secure_NO_HDCP, kKeyStatusUsable);
-  ExpectKeyStatusEqual(key_status_map, ck_hw_secure_NO_HDCP,
-                       kKeyStatusUsable);
   ExpectKeyStatusEqual(key_status_map, ck_sw_crypto_HDCP_V2_1,
                        kKeyStatusOutputNotAllowed);
   ExpectKeyStatusEqual(key_status_map, ck_hw_secure_HDCP_V2_1,
@@ -1315,11 +1304,11 @@ struct KeySecurityLevelParams {
 };
 
 KeySecurityLevelParams key_security_level_test_vectors[] = {
-  { kSecurityLevelUninitialized, false, false, false, false, false, false},
+    {kSecurityLevelUninitialized, false, false, false, false, false, false},
-  { kSecurityLevelL1, true, true, true, true, true, true},
+    {kSecurityLevelL1, true, true, true, true, true, true},
-  { kSecurityLevelL2, true, true, true, true, false, false},
+    {kSecurityLevelL2, true, true, true, true, false, false},
-  { kSecurityLevelL3, true, true, true, false, false, false},
+    {kSecurityLevelL3, true, true, true, false, false, false},
-  { kSecurityLevelUnknown, false, false, false, false, false, false},
+    {kSecurityLevelUnknown, false, false, false, false, false, false},
 };
 
 class LicenseKeysSecurityLevelConstraintsTest
@@ -1340,8 +1329,8 @@ TEST_P(LicenseKeysSecurityLevelConstraintsTest, KeyStatusChange) {
   ExpectKeyStatusesEqual(key_status_map, kKeyStatusInternalError);
 
   // change to pending
-  any_change = license_keys_->ApplyStatusChange(kKeyStatusPending,
+  any_change =
-                                                &new_usable_keys);
+      license_keys_->ApplyStatusChange(kKeyStatusPending, &new_usable_keys);
   EXPECT_TRUE(any_change);
   EXPECT_FALSE(new_usable_keys);
   EXPECT_FALSE(license_keys_->CanDecryptContent(ck_sw_crypto));
@@ -1370,8 +1359,8 @@ TEST_P(LicenseKeysSecurityLevelConstraintsTest, KeyStatusChange) {
   ExpectKeyStatusesEqual(key_status_map, kKeyStatusUsableInFuture);
 
   // change to usable
-  any_change = license_keys_->ApplyStatusChange(kKeyStatusUsable,
+  any_change =
-                                                &new_usable_keys);
+      license_keys_->ApplyStatusChange(kKeyStatusUsable, &new_usable_keys);
   EXPECT_TRUE(any_change);
   EXPECT_EQ(config->expect_usable_keys, new_usable_keys);
   EXPECT_EQ(config->expect_can_use_sw_crypto_key,
@@ -1388,25 +1377,25 @@ TEST_P(LicenseKeysSecurityLevelConstraintsTest, KeyStatusChange) {
   license_keys_->ExtractKeyStatuses(&key_status_map);
   EXPECT_EQ(content_key_count_, key_status_map.size());
 
-  EXPECT_EQ(config->expect_can_use_sw_crypto_key
+  EXPECT_EQ(config->expect_can_use_sw_crypto_key ? kKeyStatusUsable
-                ? kKeyStatusUsable : kKeyStatusOutputNotAllowed,
+                                                 : kKeyStatusOutputNotAllowed,
             key_status_map[ck_sw_crypto]);
-  EXPECT_EQ(config->expect_can_use_sw_decode_key
+  EXPECT_EQ(config->expect_can_use_sw_decode_key ? kKeyStatusUsable
-                ? kKeyStatusUsable : kKeyStatusOutputNotAllowed,
+                                                 : kKeyStatusOutputNotAllowed,
             key_status_map[ck_sw_decode]);
-  EXPECT_EQ(config->expect_can_use_hw_crypto_key
+  EXPECT_EQ(config->expect_can_use_hw_crypto_key ? kKeyStatusUsable
-                ? kKeyStatusUsable : kKeyStatusOutputNotAllowed,
+                                                 : kKeyStatusOutputNotAllowed,
             key_status_map[ck_hw_crypto]);
-  EXPECT_EQ(config->expect_can_use_hw_decode_key
+  EXPECT_EQ(config->expect_can_use_hw_decode_key ? kKeyStatusUsable
-                ? kKeyStatusUsable : kKeyStatusOutputNotAllowed,
+                                                 : kKeyStatusOutputNotAllowed,
             key_status_map[ck_hw_decode]);
-  EXPECT_EQ(config->expect_can_use_hw_secure_key
+  EXPECT_EQ(config->expect_can_use_hw_secure_key ? kKeyStatusUsable
-                ? kKeyStatusUsable : kKeyStatusOutputNotAllowed,
+                                                 : kKeyStatusOutputNotAllowed,
             key_status_map[ck_hw_secure]);
 
   // change to usable (again)
-  any_change = license_keys_->ApplyStatusChange(kKeyStatusUsable,
+  any_change =
-                                                &new_usable_keys);
+      license_keys_->ApplyStatusChange(kKeyStatusUsable, &new_usable_keys);
   EXPECT_FALSE(any_change);
   EXPECT_FALSE(new_usable_keys);
   EXPECT_EQ(config->expect_can_use_sw_crypto_key,
@@ -1422,25 +1411,25 @@ TEST_P(LicenseKeysSecurityLevelConstraintsTest, KeyStatusChange) {
 
   license_keys_->ExtractKeyStatuses(&key_status_map);
   EXPECT_EQ(content_key_count_, key_status_map.size());
-  EXPECT_EQ(config->expect_can_use_sw_crypto_key
+  EXPECT_EQ(config->expect_can_use_sw_crypto_key ? kKeyStatusUsable
-                ? kKeyStatusUsable : kKeyStatusOutputNotAllowed,
+                                                 : kKeyStatusOutputNotAllowed,
             key_status_map[ck_sw_crypto]);
-  EXPECT_EQ(config->expect_can_use_sw_decode_key
+  EXPECT_EQ(config->expect_can_use_sw_decode_key ? kKeyStatusUsable
-                ? kKeyStatusUsable : kKeyStatusOutputNotAllowed,
+                                                 : kKeyStatusOutputNotAllowed,
             key_status_map[ck_sw_decode]);
-  EXPECT_EQ(config->expect_can_use_hw_crypto_key
+  EXPECT_EQ(config->expect_can_use_hw_crypto_key ? kKeyStatusUsable
-                ? kKeyStatusUsable : kKeyStatusOutputNotAllowed,
+                                                 : kKeyStatusOutputNotAllowed,
             key_status_map[ck_hw_crypto]);
-  EXPECT_EQ(config->expect_can_use_hw_decode_key
+  EXPECT_EQ(config->expect_can_use_hw_decode_key ? kKeyStatusUsable
-                ? kKeyStatusUsable : kKeyStatusOutputNotAllowed,
+                                                 : kKeyStatusOutputNotAllowed,
             key_status_map[ck_hw_decode]);
-  EXPECT_EQ(config->expect_can_use_hw_secure_key
+  EXPECT_EQ(config->expect_can_use_hw_secure_key ? kKeyStatusUsable
-                ? kKeyStatusUsable : kKeyStatusOutputNotAllowed,
+                                                 : kKeyStatusOutputNotAllowed,
             key_status_map[ck_hw_secure]);
 
   // change to expired
-  any_change = license_keys_->ApplyStatusChange(kKeyStatusExpired,
+  any_change =
-                                                &new_usable_keys);
+      license_keys_->ApplyStatusChange(kKeyStatusExpired, &new_usable_keys);
   EXPECT_TRUE(any_change);
   EXPECT_FALSE(new_usable_keys);
   EXPECT_FALSE(license_keys_->CanDecryptContent(ck_sw_crypto));

libwvdrmengine/cdm/core/test/license_unittest.cpp

@@ -114,10 +114,7 @@ const std::string kLicenseRequestSignature = a2bs_hex(
     "9BEDB6CF3D8713F9E11675DF1F5DB9038DBBECAB9D1683F8722CAF6E18EC8C04AEE5");
 
 const CryptoSession::SupportedCertificateTypes kDefaultSupportedCertTypes = {
-    true,
+    true, true, true};
-    true,
-    true
-  };
 
 const std::string kFakeEntitlementKeyId =
     a2bs_hex("2a538231c616c67143032a645f9c545d");
@@ -125,8 +122,8 @@ const std::string kFakeEntitledKeyId =
     a2bs_hex("f93c7a81e62d4e9a988ff20bca60f52d");
 const std::string kFakeUnpaddedKey =
     a2bs_hex("b2047e7fab08b3a4dac76b7b82e8cd4d");
-const std::string kFakePaddedKey =
+const std::string kFakePaddedKey = a2bs_hex(
-    a2bs_hex("42f804e9ce0fa693692e1c4ffaeb0e14"
+    "42f804e9ce0fa693692e1c4ffaeb0e14"
     "10101010101010101010101010101010");
 const std::string kFakeKeyTooLong =
     a2bs_hex("d4bc8605d662878a46adb2adb6bf3c0b30a54a0c2f");
@@ -136,7 +133,7 @@ const std::string kFakeIv = a2bs_hex("3d515a3ee0be1687080ac59da9e0d69a");
 class MockCryptoSession : public TestCryptoSession {
  public:
   MockCryptoSession(metrics::CryptoMetrics* crypto_metrics)
-      : TestCryptoSession(crypto_metrics) { }
+      : TestCryptoSession(crypto_metrics) {}
   MOCK_METHOD0(IsOpen, bool());
   MOCK_METHOD0(request_id, const std::string&());
   MOCK_METHOD1(UsageInformationSupport, bool(bool*));
@@ -156,7 +153,8 @@ class MockPolicyEngine : public PolicyEngine {
  public:
   MockPolicyEngine(CryptoSession* crypto)
       : PolicyEngine("mock_session_id", nullptr, crypto) {}
-  MOCK_METHOD1(SetEntitledLicenseKeys,
+  MOCK_METHOD1(
+      SetEntitledLicenseKeys,
       void(const std::vector<video_widevine::WidevinePsshData_EntitledKey>&));
 };
 
@@ -176,11 +174,11 @@ class MockInitializationData : public InitializationData {
 }  // namespace
 
 // Protobuf generated classes
-using video_widevine::LicenseRequest_ContentIdentification;
 using video_widevine::ClientIdentification;
 using video_widevine::License;
 using video_widevine::License_KeyContainer;
 using video_widevine::LicenseRequest;
+using video_widevine::LicenseRequest_ContentIdentification;
 using video_widevine::SignedMessage;
 using video_widevine::WidevinePsshData_EntitledKey;
 
@@ -311,8 +309,7 @@ TEST_F(CdmLicenseTest, PrepareKeyRequestValidation) {
   CryptoSession::HdcpCapability max_hdcp_version = HDCP_V2_1;
   uint32_t crypto_session_api_version = 9;
 
-  EXPECT_CALL(*crypto_session_, IsOpen())
+  EXPECT_CALL(*crypto_session_, IsOpen()).WillOnce(Return(true));
-      .WillOnce(Return(true));
   EXPECT_CALL(*crypto_session_, request_id())
       .WillOnce(ReturnRef(kCryptoRequestId));
   EXPECT_CALL(*crypto_session_, UsageInformationSupport(NotNull()))
@@ -334,16 +331,17 @@ TEST_F(CdmLicenseTest, PrepareKeyRequestValidation) {
           DoAll(SetArgPointee<2>(kLicenseRequestSignature), Return(NO_ERROR)));
 
   CreateCdmLicense();
-  EXPECT_TRUE(cdm_license_->Init(
+  EXPECT_TRUE(cdm_license_->Init(kToken, kClientTokenDrmCert, kEmptyString,
-      kToken, kClientTokenDrmCert, kEmptyString, true,
+                                 true, kDefaultServiceCertificate,
-      kDefaultServiceCertificate, crypto_session_, policy_engine_));
+                                 crypto_session_, policy_engine_));
 
   CdmAppParameterMap app_parameters;
   CdmKeyMessage signed_request;
   std::string server_url;
-  EXPECT_EQ(cdm_license_->PrepareKeyRequest(
+  EXPECT_EQ(cdm_license_->PrepareKeyRequest(*init_data_, kLicenseTypeStreaming,
-      *init_data_, kLicenseTypeStreaming, app_parameters,
+                                            app_parameters, &signed_request,
-      &signed_request, &server_url), KEY_MESSAGE);
+                                            &server_url),
+            KEY_MESSAGE);
 
   EXPECT_TRUE(!signed_request.empty());
 
@@ -363,16 +361,16 @@ TEST_F(CdmLicenseTest, PrepareKeyRequestValidation) {
 
   // Verify Client Identification
   const ClientIdentification& client_id = license_request.client_id();
-  EXPECT_EQ(video_widevine::
+  EXPECT_EQ(
-                ClientIdentification_TokenType_DRM_DEVICE_CERTIFICATE,
+      video_widevine::ClientIdentification_TokenType_DRM_DEVICE_CERTIFICATE,
       client_id.type());
   EXPECT_TRUE(std::equal(client_id.token().begin(), client_id.token().end(),
                          kToken.begin()));
 
   EXPECT_LT(0, client_id.client_info_size());
   for (int i = 0; i < client_id.client_info_size(); ++i) {
-    const ::video_widevine::ClientIdentification_NameValue&
+    const ::video_widevine::ClientIdentification_NameValue& name_value =
-        name_value = client_id.client_info(i);
+        client_id.client_info(i);
     EXPECT_TRUE(!name_value.name().empty());
     EXPECT_TRUE(!name_value.value().empty());
   }
@@ -419,8 +417,7 @@ TEST_F(CdmLicenseTest, PrepareKeyRequestValidation) {
   EXPECT_EQ(::video_widevine::LicenseRequest_RequestType_NEW,
             license_request.type());
   EXPECT_EQ(kLicenseStartTime, license_request.request_time());
-  EXPECT_EQ(video_widevine::VERSION_2_1,
+  EXPECT_EQ(video_widevine::VERSION_2_1, license_request.protocol_version());
-            license_request.protocol_version());
   EXPECT_EQ(kNonce, license_request.key_control_nonce());
 }
 
@@ -431,8 +428,7 @@ TEST_F(CdmLicenseTest, PrepareKeyRequestValidationV15) {
   uint32_t crypto_session_api_version = 15;
   uint32_t resource_rating_tier = RESOURCE_RATING_TIER_LOW;
 
-  EXPECT_CALL(*crypto_session_, IsOpen())
+  EXPECT_CALL(*crypto_session_, IsOpen()).WillOnce(Return(true));
-      .WillOnce(Return(true));
   EXPECT_CALL(*crypto_session_, request_id())
       .WillOnce(ReturnRef(kCryptoRequestId));
   EXPECT_CALL(*crypto_session_, UsageInformationSupport(NotNull()))
@@ -447,8 +443,7 @@ TEST_F(CdmLicenseTest, PrepareKeyRequestValidationV15) {
       .WillRepeatedly(
           DoAll(SetArgPointee<0>(crypto_session_api_version), Return(true)));
   EXPECT_CALL(*crypto_session_, GetResourceRatingTier(NotNull()))
-      .WillOnce(
+      .WillOnce(DoAll(SetArgPointee<0>(resource_rating_tier), Return(true)));
-          DoAll(SetArgPointee<0>(resource_rating_tier), Return(true)));
   EXPECT_CALL(*clock_, GetCurrentTime()).WillOnce(Return(kLicenseStartTime));
   EXPECT_CALL(*crypto_session_, GenerateNonce(NotNull()))
       .WillOnce(DoAll(SetArgPointee<0>(kNonce), Return(NO_ERROR)));
@@ -457,16 +452,17 @@ TEST_F(CdmLicenseTest, PrepareKeyRequestValidationV15) {
           DoAll(SetArgPointee<2>(kLicenseRequestSignature), Return(NO_ERROR)));
 
   CreateCdmLicense();
-  EXPECT_TRUE(cdm_license_->Init(
+  EXPECT_TRUE(cdm_license_->Init(kToken, kClientTokenDrmCert, kEmptyString,
-      kToken, kClientTokenDrmCert, kEmptyString, true,
+                                 true, kDefaultServiceCertificate,
-      kDefaultServiceCertificate, crypto_session_, policy_engine_));
+                                 crypto_session_, policy_engine_));
 
   CdmAppParameterMap app_parameters;
   CdmKeyMessage signed_request;
   std::string server_url;
-  EXPECT_EQ(cdm_license_->PrepareKeyRequest(
+  EXPECT_EQ(cdm_license_->PrepareKeyRequest(*init_data_, kLicenseTypeStreaming,
-      *init_data_, kLicenseTypeStreaming, app_parameters,
+                                            app_parameters, &signed_request,
-      &signed_request, &server_url), KEY_MESSAGE);
+                                            &server_url),
+            KEY_MESSAGE);
 
   EXPECT_TRUE(!signed_request.empty());
 
@@ -486,16 +482,16 @@ TEST_F(CdmLicenseTest, PrepareKeyRequestValidationV15) {
 
   // Verify Client Identification
   const ClientIdentification& client_id = license_request.client_id();
-  EXPECT_EQ(video_widevine::
+  EXPECT_EQ(
-                ClientIdentification_TokenType_DRM_DEVICE_CERTIFICATE,
+      video_widevine::ClientIdentification_TokenType_DRM_DEVICE_CERTIFICATE,
       client_id.type());
   EXPECT_TRUE(std::equal(client_id.token().begin(), client_id.token().end(),
                          kToken.begin()));
 
   EXPECT_LT(0, client_id.client_info_size());
   for (int i = 0; i < client_id.client_info_size(); ++i) {
-    const ::video_widevine::ClientIdentification_NameValue&
+    const ::video_widevine::ClientIdentification_NameValue& name_value =
-        name_value = client_id.client_info(i);
+        client_id.client_info(i);
     EXPECT_TRUE(!name_value.name().empty());
     EXPECT_TRUE(!name_value.value().empty());
   }
@@ -521,8 +517,7 @@ TEST_F(CdmLicenseTest, PrepareKeyRequestValidationV15) {
               ClientIdentification_ClientCapabilities_CertificateKeyType_RSA_2048,
           video_widevine::
               ClientIdentification_ClientCapabilities_CertificateKeyType_RSA_3072));
-  EXPECT_EQ(resource_rating_tier,
+  EXPECT_EQ(resource_rating_tier, client_capabilities.resource_rating_tier());
-            client_capabilities.resource_rating_tier());
 
   // Verify Content Identification
   const LicenseRequest_ContentIdentification& content_id =
@@ -543,17 +538,14 @@ TEST_F(CdmLicenseTest, PrepareKeyRequestValidationV15) {
   EXPECT_EQ(::video_widevine::LicenseRequest_RequestType_NEW,
             license_request.type());
   EXPECT_EQ(kLicenseStartTime, license_request.request_time());
-  EXPECT_EQ(video_widevine::VERSION_2_1,
+  EXPECT_EQ(video_widevine::VERSION_2_1, license_request.protocol_version());
-            license_request.protocol_version());
   EXPECT_EQ(kNonce, license_request.key_control_nonce());
 }
 
 struct EntitledKeyVariant {
   EntitledKeyVariant(const char* name, const std::string& key,
                      bool should_succeed)
-      : name(name),
+      : name(name), key(key), should_succeed(should_succeed) {}
-        key(key),
-        should_succeed(should_succeed) {}
   const std::string name;
   const std::string key;
   const bool should_succeed;
@@ -586,26 +578,22 @@ TEST_P(CdmLicenseEntitledKeyTest, LoadsEntitledKeys) {
   padded_key.set_iv(kFakeIv);
 
   // Set the expected downstream calls
-  EXPECT_CALL(*crypto_session_, IsOpen())
+  EXPECT_CALL(*crypto_session_, IsOpen()).WillOnce(Return(true));
-      .WillOnce(Return(true));
 
   if (variant.should_succeed) {
     EXPECT_CALL(*crypto_session_, LoadEntitledContentKeys(_))
         .WillOnce(Return(KEY_ADDED));
-    EXPECT_CALL(*policy_engine_, SetEntitledLicenseKeys(_))
+    EXPECT_CALL(*policy_engine_, SetEntitledLicenseKeys(_)).Times(1);
-      .Times(1);
   } else {
-    EXPECT_CALL(*crypto_session_, LoadEntitledContentKeys(_))
+    EXPECT_CALL(*crypto_session_, LoadEntitledContentKeys(_)).Times(0);
-      .Times(0);
+    EXPECT_CALL(*policy_engine_, SetEntitledLicenseKeys(_)).Times(0);
-    EXPECT_CALL(*policy_engine_, SetEntitledLicenseKeys(_))
-      .Times(0);
   }
 
   // Set up the CdmLicense with the mocks and fake entitlement key
   CreateCdmLicense();
-  EXPECT_TRUE(cdm_license_->Init(
+  EXPECT_TRUE(cdm_license_->Init(kToken, kClientTokenDrmCert, kEmptyString,
-      kToken, kClientTokenDrmCert, kEmptyString, true,
+                                 true, kDefaultServiceCertificate,
-      kDefaultServiceCertificate, crypto_session_, policy_engine_));
+                                 crypto_session_, policy_engine_));
   cdm_license_->set_entitlement_keys(entitlement_license);
 
   // Call the function under test and check its return value
@@ -620,8 +608,7 @@ TEST_P(CdmLicenseEntitledKeyTest, LoadsEntitledKeys) {
 
 INSTANTIATE_TEST_CASE_P(
     EntitledKeyTests, CdmLicenseEntitledKeyTest,
-    Values(
+    Values(EntitledKeyVariant("UnpaddedKey", kFakeUnpaddedKey, true),
-        EntitledKeyVariant("UnpaddedKey", kFakeUnpaddedKey, true),
            EntitledKeyVariant("PaddedKey", kFakePaddedKey, true),
            EntitledKeyVariant("KeyTooLong", kFakeKeyTooLong, true),
            EntitledKeyVariant("KeyTooShort", kFakeKeyTooShort, false)),

libwvdrmengine/cdm/core/test/policy_engine_constraints_unittest.cpp

@@ -10,8 +10,8 @@
 #include "crypto_session.h"
 #include "license.h"
 #include "metrics_collections.h"
-#include "policy_engine.h"
 #include "mock_clock.h"
+#include "policy_engine.h"
 #include "test_base.h"
 #include "test_printers.h"
 #include "wv_cdm_event_listener.h"
@@ -68,7 +68,7 @@ const int64_t kHdcpInterval = 10;
 class HdcpOnlyMockCryptoSession : public TestCryptoSession {
  public:
   HdcpOnlyMockCryptoSession(metrics::CryptoMetrics* crypto_metrics)
-      : TestCryptoSession(crypto_metrics) { }
+      : TestCryptoSession(crypto_metrics) {}
 
   MOCK_METHOD2(GetHdcpCapabilities,
                CdmResponseType(HdcpCapability*, HdcpCapability*));
@@ -88,17 +88,15 @@ class MockCdmEventListener : public WvCdmEventListener {
 
 class PolicyEngineConstraintsTest : public WvCdmTestBase {
  public:
-  PolicyEngineConstraintsTest() :
+  PolicyEngineConstraintsTest() : crypto_session_(&dummy_metrics_) {}
-      crypto_session_(&dummy_metrics_) {
-  }
 
  protected:
   void SetUp() override {
     WvCdmTestBase::SetUp();
     current_time_ = 0;
 
-    policy_engine_.reset(new PolicyEngine(kSessionId, &mock_event_listener_,
+    policy_engine_.reset(
-                                          &crypto_session_));
+        new PolicyEngine(kSessionId, &mock_event_listener_, &crypto_session_));
     InjectMockClock();
 
     SetupLicense();
@@ -194,8 +192,8 @@ class PolicyEngineConstraintsTest : public WvCdmTestBase {
                                bool expected_has_new_usable_key) {
     EXPECT_CALL(mock_event_listener_,
                 OnSessionKeysChange(
-                    kSessionId, UnorderedElementsAre(
+                    kSessionId,
-                                   Pair(kKeyId1, expected_key_status),
+                    UnorderedElementsAre(Pair(kKeyId1, expected_key_status),
                                          Pair(kKeyId2, expected_key_status),
                                          Pair(kKeyId3, expected_key_status),
                                          Pair(kKeyId4, expected_key_status)),
@@ -207,13 +205,12 @@ class PolicyEngineConstraintsTest : public WvCdmTestBase {
                                 const KeyId& k3, CdmKeyStatus expected_3,
                                 const KeyId& k4, CdmKeyStatus expected_4,
                                 bool expected_has_new_usable_key) {
-    EXPECT_CALL(mock_event_listener_,
+    EXPECT_CALL(
+        mock_event_listener_,
         OnSessionKeysChange(
-                    kSessionId, UnorderedElementsAre(
+            kSessionId,
-                                   Pair(k1, expected_1),
+            UnorderedElementsAre(Pair(k1, expected_1), Pair(k2, expected_2),
-                                   Pair(k2, expected_2),
+                                 Pair(k3, expected_3), Pair(k4, expected_4)),
-                                   Pair(k3, expected_3),
-                                   Pair(k4, expected_4)),
             expected_has_new_usable_key));
   }
 
@@ -232,15 +229,13 @@ TEST_F(PolicyEngineConstraintsTest, IsPermissiveWithoutAResolution) {
 
   {
     Sequence key_change;
-    ExpectSessionKeysChanges(kKeyId1, kKeyStatusUsable,
+    ExpectSessionKeysChanges(
-                             kKeyId2, kKeyStatusOutputNotAllowed,
+        kKeyId1, kKeyStatusUsable, kKeyId2, kKeyStatusOutputNotAllowed, kKeyId3,
-                             kKeyId3, kKeyStatusUsable,
+        kKeyStatusUsable, kKeyId4, kKeyStatusOutputNotAllowed, true);
-                             kKeyId4, kKeyStatusOutputNotAllowed, true);
   }
 
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
-          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
                             Return(GET_HDCP_CAPABILITY_FAILED)));
 
   policy_engine_->SetLicense(license_);
@@ -257,24 +252,23 @@ TEST_F(PolicyEngineConstraintsTest, IsPermissiveWithoutAResolution) {
 TEST_F(PolicyEngineConstraintsTest, HandlesResolutionsBasedOnConstraints) {
   {
     Sequence time;
-    for (int i=0; i<4; ++i) {
+    for (int i = 0; i < 4; ++i) {
-      EXPECT_CALL(*mock_clock_, GetCurrentTime()).InSequence(time)
+      EXPECT_CALL(*mock_clock_, GetCurrentTime())
+          .InSequence(time)
           .WillOnce(Return(i * 10));
     }
   }
   {
     Sequence key_change;
     ExpectSessionKeysChange(kKeyStatusUsable, true);
-    ExpectSessionKeysChanges(kKeyId1, kKeyStatusUsable,
+    ExpectSessionKeysChanges(
-                             kKeyId2, kKeyStatusUsable,
+        kKeyId1, kKeyStatusUsable, kKeyId2, kKeyStatusUsable, kKeyId3,
-                             kKeyId3, kKeyStatusOutputNotAllowed,
+        kKeyStatusOutputNotAllowed, kKeyId4, kKeyStatusOutputNotAllowed, false);
-                             kKeyId4, kKeyStatusOutputNotAllowed, false);
   }
   EXPECT_CALL(mock_event_listener_, OnExpirationUpdate(kSessionId, _));
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
       .WillRepeatedly(
-          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), Return(NO_ERROR)));
-                Return(NO_ERROR)));
 
   policy_engine_->SetLicense(license_);
   policy_engine_->NotifyResolution(1, kTargetRes1);
@@ -315,35 +309,28 @@ TEST_F(PolicyEngineConstraintsTest,
 
   {
     Sequence key_change;
-    ExpectSessionKeysChanges(kKeyId1, kKeyStatusUsable,
+    ExpectSessionKeysChanges(
-                             kKeyId2, kKeyStatusOutputNotAllowed,
+        kKeyId1, kKeyStatusUsable, kKeyId2, kKeyStatusOutputNotAllowed, kKeyId3,
-                             kKeyId3, kKeyStatusUsable,
+        kKeyStatusUsable, kKeyId4, kKeyStatusOutputNotAllowed, true);
-                             kKeyId4, kKeyStatusOutputNotAllowed, true);
     EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-        .WillOnce(
+        .WillOnce(DoAll(SetArgPointee<0>(HDCP_V2_2),
-            DoAll(SetArgPointee<0>(HDCP_V2_2),
                         Return(GET_HDCP_CAPABILITY_FAILED)))
-        .WillOnce(
+        .WillOnce(DoAll(SetArgPointee<0>(HDCP_V2_2),
-            DoAll(SetArgPointee<0>(HDCP_V2_2),
                         Return(GET_HDCP_CAPABILITY_FAILED)));
   }
   int64_t start_time = current_time_ + 5;
   {
     InSequence calls;
     EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-        .WillOnce(
+        .WillOnce(DoAll(SetArgPointee<0>(HDCP_V2_2),
-            DoAll(SetArgPointee<0>(HDCP_V2_2),
                         Return(GET_HDCP_CAPABILITY_FAILED)));
     EXPECT_CALL(*mock_clock_, GetCurrentTime())
         .WillOnce(Return(start_time + kHdcpInterval / 2))
         .WillOnce(Return(start_time + kHdcpInterval));
     EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-        .WillOnce(
+        .WillOnce(DoAll(SetArgPointee<0>(HDCP_V2_2),
-            DoAll(SetArgPointee<0>(HDCP_V2_2),
                         Return(GET_HDCP_CAPABILITY_FAILED)))
-        .WillOnce(
+        .WillOnce(DoAll(SetArgPointee<0>(HDCP_V2_2), Return(NO_ERROR)));
-            DoAll(SetArgPointee<0>(HDCP_V2_2),
-                  Return(NO_ERROR)));
   }
 
   policy_engine_->NotifyResolution(1, kTargetRes1);
@@ -354,8 +341,7 @@ TEST_F(PolicyEngineConstraintsTest,
 }
 
 TEST_F(PolicyEngineConstraintsTest, DoesNotRequestHdcpWithoutALicense) {
-  EXPECT_CALL(*mock_clock_, GetCurrentTime())
+  EXPECT_CALL(*mock_clock_, GetCurrentTime()).WillOnce(Return(0));
-      .WillOnce(Return(0));
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _)).Times(0);
 
   policy_engine_->OnTimerEvent();
@@ -364,24 +350,22 @@ TEST_F(PolicyEngineConstraintsTest, DoesNotRequestHdcpWithoutALicense) {
 TEST_F(PolicyEngineConstraintsTest, HandlesConstraintOverridingHdcp) {
   {
     Sequence time;
-    for (int i=0; i<3; ++i) {
+    for (int i = 0; i < 3; ++i) {
-      EXPECT_CALL(*mock_clock_, GetCurrentTime()).InSequence(time)
+      EXPECT_CALL(*mock_clock_, GetCurrentTime())
+          .InSequence(time)
           .WillOnce(Return(i * 10));
     }
   }
   {
     Sequence key_change;
     ExpectSessionKeysChange(kKeyStatusUsable, true);
-    ExpectSessionKeysChanges(kKeyId1, kKeyStatusUsable,
+    ExpectSessionKeysChanges(
-                             kKeyId2, kKeyStatusUsable,
+        kKeyId1, kKeyStatusUsable, kKeyId2, kKeyStatusUsable, kKeyId3,
-                             kKeyId3, kKeyStatusOutputNotAllowed,
+        kKeyStatusOutputNotAllowed, kKeyId4, kKeyStatusOutputNotAllowed, false);
-                             kKeyId4, kKeyStatusOutputNotAllowed, false);
   }
   EXPECT_CALL(mock_event_listener_, OnExpirationUpdate(kSessionId, _));
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_V2), Return(NO_ERROR)));
-          DoAll(SetArgPointee<0>(HDCP_V2),
-                Return(NO_ERROR)));
 
   policy_engine_->SetLicense(license_);
   policy_engine_->NotifyResolution(1, kTargetRes1);
@@ -406,27 +390,24 @@ TEST_F(PolicyEngineConstraintsTest, HandlesConstraintOverridingHdcp) {
 TEST_F(PolicyEngineConstraintsTest, HandlesNoHdcp) {
   {
     Sequence time;
-    for (int i=0; i<3; ++i) {
+    for (int i = 0; i < 3; ++i) {
-      EXPECT_CALL(*mock_clock_, GetCurrentTime()).InSequence(time)
+      EXPECT_CALL(*mock_clock_, GetCurrentTime())
+          .InSequence(time)
           .WillOnce(Return(i * 10));
     }
   }
   {
     Sequence key_change;
-    ExpectSessionKeysChanges(kKeyId1, kKeyStatusUsable,
+    ExpectSessionKeysChanges(
-                             kKeyId2, kKeyStatusOutputNotAllowed,
+        kKeyId1, kKeyStatusUsable, kKeyId2, kKeyStatusOutputNotAllowed, kKeyId3,
-                             kKeyId3, kKeyStatusUsable,
+        kKeyStatusUsable, kKeyId4, kKeyStatusOutputNotAllowed, true);
-                             kKeyId4, kKeyStatusOutputNotAllowed, true);
+    ExpectSessionKeysChanges(
-    ExpectSessionKeysChanges(kKeyId1, kKeyStatusUsable,
+        kKeyId1, kKeyStatusUsable, kKeyId2, kKeyStatusOutputNotAllowed, kKeyId3,
-                             kKeyId2, kKeyStatusOutputNotAllowed,
+        kKeyStatusOutputNotAllowed, kKeyId4, kKeyStatusOutputNotAllowed, false);
-                             kKeyId3, kKeyStatusOutputNotAllowed,
-                             kKeyId4, kKeyStatusOutputNotAllowed, false);
   }
   EXPECT_CALL(mock_event_listener_, OnExpirationUpdate(kSessionId, _));
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NONE), Return(NO_ERROR)));
-          DoAll(SetArgPointee<0>(HDCP_NONE),
-                Return(NO_ERROR)));
 
   policy_engine_->SetLicense(license_);
 
@@ -452,25 +433,24 @@ TEST_F(PolicyEngineConstraintsTest, HandlesNoHdcp) {
 TEST_F(PolicyEngineConstraintsTest, UsesDefaultHdcpWhenResolutionNotSet) {
   {
     Sequence time;
-    for (int i=0; i<2; ++i) {
+    for (int i = 0; i < 2; ++i) {
-      EXPECT_CALL(*mock_clock_, GetCurrentTime()).InSequence(time)
+      EXPECT_CALL(*mock_clock_, GetCurrentTime())
+          .InSequence(time)
           .WillOnce(Return(i * 10));
     }
   }
 
   {
     Sequence key_change;
-    ExpectSessionKeysChanges(kKeyId1, kKeyStatusUsable,
+    ExpectSessionKeysChanges(
-                             kKeyId2, kKeyStatusOutputNotAllowed,
+        kKeyId1, kKeyStatusUsable, kKeyId2, kKeyStatusOutputNotAllowed, kKeyId3,
-                             kKeyId3, kKeyStatusUsable,
+        kKeyStatusUsable, kKeyId4, kKeyStatusOutputNotAllowed, true);
-                             kKeyId4, kKeyStatusOutputNotAllowed, true);
   }
 
   EXPECT_CALL(mock_event_listener_, OnExpirationUpdate(kSessionId, _));
 
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
-          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
                             Return(GET_HDCP_CAPABILITY_FAILED)));
 
   policy_engine_->SetLicense(license_);

libwvdrmengine/cdm/core/test/policy_engine_unittest.cpp

@@ -16,8 +16,8 @@
 #include "policy_engine.h"
 #include "test_base.h"
 #include "test_printers.h"
-#include "wv_cdm_event_listener.h"
 #include "wv_cdm_constants.h"
+#include "wv_cdm_event_listener.h"
 
 namespace wvcdm {
 
@@ -53,8 +53,8 @@ int64_t GetLicenseRenewalDelay(int64_t license_duration) {
 
 class HdcpOnlyMockCryptoSession : public TestCryptoSession {
  public:
-  HdcpOnlyMockCryptoSession(metrics::CryptoMetrics* metrics) :
+  HdcpOnlyMockCryptoSession(metrics::CryptoMetrics* metrics)
-      TestCryptoSession(metrics) {}
+      : TestCryptoSession(metrics) {}
 
   MOCK_METHOD2(GetHdcpCapabilities,
                CdmResponseType(HdcpCapability*, HdcpCapability*));
@@ -80,8 +80,8 @@ class MockCdmEventListener : public WvCdmEventListener {
 using video_widevine::License;
 using video_widevine::License_Policy;
 using video_widevine::LicenseIdentification;
-using video_widevine::STREAMING;
 using video_widevine::OFFLINE;
+using video_widevine::STREAMING;
 
 // gmock methods
 using ::testing::_;
@@ -96,14 +96,13 @@ using ::testing::UnorderedElementsAre;
 
 class PolicyEngineTest : public WvCdmTestBase {
  public:
-  PolicyEngineTest() : crypto_session_(&dummy_metrics_) {
+  PolicyEngineTest() : crypto_session_(&dummy_metrics_) {}
-  }
+
  protected:
   void SetUp() override {
     WvCdmTestBase::SetUp();
     policy_engine_.reset(
-        new PolicyEngine(kSessionId, &mock_event_listener_,
+        new PolicyEngine(kSessionId, &mock_event_listener_, &crypto_session_));
-                         &crypto_session_));
     InjectMockClock();
 
     license_.set_license_start_time(kLicenseStartTime);
@@ -135,8 +134,7 @@ class PolicyEngineTest : public WvCdmTestBase {
 
     ON_CALL(crypto_session_, GetHdcpCapabilities(_, _))
         .WillByDefault(
-          Invoke(
+            Invoke(&crypto_session_,
-              &crypto_session_,
                    &HdcpOnlyMockCryptoSession::DoRealGetHdcpCapabilities));
   }
 
@@ -147,10 +145,10 @@ class PolicyEngineTest : public WvCdmTestBase {
 
   void ExpectSessionKeysChange(CdmKeyStatus expected_key_status,
                                bool expected_has_new_usable_key) {
-    EXPECT_CALL(mock_event_listener_,
+    EXPECT_CALL(
+        mock_event_listener_,
         OnSessionKeysChange(
-                    kSessionId, UnorderedElementsAre(
+            kSessionId, UnorderedElementsAre(Pair(kKeyId, expected_key_status)),
-                                    Pair(kKeyId, expected_key_status)),
             expected_has_new_usable_key));
   }
 
@@ -158,19 +156,20 @@ class PolicyEngineTest : public WvCdmTestBase {
                                bool expected_has_new_usable_key,
                                KeyId expected_keyid) {
     EXPECT_CALL(mock_event_listener_,
-                OnSessionKeysChange(
+                OnSessionKeysChange(kSessionId,
-                    kSessionId, UnorderedElementsAre(
+                                    UnorderedElementsAre(Pair(
-                                    Pair(expected_keyid, expected_key_status)),
+                                        expected_keyid, expected_key_status)),
                                     expected_has_new_usable_key));
   }
 
   void ExpectSessionKeysChange(CdmKeyStatus expected_key1_status,
                                CdmKeyStatus expected_key2_status,
                                bool expected_has_new_usable_key) {
-    EXPECT_CALL(mock_event_listener_,
+    EXPECT_CALL(
+        mock_event_listener_,
         OnSessionKeysChange(
-                    kSessionId, UnorderedElementsAre(
+            kSessionId,
-                                    Pair(kKeyId, expected_key1_status),
+            UnorderedElementsAre(Pair(kKeyId, expected_key1_status),
                                  Pair(kAnotherKeyId, expected_key2_status)),
             expected_has_new_usable_key));
   }
@@ -206,8 +205,7 @@ TEST_F(PolicyEngineTest, PlaybackSuccess_OfflineLicense) {
 
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
       .WillRepeatedly(
-          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), Return(NO_ERROR)));
-                Return(NO_ERROR)));
 
   policy_engine_->SetLicense(license_);
   policy_engine_->BeginDecryption();
@@ -231,8 +229,7 @@ TEST_F(PolicyEngineTest, PlaybackSuccess_EntitlementLicense) {
 
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
       .WillRepeatedly(
-          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
+          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT), Return(NO_ERROR)));
-                Return(NO_ERROR)));
 
   License::KeyContainer* key = license_.mutable_key(0);
   key->set_type(License::KeyContainer::ENTITLEMENT);
@@ -298,8 +295,7 @@ TEST_F(PolicyEngineTest, PlaybackSuccess_StreamingLicense) {
               OnExpirationUpdate(_, kLicenseStartTime + kLowDuration));
 
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
-          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
                             Return(GET_HDCP_CAPABILITY_FAILED)));
 
   policy_engine_->SetLicense(license_);
@@ -321,8 +317,7 @@ TEST_F(PolicyEngineTest, PlaybackFailed_CanPlayFalse) {
   ExpectSessionKeysChange(kKeyStatusExpired, false);
 
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
-          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
                             Return(GET_HDCP_CAPABILITY_FAILED)));
 
   policy_engine_->SetLicense(license_);
@@ -346,8 +341,7 @@ TEST_F(PolicyEngineTest, LicenseExpired_RentalDurationExpiredWithoutPlayback) {
       .WillOnce(Return(kLicenseStartTime + kLowDuration));
 
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
-          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
                             Return(GET_HDCP_CAPABILITY_FAILED)));
 
   InSequence s;
@@ -381,8 +375,7 @@ TEST_F(PolicyEngineTest, PlaybackOk_RentalDurationPassedWithPlayback) {
       .WillOnce(Return(kLicenseStartTime + kLowDuration + 1));
 
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
-          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
                             Return(GET_HDCP_CAPABILITY_FAILED)));
 
   InSequence s;
@@ -416,8 +409,7 @@ TEST_F(PolicyEngineTest, PlaybackFails_PlaybackDurationExpired) {
       .WillOnce(Return(playback_start_time + kPlaybackDuration + 2));
 
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
-          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
                             Return(GET_HDCP_CAPABILITY_FAILED)));
 
   InSequence s;
@@ -453,8 +445,7 @@ TEST_F(PolicyEngineTest, LicenseExpired_LicenseDurationExpiredWithoutPlayback) {
       .WillOnce(Return(kLicenseStartTime + kLowDuration));
 
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
-          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
                             Return(GET_HDCP_CAPABILITY_FAILED)));
 
   InSequence s;
@@ -489,8 +480,7 @@ TEST_F(PolicyEngineTest, PlaybackFails_ExpiryBeforeRenewalDelay_Offline) {
       .WillOnce(Return(kPlaybackStartTime + kPlaybackDuration + 1));
 
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
-          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
                             Return(GET_HDCP_CAPABILITY_FAILED)));
 
   InSequence s;
@@ -529,8 +519,7 @@ TEST_F(PolicyEngineTest, PlaybackFails_ExpiryBeforeRenewalDelay_Streaming) {
       .WillOnce(Return(kLicenseStartTime + kLicenseDuration + 1));
 
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
-          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
                             Return(GET_HDCP_CAPABILITY_FAILED)));
 
   InSequence s;
@@ -564,8 +553,7 @@ TEST_F(PolicyEngineTest, PlaybackOk_RentalDuration0) {
       .WillOnce(Return(kLicenseStartTime + kLicenseDuration + 1));
 
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
-          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
                             Return(GET_HDCP_CAPABILITY_FAILED)));
 
   InSequence s;
@@ -601,8 +589,7 @@ TEST_F(PolicyEngineTest, PlaybackOk_PlaybackDuration0) {
       .WillOnce(Return(kLicenseStartTime + kLicenseDuration + 2));
 
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
-          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
                             Return(GET_HDCP_CAPABILITY_FAILED)));
 
   InSequence s;
@@ -640,8 +627,7 @@ TEST_F(PolicyEngineTest, PlaybackOk_LicenseDuration0) {
       .WillOnce(Return(kPlaybackStartTime + kPlaybackDuration + 1));
 
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
-          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
                             Return(GET_HDCP_CAPABILITY_FAILED)));
 
   InSequence s;
@@ -682,8 +668,7 @@ TEST_F(PolicyEngineTest, PlaybackOk_PlaybackAndRental0) {
               OnExpirationUpdate(_, kLicenseStartTime + kLicenseDuration));
 
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
-          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
                             Return(GET_HDCP_CAPABILITY_FAILED)));
 
   policy_engine_->SetLicense(license_);
@@ -741,8 +726,7 @@ TEST_F(PolicyEngineTest, PlaybackOk_PlaybackAndLicense0_WithPlayback) {
       .WillOnce(Return(kLicenseStartTime + kRentalDuration + 10));
 
   ExpectSessionKeysChange(kKeyStatusUsable, true);
-  EXPECT_CALL(mock_event_listener_,
+  EXPECT_CALL(mock_event_listener_, OnExpirationUpdate(_, 0));
-              OnExpirationUpdate(_, 0));
   EXPECT_CALL(mock_event_listener_,
               OnExpirationUpdate(_, kLicenseStartTime + kRentalDuration));
 
@@ -866,13 +850,11 @@ TEST_F(PolicyEngineTest, PlaybackOk_Durations0) {
   EXPECT_CALL(mock_event_listener_, OnExpirationUpdate(_, NEVER_EXPIRES));
 
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
-          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
                             Return(GET_HDCP_CAPABILITY_FAILED)));
 
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
-          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
                             Return(GET_HDCP_CAPABILITY_FAILED)));
 
   policy_engine_->SetLicense(license_);
@@ -894,8 +876,7 @@ TEST_F(PolicyEngineTest, PlaybackOk_LicenseWithFutureStartTime) {
       .WillOnce(Return(kPlaybackStartTime));
 
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
-          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
                             Return(GET_HDCP_CAPABILITY_FAILED)));
 
   InSequence s;
@@ -933,8 +914,7 @@ TEST_F(PolicyEngineTest, PlaybackFailed_CanRenewFalse) {
       .WillOnce(Return(kPlaybackStartTime + kPlaybackDuration + 1));
 
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
-          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
                             Return(GET_HDCP_CAPABILITY_FAILED)));
 
   InSequence s;
@@ -979,8 +959,7 @@ TEST_F(PolicyEngineTest, PlaybackOk_RenewSuccess) {
                        kLicenseRenewalRetryInterval + 10));
 
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
-          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
                             Return(GET_HDCP_CAPABILITY_FAILED)));
 
   InSequence s;
@@ -1036,8 +1015,7 @@ TEST_F(PolicyEngineTest, PlaybackOk_RenewSuccess_WithFutureStartTime) {
       .WillOnce(Return(kLicenseStartTime + license_renewal_delay + 60));
 
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
-          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
                             Return(GET_HDCP_CAPABILITY_FAILED)));
 
   InSequence s;
@@ -1093,8 +1071,7 @@ TEST_F(PolicyEngineTest, LicenseExpired_RenewFailedVersionNotUpdated) {
       .WillOnce(Return(kLicenseStartTime + kLowDuration + 10));
 
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
-          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
                             Return(GET_HDCP_CAPABILITY_FAILED)));
 
   InSequence s;
@@ -1156,8 +1133,7 @@ TEST_F(PolicyEngineTest, PlaybackFailed_RepeatedRenewFailures) {
       .WillOnce(Return(kLicenseStartTime + kLicenseDuration));
 
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
-          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
                             Return(GET_HDCP_CAPABILITY_FAILED)));
 
   InSequence s;
@@ -1217,8 +1193,7 @@ TEST_F(PolicyEngineTest, PlaybackOk_RenewSuccessAfterExpiry) {
       .WillOnce(Return(kPlaybackStartTime + kPlaybackDuration + 20));
 
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
-          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
                             Return(GET_HDCP_CAPABILITY_FAILED)));
 
   InSequence s;
@@ -1292,8 +1267,7 @@ TEST_F(PolicyEngineTest, PlaybackOk_RenewSuccessAfterFailures) {
       .WillOnce(Return(kLicenseStartTime + license_renewal_delay + 200));
 
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
-          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
                             Return(GET_HDCP_CAPABILITY_FAILED)));
 
   InSequence s;
@@ -1351,8 +1325,7 @@ TEST_F(PolicyEngineTest, PlaybackOk_RenewedWithUsage) {
       .WillOnce(Return(kLicenseStartTime + 40));
 
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
-          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
                             Return(GET_HDCP_CAPABILITY_FAILED)));
 
   InSequence s;
@@ -1414,8 +1387,7 @@ TEST_F(PolicyEngineTest, MultipleKeysInLicense) {
       .WillOnce(Return(kLicenseStartTime + 1));
 
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
-          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
                             Return(GET_HDCP_CAPABILITY_FAILED)));
 
   ExpectSessionKeysChange(kKeyStatusUsable, kKeyStatusUsable, true);
@@ -1441,8 +1413,7 @@ TEST_F(PolicyEngineTest, PlaybackOk_SoftEnforcePlaybackDuration) {
       .WillOnce(Return(kLicenseStartTime + kLicenseDuration + 5));
 
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
-          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
                             Return(GET_HDCP_CAPABILITY_FAILED)));
 
   InSequence seq;
@@ -1479,8 +1450,7 @@ TEST_F(PolicyEngineTest, LicenseExpired_SoftEnforceLoadBeforeExpire) {
       .WillOnce(Return(kPlaybackStartTime + kPlaybackDuration + 10));
 
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
-          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
                             Return(GET_HDCP_CAPABILITY_FAILED)));
 
   InSequence seq;
@@ -1508,8 +1478,7 @@ TEST_F(PolicyEngineTest, LicenseExpired_SoftEnforceLoadAfterExpire) {
       .WillOnce(Return(kPlaybackStartTime + kPlaybackDuration + 10));
 
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
-          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
                             Return(GET_HDCP_CAPABILITY_FAILED)));
 
   InSequence seq;
@@ -1542,8 +1511,7 @@ TEST_F(PolicyEngineTest, PlaybackOk_GracePeriod) {
       .WillOnce(Return(kPlaybackStartTime + kPlaybackDuration + 5));
 
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
-          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
                             Return(GET_HDCP_CAPABILITY_FAILED)));
 
   InSequence seq;
@@ -1586,8 +1554,7 @@ TEST_F(PolicyEngineTest, PlaybackOk_GracePeriodWithLoad) {
       .WillOnce(Return(kNewPlaybackStartTime + kPlaybackDuration + 5));
 
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
-          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
                             Return(GET_HDCP_CAPABILITY_FAILED)));
 
   InSequence seq;
@@ -1629,8 +1596,7 @@ TEST_F(PolicyEngineTest, PlaybackOk_GracePeriodWithExpiredLoad) {
       .WillOnce(Return(kNewPlaybackStartTime));
 
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
-          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
                             Return(GET_HDCP_CAPABILITY_FAILED)));
 
   InSequence seq;
@@ -1661,8 +1627,7 @@ TEST_F(PolicyEngineTest, PlaybackOk_CanStoreGracePeriod) {
       .WillOnce(Return(kPlaybackStartTime + kGracePeriod + 2));
 
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
-          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
                             Return(GET_HDCP_CAPABILITY_FAILED)));
 
   InSequence seq;
@@ -1692,12 +1657,12 @@ struct KeySecurityLevelParams {
 };
 
 KeySecurityLevelParams key_security_test_vectors[] = {
-  { false, License::KeyContainer::HW_SECURE_ALL, true, true, true, true },
+    {false, License::KeyContainer::HW_SECURE_ALL, true, true, true, true},
-  { true, License::KeyContainer::SW_SECURE_CRYPTO, true, true, true, false },
+    {true, License::KeyContainer::SW_SECURE_CRYPTO, true, true, true, false},
-  { true, License::KeyContainer::SW_SECURE_DECODE, true, true, true, false },
+    {true, License::KeyContainer::SW_SECURE_DECODE, true, true, true, false},
-  { true, License::KeyContainer::HW_SECURE_CRYPTO, true, true, false, false },
+    {true, License::KeyContainer::HW_SECURE_CRYPTO, true, true, false, false},
-  { true, License::KeyContainer::HW_SECURE_DECODE, true, false, false, false },
+    {true, License::KeyContainer::HW_SECURE_DECODE, true, false, false, false},
-  { true, License::KeyContainer::HW_SECURE_ALL, true, false, false, false },
+    {true, License::KeyContainer::HW_SECURE_ALL, true, false, false, false},
 };
 
 class PolicyEngineKeySecurityLevelTest
@@ -1705,7 +1670,6 @@ class PolicyEngineKeySecurityLevelTest
       public ::testing::WithParamInterface<KeySecurityLevelParams*> {};
 
 TEST_P(PolicyEngineKeySecurityLevelTest, CanUseKeyForSecurityLevel) {
-
   KeySecurityLevelParams* param = GetParam();
 
   license_.clear_key();
@@ -1747,18 +1711,13 @@ TEST_P(PolicyEngineKeySecurityLevelTest, CanUseKeyForSecurityLevel) {
             policy_engine_->CanUseKeyForSecurityLevel(kKeyId));
 }
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_CASE_P(PolicyEngine, PolicyEngineKeySecurityLevelTest,
-    PolicyEngine, PolicyEngineKeySecurityLevelTest,
                         ::testing::Range(&key_security_test_vectors[0],
                                          &key_security_test_vectors[5]));
 
 class PolicyEngineKeyAllowedUsageTest : public PolicyEngineTest {
  protected:
-  enum KeyFlag {
+  enum KeyFlag { kKeyFlagNull, kKeyFlagFalse, kKeyFlagTrue };
-    kKeyFlagNull,
-    kKeyFlagFalse,
-    kKeyFlagTrue
-  };
 
   static const KeyFlag kEncryptNull = kKeyFlagNull;
   static const KeyFlag kEncryptFalse = kKeyFlagFalse;
@@ -1778,7 +1737,6 @@ class PolicyEngineKeyAllowedUsageTest : public PolicyEngineTest {
   static const KeyFlag kContentClearFalse = kKeyFlagFalse;
   static const KeyFlag kContentClearTrue = kKeyFlagTrue;
 
-
   void ExpectAllowedContentKeySettings(const CdmKeyAllowedUsage& key_usage,
                                        KeyFlag secure, KeyFlag clear,
                                        CdmKeySecurityLevel key_security_level) {
@@ -1854,7 +1812,6 @@ class PolicyEngineKeyAllowedUsageTest : public PolicyEngineTest {
 };
 
 TEST_F(PolicyEngineKeyAllowedUsageTest, AllowedUsageBasic) {
-
   const KeyId kGenericKeyId = "oper_session_key";
 
   license_.clear_key();
@@ -1883,8 +1840,7 @@ TEST_F(PolicyEngineKeyAllowedUsageTest, AllowedUsageBasic) {
       .WillOnce(Return(kLicenseStartTime + 1));
 
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
-          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
                             Return(GET_HDCP_CAPABILITY_FAILED)));
 
   ExpectSessionKeysChange(kKeyStatusUsable, kKeyStatusUsable, true);
@@ -1894,8 +1850,8 @@ TEST_F(PolicyEngineKeyAllowedUsageTest, AllowedUsageBasic) {
 
   ExpectSecureContentKey(kKeyId, kHardwareSecureAll);
   ExpectLessSecureContentKey(kAnotherKeyId, kKeySecurityLevelUnset);
-  ExpectOperatorSessionKey(kGenericKeyId, kEncryptNull, kDecryptNull,
+  ExpectOperatorSessionKey(kGenericKeyId, kEncryptNull, kDecryptNull, kSignTrue,
-                           kSignTrue, kVerifyNull);
+                           kVerifyNull);
 
   CdmKeyAllowedUsage key_usage;
   EXPECT_EQ(KEY_NOT_FOUND_1,
@@ -1903,7 +1859,6 @@ TEST_F(PolicyEngineKeyAllowedUsageTest, AllowedUsageBasic) {
 }
 
 TEST_F(PolicyEngineKeyAllowedUsageTest, AllowedUsageGeneric) {
-
   const KeyId kGenericEncryptKeyId = "oper_session_key_1";
   const KeyId kGenericDecryptKeyId = "oper_session_key_2";
   const KeyId kGenericSignKeyId = "oper_session_key_3";
@@ -1945,8 +1900,7 @@ TEST_F(PolicyEngineKeyAllowedUsageTest, AllowedUsageGeneric) {
       .WillOnce(Return(kLicenseStartTime + 1));
 
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
-          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
                             Return(GET_HDCP_CAPABILITY_FAILED)));
 
   ExpectSessionKeysChange(kKeyStatusUsable, kKeyStatusUsable, true);
@@ -2014,8 +1968,7 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess) {
       .WillOnce(Return(kLicenseStartTime + 100));
 
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
-          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
                             Return(GET_HDCP_CAPABILITY_FAILED)));
 
   policy_engine_->SetLicense(license_);
@@ -2041,8 +1994,7 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_PlaybackNotBegun) {
       .WillOnce(Return(kLicenseStartTime + 200));
 
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
-          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
                             Return(GET_HDCP_CAPABILITY_FAILED)));
 
   policy_engine_->SetLicense(license_);
@@ -2082,8 +2034,7 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_PlaybackBegun) {
       .WillOnce(Return(kLicenseStartTime + 200));
 
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
-          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
                             Return(GET_HDCP_CAPABILITY_FAILED)));
 
   policy_engine_->SetLicense(license_);
@@ -2136,8 +2087,7 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_Offline) {
       .WillOnce(Return(kLicenseStartTime + 300));
 
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
-          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
                             Return(GET_HDCP_CAPABILITY_FAILED)));
 
   policy_engine_->SetLicense(license_);
@@ -2223,8 +2173,7 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_CanPlayFalse) {
       .WillOnce(Return(kLicenseStartTime + 100));
 
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
-          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
                             Return(GET_HDCP_CAPABILITY_FAILED)));
 
   policy_engine_->SetLicense(license_);
@@ -2263,8 +2212,7 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_RentalDurationExpired) {
       .WillOnce(Return(kLicenseStartTime + kLowDuration + 5));
 
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
-          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
                             Return(GET_HDCP_CAPABILITY_FAILED)));
 
   policy_engine_->SetLicense(license_);
@@ -2306,8 +2254,7 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_PlaybackDurationExpired) {
       .WillOnce(Return(playback_start_time + 5 + kLowDuration));
 
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
-          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
                             Return(GET_HDCP_CAPABILITY_FAILED)));
 
   policy_engine_->SetLicense(license_);
@@ -2345,8 +2292,7 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_LicenseDurationExpired) {
       .WillOnce(Return(kLicenseStartTime + kLowDuration + 5));
 
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
-          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
                             Return(GET_HDCP_CAPABILITY_FAILED)));
 
   policy_engine_->SetLicense(license_);
@@ -2388,8 +2334,7 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_RentalDuration0) {
       .WillOnce(Return(kLicenseStartTime + kLowDuration + 5));
 
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
-          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
                             Return(GET_HDCP_CAPABILITY_FAILED)));
 
   policy_engine_->SetLicense(license_);
@@ -2434,8 +2379,7 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_PlaybackDuration0) {
       .WillOnce(Return(kLicenseStartTime + kHighDuration + 5));
 
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
-          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
                             Return(GET_HDCP_CAPABILITY_FAILED)));
 
   policy_engine_->SetLicense(license_);
@@ -2454,8 +2398,7 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_PlaybackDuration0) {
   EXPECT_EQ(QUERY_VALUE_FALSE, query_info[QUERY_KEY_PERSIST_ALLOWED]);
   EXPECT_EQ(QUERY_VALUE_TRUE, query_info[QUERY_KEY_RENEW_ALLOWED]);
 
-  EXPECT_EQ(0,
+  EXPECT_EQ(0, std::stoll(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING]));
-            std::stoll(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING]));
   EXPECT_EQ(LLONG_MAX,
             std::stoll(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING]));
   EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]);
@@ -2472,8 +2415,7 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_PlaybackDuration0) {
   EXPECT_EQ(QUERY_VALUE_FALSE, query_info[QUERY_KEY_PERSIST_ALLOWED]);
   EXPECT_EQ(QUERY_VALUE_TRUE, query_info[QUERY_KEY_RENEW_ALLOWED]);
 
-  EXPECT_EQ(0,
+  EXPECT_EQ(0, std::stoll(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING]));
-            std::stoll(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING]));
   EXPECT_EQ(LLONG_MAX,
             std::stoll(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING]));
   EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]);
@@ -2491,8 +2433,7 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_LicenseDuration0) {
       .WillOnce(Return(kPlaybackStartTime + kPlaybackDuration + 5));
 
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
-          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
                             Return(GET_HDCP_CAPABILITY_FAILED)));
 
   policy_engine_->SetLicense(license_);
@@ -2566,7 +2507,8 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_PlaybackAndRental0) {
   EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]);
 }
 
-TEST_F(PolicyEngineQueryTest, QuerySuccess_PlaybackAndLicense0_WithoutPlayback) {
+TEST_F(PolicyEngineQueryTest,
+       QuerySuccess_PlaybackAndLicense0_WithoutPlayback) {
   License_Policy* policy = license_.mutable_policy();
   policy->set_rental_duration_seconds(kRentalDuration);
   policy->set_playback_duration_seconds(kDurationUnlimited);
@@ -2793,8 +2735,7 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_RentalAndLicense0_WithPlayback) {
 
   EXPECT_EQ(LLONG_MAX,
             std::stoll(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING]));
-  EXPECT_EQ(10,
+  EXPECT_EQ(10, std::stoll(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING]));
-            std::stoll(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING]));
   EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]);
 
   policy_engine_->OnTimerEvent();
@@ -2808,10 +2749,8 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_RentalAndLicense0_WithPlayback) {
   EXPECT_EQ(QUERY_VALUE_FALSE, query_info[QUERY_KEY_PERSIST_ALLOWED]);
   EXPECT_EQ(QUERY_VALUE_TRUE, query_info[QUERY_KEY_RENEW_ALLOWED]);
 
-  EXPECT_EQ(0,
+  EXPECT_EQ(0, std::stoll(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING]));
-            std::stoll(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING]));
+  EXPECT_EQ(0, std::stoll(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING]));
-  EXPECT_EQ(0,
-            std::stoll(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING]));
   EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]);
 }
 
@@ -2830,8 +2769,7 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_Durations0) {
       .WillOnce(Return(kLicenseStartTime + kHighDuration + 15));
 
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
-          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
                             Return(GET_HDCP_CAPABILITY_FAILED)));
 
   policy_engine_->SetLicense(license_);
@@ -2868,8 +2806,7 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_LicenseWithFutureStartTime) {
       .WillOnce(Return(kLicenseStartTime + 25));
 
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
-          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
                             Return(GET_HDCP_CAPABILITY_FAILED)));
 
   policy_engine_->SetLicense(license_);
@@ -2924,8 +2861,7 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_Renew) {
                        kLicenseRenewalRetryInterval + 15));
 
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
-          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
                             Return(GET_HDCP_CAPABILITY_FAILED)));
 
   policy_engine_->SetLicense(license_);
@@ -2982,8 +2918,7 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_RenewWithFutureStartTime) {
                        kLicenseRenewalRetryInterval + 40));
 
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
-          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
                             Return(GET_HDCP_CAPABILITY_FAILED)));
 
   policy_engine_->SetLicense(license_);
@@ -3062,8 +2997,7 @@ TEST_F(PolicyEngineTest, SetLicenseForReleaseAfterSetLicense) {
               OnExpirationUpdate(_, kPlaybackStartTime + kPlaybackDuration));
 
   EXPECT_CALL(crypto_session_, GetHdcpCapabilities(_, _))
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
-          DoAll(SetArgPointee<0>(HDCP_NO_DIGITAL_OUTPUT),
                             Return(GET_HDCP_CAPABILITY_FAILED)));
 
   policy_engine_->SetLicense(license_);

libwvdrmengine/cdm/core/test/test_base.cpp

@@ -65,7 +65,8 @@ void show_menu(char* prog_name) {
             << std::endl;
 
   std::cout << "  --service_certificate=<cert>" << std::endl;
-  std::cout << "    configure the signed license service certificate" << std::endl;
+  std::cout << "    configure the signed license service certificate"
+            << std::endl;
   std::cout << "    Specify the SignedDeviceCertificate (from "
             << "device_certificate.proto) " << std::endl;
   std::cout << "    in hex format." << std::endl;
@@ -77,11 +78,14 @@ void show_menu(char* prog_name) {
   std::cout << "      adb push run_request_license_test.sh /system/bin"
             << std::endl;
   std::cout << "      adb shell sh /system/bin/run_request_license_test.sh"
-            << std::endl << std::endl;
+            << std::endl
+            << std::endl;
 
   std::cout << "  --provisioning_certificate=<cert>" << std::endl;
-  std::cout << "    configure the signed provisioning service certificate" << std::endl
+  std::cout << "    configure the signed provisioning service certificate"
-            << "    in hex" << std::endl << std::endl;
+            << std::endl
+            << "    in hex" << std::endl
+            << std::endl;
 
   std::cout << "  --license_server_url=<url>" << std::endl;
   std::cout << "    configure the license server url, please include http[s]"
@@ -89,7 +93,8 @@ void show_menu(char* prog_name) {
             << std::endl;
 
   std::cout << "  --provisioning_server_url=<url>" << std::endl;
-  std::cout << "    configure the provisioning server url, please include http[s]"
+  std::cout
+      << "    configure the provisioning server url, please include http[s]"
       << "    in the url" << std::endl
       << std::endl;
 }
@@ -391,7 +396,7 @@ void WvCdmTestBase::EnsureProvisioned() {
   ASSERT_EQ(NO_ERROR, cdm_engine.CloseSession(session_id));
 }
 
-bool WvCdmTestBase::Initialize(int argc, char **argv) {
+bool WvCdmTestBase::Initialize(int argc, char** argv) {
   Properties::Init();
   bool is_cast_receiver = false;
   bool force_load_test_keybox = false;  // TODO(fredgc): obsolete. remove.
@@ -411,7 +416,8 @@ bool WvCdmTestBase::Initialize(int argc, char **argv) {
     } else {
       const auto index = arg.find('=');
       if (index == std::string::npos) {
-        std::cerr << "Argument values need to be specified using --arg=foo" << std::endl;
+        std::cerr << "Argument values need to be specified using --arg=foo"
+                  << std::endl;
         show_usage = true;
         break;
       }
@@ -487,9 +493,7 @@ TestLicenseHolder::TestLicenseHolder(CdmEngine* cdm_engine)
       enc_key_(CONTENT_KEY_SIZE, 'e'),
       session_key_(CONTENT_KEY_SIZE, 'f') {}
 
-TestLicenseHolder::~TestLicenseHolder() {
+TestLicenseHolder::~TestLicenseHolder() { CloseSession(); }
-  CloseSession();
-}
 
 void TestLicenseHolder::OpenSession(const std::string& key_system) {
   CdmResponseType status =
@@ -640,8 +644,7 @@ void TestLicenseHolder::SignAndLoadLicense() {
 
   CdmKeySetId key_set_id;
   CdmLicenseType license_type;  // Required for AddKey. Result value ignored.
-  EXPECT_EQ(KEY_ADDED,
+  EXPECT_EQ(KEY_ADDED, cdm_engine_->AddKey(session_id_, response_data,
-            cdm_engine_->AddKey(session_id_, response_data,
                                            &license_type, &key_set_id));
 }
 

libwvdrmengine/cdm/core/test/url_request.cpp

@@ -82,7 +82,7 @@ UrlRequest::UrlRequest(const std::string& url)
 UrlRequest::~UrlRequest() {}
 
 void UrlRequest::Reconnect() {
-  for(uint32_t i = 0; i < kMaxConnectAttempts && !is_connected_; ++i) {
+  for (uint32_t i = 0; i < kMaxConnectAttempts && !is_connected_; ++i) {
     socket_.CloseSocket();
     if (socket_.Connect(kConnectTimeoutMs)) {
       is_connected_ = true;

libwvdrmengine/cdm/core/test/usage_table_header_unittest.cpp

@@ -216,8 +216,8 @@ void InitVectorConstants() {
   }
 }
 
-void ToVector(std::vector<CdmUsageEntryInfo>& vec,
+void ToVector(std::vector<CdmUsageEntryInfo>& vec, const CdmUsageEntryInfo* arr,
-              const CdmUsageEntryInfo* arr, size_t total_size) {
+              size_t total_size) {
   size_t max = total_size / sizeof(CdmUsageEntryInfo);
   vec.clear();
   for (size_t i = 0; i < max; i++) {
@@ -250,8 +250,7 @@ class MockDeviceFiles : public DeviceFiles {
                     const std::string&, const CdmUsageEntry&, uint32_t));
   MOCK_METHOD2(RetrieveUsageInfo,
                bool(const std::string&, std::vector<CdmUsageData>*));
-  MOCK_METHOD1(ListLicenses,
+  MOCK_METHOD1(ListLicenses, bool(std::vector<std::string>* key_set_ids));
-               bool(std::vector<std::string>* key_set_ids));
   MOCK_METHOD1(ListUsageInfoFiles,
                bool(std::vector<std::string>* usage_info_files));
 
@@ -307,9 +306,7 @@ using ::testing::UnorderedElementsAreArray;
 
 class UsageTableHeaderTest : public WvCdmTestBase {
  public:
-  static void SetUpTestCase() {
+  static void SetUpTestCase() { InitVectorConstants(); }
-    InitVectorConstants();
-  }
 
   // Useful when UsageTableHeader is mocked
   void DeleteEntry(uint32_t usage_entry_number, DeviceFiles*,
@@ -388,10 +385,7 @@ class UsageTableHeaderInitializationTest
     : public UsageTableHeaderTest,
       public ::testing::WithParamInterface<CdmSecurityLevel> {
  public:
-  static void SetUpTestCase() {
+  static void SetUpTestCase() { InitVectorConstants(); }
-    InitVectorConstants();
-  }
-
 };
 
 TEST_P(UsageTableHeaderInitializationTest, CreateUsageTableHeader) {
@@ -400,11 +394,10 @@ TEST_P(UsageTableHeaderInitializationTest, CreateUsageTableHeader) {
                       SetArgPointee<1>(kEmptyUsageEntryInfoVector),
                       Return(false)));
   EXPECT_CALL(*device_files_, ListLicenses(NotNull()))
-      .WillOnce(DoAll(SetArgPointee<0>(kEmptyLicenseList),
+      .WillOnce(DoAll(SetArgPointee<0>(kEmptyLicenseList), Return(false)));
-                      Return(false)));
   EXPECT_CALL(*device_files_, ListUsageInfoFiles(NotNull()))
-      .WillOnce(DoAll(SetArgPointee<0>(kEmptyUsageInfoFilesList),
+      .WillOnce(
-                      Return(false)));
+          DoAll(SetArgPointee<0>(kEmptyUsageInfoFilesList), Return(false)));
   EXPECT_CALL(*crypto_session_, CreateUsageTableHeader(NotNull()))
       .WillOnce(
           DoAll(SetArgPointee<0>(kEmptyUsageTableHeader), Return(NO_ERROR)));
@@ -422,16 +415,15 @@ TEST_P(UsageTableHeaderInitializationTest, Upgrade_UnableToRetrieveLicenses) {
                       SetArgPointee<1>(kEmptyUsageEntryInfoVector),
                       Return(false)));
   EXPECT_CALL(*device_files_, ListLicenses(NotNull()))
-      .WillOnce(DoAll(SetArgPointee<0>(kLicenseList),
+      .WillOnce(DoAll(SetArgPointee<0>(kLicenseList), Return(true)));
-                      Return(true)));
   EXPECT_CALL(*device_files_, ListUsageInfoFiles(NotNull()))
-      .WillOnce(DoAll(SetArgPointee<0>(kEmptyUsageInfoFilesList),
+      .WillOnce(
-                      Return(false)));
+          DoAll(SetArgPointee<0>(kEmptyUsageInfoFilesList), Return(false)));
   EXPECT_CALL(*crypto_session_, CreateUsageTableHeader(NotNull()))
       .WillOnce(
           DoAll(SetArgPointee<0>(kEmptyUsageTableHeader), Return(NO_ERROR)));
   // TODO: Why not being called?
-  //EXPECT_CALL(*device_files_, DeleteAllLicenses()).WillOnce(Return(true));
+  // EXPECT_CALL(*device_files_, DeleteAllLicenses()).WillOnce(Return(true));
   EXPECT_CALL(*device_files_, StoreUsageTableInfo(kEmptyUsageTableHeader,
                                                   kEmptyUsageEntryInfoVector))
       .Times(2)
@@ -448,11 +440,9 @@ TEST_P(UsageTableHeaderInitializationTest, Upgrade_UnableToRetrieveUsageInfo) {
                       SetArgPointee<1>(kEmptyUsageEntryInfoVector),
                       Return(false)));
   EXPECT_CALL(*device_files_, ListLicenses(NotNull()))
-      .WillOnce(DoAll(SetArgPointee<0>(kEmptyLicenseList),
+      .WillOnce(DoAll(SetArgPointee<0>(kEmptyLicenseList), Return(false)));
-                      Return(false)));
   EXPECT_CALL(*device_files_, ListUsageInfoFiles(NotNull()))
-      .WillOnce(DoAll(SetArgPointee<0>(kUsageInfoFileList),
+      .WillOnce(DoAll(SetArgPointee<0>(kUsageInfoFileList), Return(true)));
-                      Return(true)));
   EXPECT_CALL(*crypto_session_, CreateUsageTableHeader(NotNull()))
       .WillOnce(
           DoAll(SetArgPointee<0>(kEmptyUsageTableHeader), Return(NO_ERROR)));
@@ -485,8 +475,7 @@ TEST_P(UsageTableHeaderInitializationTest, 200UsageEntries) {
   usage_entries_200.resize(200);
   EXPECT_CALL(*device_files_, RetrieveUsageTableInfo(NotNull(), NotNull()))
       .WillOnce(DoAll(SetArgPointee<0>(kUsageTableHeader),
-                      SetArgPointee<1>(usage_entries_200),
+                      SetArgPointee<1>(usage_entries_200), Return(true)));
-                          Return(true)));
   EXPECT_CALL(*crypto_session_, LoadUsageTableHeader(kUsageTableHeader))
       .WillOnce(Return(NO_ERROR));
 
@@ -502,8 +491,8 @@ TEST_P(UsageTableHeaderInitializationTest,
 
   SecurityLevel security_level =
       (GetParam() == kSecurityLevelL3) ? kLevel3 : kLevelDefault;
-  EXPECT_CALL(*crypto_session_,
+  EXPECT_CALL(*crypto_session_, Open(security_level))
-              Open(security_level)).WillOnce(Return(NO_ERROR));
+      .WillOnce(Return(NO_ERROR));
   EXPECT_CALL(*crypto_session_, LoadUsageTableHeader(kUsageTableHeader))
       .WillOnce(Return(NO_ERROR));
   EXPECT_CALL(*crypto_session_, CreateUsageTableHeader(NotNull()))
@@ -549,21 +538,19 @@ TEST_P(UsageTableHeaderInitializationTest,
   // Expectations for AddEntry
   uint32_t expect_usage_entry_number = k201UsageEntryInfoVector.size();
   EXPECT_CALL(*crypto_session_, CreateUsageEntry(NotNull()))
-      .WillOnce(DoAll(SetArgPointee<0>(expect_usage_entry_number),
+      .WillOnce(
-                      Return(NO_ERROR)));
+          DoAll(SetArgPointee<0>(expect_usage_entry_number), Return(NO_ERROR)));
-  EXPECT_CALL(*device_files_, StoreUsageTableInfo(kUsageTableHeader,
+  EXPECT_CALL(*device_files_,
-                                                  usage_entries_202))
+              StoreUsageTableInfo(kUsageTableHeader, usage_entries_202))
       .WillOnce(Return(true));
 
   // Expectations for DeleteEntry
   SecurityLevel security_level =
       (GetParam() == kSecurityLevelL3) ? kLevel3 : kLevelDefault;
-  EXPECT_CALL(*crypto_session_,
+  EXPECT_CALL(*crypto_session_, Open(security_level))
-              Open(security_level))
       .Times(2)
       .WillRepeatedly(Return(NO_ERROR));
-  EXPECT_CALL(
+  EXPECT_CALL(*crypto_session_,
-      *crypto_session_,
               ShrinkUsageTableHeader(usage_entries_202.size() - 1, NotNull()))
       .WillOnce(Return(SHRINK_USAGE_TABLER_HEADER_UNKNOWN_ERROR));
 
@@ -585,28 +572,25 @@ TEST_P(UsageTableHeaderInitializationTest,
   // Expectations for AddEntry
   uint32_t expect_usage_entry_number = k201UsageEntryInfoVector.size();
   EXPECT_CALL(*crypto_session_, CreateUsageEntry(NotNull()))
-      .WillOnce(DoAll(SetArgPointee<0>(expect_usage_entry_number),
+      .WillOnce(
-                      Return(NO_ERROR)));
+          DoAll(SetArgPointee<0>(expect_usage_entry_number), Return(NO_ERROR)));
-  EXPECT_CALL(*device_files_, StoreUsageTableInfo(kUsageTableHeader,
+  EXPECT_CALL(*device_files_,
-                                                  usage_entries_202))
+              StoreUsageTableInfo(kUsageTableHeader, usage_entries_202))
       .WillOnce(Return(true));
 
   // Expectations for DeleteEntry
   SecurityLevel security_level =
       (GetParam() == kSecurityLevelL3) ? kLevel3 : kLevelDefault;
 
-  EXPECT_CALL(*crypto_session_,
+  EXPECT_CALL(*crypto_session_, Open(security_level))
-              Open(security_level))
       .Times(2)
       .WillRepeatedly(Return(NO_ERROR));
-  EXPECT_CALL(
+  EXPECT_CALL(*crypto_session_,
-      *crypto_session_,
               ShrinkUsageTableHeader(usage_entries_202.size() - 1, NotNull()))
       .WillOnce(
           DoAll(SetArgPointee<1>(kAnotherUsageTableHeader), Return(NO_ERROR)));
   EXPECT_CALL(*device_files_,
-              StoreUsageTableInfo(
+              StoreUsageTableInfo(kAnotherUsageTableHeader,
-                  kAnotherUsageTableHeader,
                                   SizeIs(k201UsageEntryInfoVector.size())))
       .WillOnce(Return(true));
 
@@ -756,7 +740,7 @@ TEST_F(UsageTableHeaderTest,
   std::vector<CdmUsageEntryInfo> usage_entry_info_vector_at_start =
       k10UsageEntryInfoVector;
 
-  uint32_t usage_entry_number_first_to_be_deleted;  // randomly choosen
+  uint32_t usage_entry_number_first_to_be_deleted;  // randomly chosen
   std::vector<CdmUsageEntryInfo> final_usage_entries;
 
   uint32_t expected_usage_entry_number = k10UsageEntryInfoVector.size() - 1;
@@ -770,8 +754,7 @@ TEST_F(UsageTableHeaderTest,
 
   EXPECT_CALL(*crypto_session_, CreateUsageEntry(NotNull()))
       .WillOnce(Return(INSUFFICIENT_CRYPTO_RESOURCES_3))
-      .WillOnce(
+      .WillOnce(DoAll(SetArgPointee<0>(expected_usage_entry_number),
-          DoAll(SetArgPointee<0>(expected_usage_entry_number),
                       Return(NO_ERROR)));
 
   EXPECT_CALL(*device_files_, StoreUsageTableInfo(kUsageTableHeader, _))
@@ -812,8 +795,8 @@ TEST_F(UsageTableHeaderTest,
   std::vector<CdmUsageEntryInfo> usage_entry_info_vector_at_start =
       k10UsageEntryInfoVector;
 
-  uint32_t usage_entry_number_first_to_be_deleted;  // randomly choosen
+  uint32_t usage_entry_number_first_to_be_deleted;   // randomly chosen
-  uint32_t usage_entry_number_second_to_be_deleted;  // randomly choosen
+  uint32_t usage_entry_number_second_to_be_deleted;  // randomly chosen
   std::vector<CdmUsageEntryInfo> final_usage_entries;
 
   uint32_t expected_usage_entry_number = k10UsageEntryInfoVector.size() - 2;
@@ -831,8 +814,7 @@ TEST_F(UsageTableHeaderTest,
   EXPECT_CALL(*crypto_session_, CreateUsageEntry(NotNull()))
       .WillOnce(Return(INSUFFICIENT_CRYPTO_RESOURCES_3))
       .WillOnce(Return(INSUFFICIENT_CRYPTO_RESOURCES_3))
-      .WillOnce(
+      .WillOnce(DoAll(SetArgPointee<0>(expected_usage_entry_number),
-          DoAll(SetArgPointee<0>(expected_usage_entry_number),
                       Return(NO_ERROR)));
 
   EXPECT_CALL(*device_files_, StoreUsageTableInfo(kUsageTableHeader, _))
@@ -878,9 +860,9 @@ TEST_F(UsageTableHeaderTest, AddEntry_CreateUsageEntryFailsThrice) {
   std::vector<CdmUsageEntryInfo> usage_entry_info_vector_at_start =
       k10UsageEntryInfoVector;
 
-  uint32_t usage_entry_number_first_to_be_deleted;   // randomly choosen
+  uint32_t usage_entry_number_first_to_be_deleted;   // randomly chosen
-  uint32_t usage_entry_number_second_to_be_deleted;  // randomly choosen
+  uint32_t usage_entry_number_second_to_be_deleted;  // randomly chosen
-  uint32_t usage_entry_number_third_to_be_deleted;   // randomly choosen
+  uint32_t usage_entry_number_third_to_be_deleted;   // randomly chosen
   std::vector<CdmUsageEntryInfo> final_usage_entries;
 
   // Setup expectations
@@ -1000,8 +982,7 @@ TEST_F(UsageTableHeaderTest,
   EXPECT_CALL(*mock_usage_table_header,
               DeleteEntry(_, device_files_, NotNull()))
       .Times(1)
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(Invoke(this, &UsageTableHeaderTest::DeleteEntry),
-          DoAll(Invoke(this, &UsageTableHeaderTest::DeleteEntry),
                             Return(NO_ERROR)));
 
   EXPECT_CALL(*crypto_session_,
@@ -1010,10 +991,8 @@ TEST_F(UsageTableHeaderTest,
       .WillOnce(Return(NO_ERROR));
 
   // Now invoke the method under test
-  EXPECT_EQ(NO_ERROR,
+  EXPECT_EQ(NO_ERROR, mock_usage_table_header->LoadEntry(
-            mock_usage_table_header->LoadEntry(
+                          crypto_session_, usage_entry_to_load,
-                crypto_session_,
-                usage_entry_to_load,
                           usage_entry_number_to_load));
 }
 
@@ -1033,8 +1012,7 @@ TEST_F(UsageTableHeaderTest,
   EXPECT_CALL(*mock_usage_table_header,
               DeleteEntry(_, device_files_, NotNull()))
       .Times(2)
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(Invoke(this, &UsageTableHeaderTest::DeleteEntry),
-          DoAll(Invoke(this, &UsageTableHeaderTest::DeleteEntry),
                             Return(NO_ERROR)));
 
   EXPECT_CALL(*crypto_session_,
@@ -1044,10 +1022,8 @@ TEST_F(UsageTableHeaderTest,
       .WillOnce(Return(NO_ERROR));
 
   // Now invoke the method under test
-  EXPECT_EQ(NO_ERROR,
+  EXPECT_EQ(NO_ERROR, mock_usage_table_header->LoadEntry(
-            mock_usage_table_header->LoadEntry(
+                          crypto_session_, usage_entry_to_load,
-                crypto_session_,
-                usage_entry_to_load,
                           usage_entry_number_to_load));
 }
 
@@ -1066,8 +1042,7 @@ TEST_F(UsageTableHeaderTest, LoadEntry_LoadUsageEntryFailsThrice) {
   EXPECT_CALL(*mock_usage_table_header,
               DeleteEntry(_, device_files_, NotNull()))
       .Times(3)
-      .WillRepeatedly(
+      .WillRepeatedly(DoAll(Invoke(this, &UsageTableHeaderTest::DeleteEntry),
-          DoAll(Invoke(this, &UsageTableHeaderTest::DeleteEntry),
                             Return(NO_ERROR)));
 
   EXPECT_CALL(*crypto_session_,
@@ -1076,10 +1051,9 @@ TEST_F(UsageTableHeaderTest, LoadEntry_LoadUsageEntryFailsThrice) {
       .WillRepeatedly(Return(INSUFFICIENT_CRYPTO_RESOURCES_3));
 
   // Now invoke the method under test
-  EXPECT_EQ(INSUFFICIENT_CRYPTO_RESOURCES_3,
+  EXPECT_EQ(
-            mock_usage_table_header->LoadEntry(
+      INSUFFICIENT_CRYPTO_RESOURCES_3,
-                crypto_session_,
+      mock_usage_table_header->LoadEntry(crypto_session_, usage_entry_to_load,
-                usage_entry_to_load,
                                          usage_entry_number_to_load));
 }
 
@@ -2352,8 +2326,7 @@ TEST_F(UsageTableHeaderTest, StaleHeader) {
 
   EXPECT_CALL(*device_files_, RetrieveUsageTableInfo(NotNull(), NotNull()))
       .WillOnce(DoAll(SetArgPointee<0>(kUsageTableHeader),
-                      SetArgPointee<1>(usage_entry_info_vector),
+                      SetArgPointee<1>(usage_entry_info_vector), Return(true)));
-                      Return(true)));
   EXPECT_CALL(*crypto_session_, LoadUsageTableHeader(kUsageTableHeader))
       .WillOnce(Return(LOAD_USAGE_HEADER_GENERATION_SKEW));
   EXPECT_CALL(*crypto_session_, CreateUsageTableHeader(NotNull()))