Pass CdmIdentifier to UsageInfo Methods

The methods on WvContentDecryptionModule related to UsageInfo (Secure
Stops) do not work if kDefaultCdmIdentifier has not been provisioned.
This can occur if an app provisions and uses an origin without any app
on that device ever provisioning the default origin. More concerningly,
this will happen 100% of the time on SPOID-using devices, as there is no
way to provision the default identifier on these devices.

The fix is to pass the current identifier to these methods so that they
do not have to use kDefaultCdmIdentifier.

Test: build_and_run_all_unit_tests.sh
Test: WV GTS Tests
Bug: 62431478
Change-Id: I92a8b4acb69c964abe8129bccf2ff48a66c4a9e0

libwvdrmengine/cdm/include/wv_content_decryption_module.h

@@ -99,13 +99,17 @@ class WvContentDecryptionModule : public android::RefBase, public TimerHandler {
 
   // Secure stop related methods
   virtual CdmResponseType GetUsageInfo(const std::string& app_id,
+                                       const CdmIdentifier& identifier,
                                        CdmUsageInfo* usage_info);
   virtual CdmResponseType GetUsageInfo(const std::string& app_id,
                                        const CdmSecureStopId& ssid,
+                                       const CdmIdentifier& identifier,
                                        CdmUsageInfo* usage_info);
-  virtual CdmResponseType ReleaseAllUsageInfo(const std::string& app_id);
+  virtual CdmResponseType ReleaseAllUsageInfo(const std::string& app_id,
+                                              const CdmIdentifier& identifier);
   virtual CdmResponseType ReleaseUsageInfo(
-      const CdmUsageInfoReleaseMessage& message);
+      const CdmUsageInfoReleaseMessage& message,
+      const CdmIdentifier& identifier);
 
   // Accept encrypted buffer and decrypt data.
   // Decryption parameters that need to be specified are

libwvdrmengine/cdm/src/wv_content_decryption_module.cpp

@@ -303,8 +303,9 @@ CdmResponseType WvContentDecryptionModule::Unprovision(
 }
 
 CdmResponseType WvContentDecryptionModule::GetUsageInfo(
-    const std::string& app_id, CdmUsageInfo* usage_info) {
+    const std::string& app_id, const CdmIdentifier& identifier,
-  CdmEngine* cdm_engine = EnsureCdmForIdentifier(kDefaultCdmIdentifier);
+    CdmUsageInfo* usage_info) {
+  CdmEngine* cdm_engine = EnsureCdmForIdentifier(identifier);
   CdmResponseType sts;
   M_TIME(
       sts = cdm_engine->GetUsageInfo(
@@ -319,8 +320,9 @@ CdmResponseType WvContentDecryptionModule::GetUsageInfo(
 CdmResponseType WvContentDecryptionModule::GetUsageInfo(
     const std::string& app_id,
     const CdmSecureStopId& ssid,
+    const CdmIdentifier& identifier,
     CdmUsageInfo* usage_info) {
-  CdmEngine* cdm_engine = EnsureCdmForIdentifier(kDefaultCdmIdentifier);
+  CdmEngine* cdm_engine = EnsureCdmForIdentifier(identifier);
   CdmResponseType sts;
   M_TIME(
       sts = cdm_engine->GetUsageInfo(
@@ -334,8 +336,8 @@ CdmResponseType WvContentDecryptionModule::GetUsageInfo(
 }
 
 CdmResponseType WvContentDecryptionModule::ReleaseAllUsageInfo(
-    const std::string& app_id) {
+    const std::string& app_id, const CdmIdentifier& identifier) {
-  CdmEngine* cdm_engine = EnsureCdmForIdentifier(kDefaultCdmIdentifier);
+  CdmEngine* cdm_engine = EnsureCdmForIdentifier(identifier);
   CdmResponseType sts;
   M_TIME(
       sts = cdm_engine->ReleaseAllUsageInfo(
@@ -347,8 +349,9 @@ CdmResponseType WvContentDecryptionModule::ReleaseAllUsageInfo(
 }
 
 CdmResponseType WvContentDecryptionModule::ReleaseUsageInfo(
-    const CdmUsageInfoReleaseMessage& message) {
+    const CdmUsageInfoReleaseMessage& message,
-  CdmEngine* cdm_engine = EnsureCdmForIdentifier(kDefaultCdmIdentifier);
+    const CdmIdentifier& identifier) {
+  CdmEngine* cdm_engine = EnsureCdmForIdentifier(identifier);
   CdmResponseType sts;
   M_TIME(
       sts = cdm_engine->ReleaseUsageInfo(

libwvdrmengine/cdm/test/cdm_extended_duration_test.cpp

@@ -969,15 +969,17 @@ TEST_F(WvCdmExtendedDurationTest, UsageOverflowTest) {
   uint32_t num_usage_info = 0;
   CdmUsageInfo usage_info;
   CdmUsageInfoReleaseMessage release_msg;
-  CdmResponseType status = decryptor_.GetUsageInfo("", &usage_info);
+  CdmResponseType status = decryptor_.GetUsageInfo(
+      "", kDefaultCdmIdentifier, &usage_info);
   EXPECT_EQ(usage_info.empty() ? NO_ERROR : KEY_MESSAGE, status);
   while (usage_info.size() > 0) {
     for (size_t i = 0; i < usage_info.size(); ++i) {
       release_msg =
           GetUsageInfoResponse(g_license_server, g_client_auth, usage_info[i]);
-      EXPECT_EQ(NO_ERROR, decryptor_.ReleaseUsageInfo(release_msg));
+      EXPECT_EQ(NO_ERROR, decryptor_.ReleaseUsageInfo(release_msg,
+                                                      kDefaultCdmIdentifier));
     }
-    status = decryptor_.GetUsageInfo("", &usage_info);
+    status = decryptor_.GetUsageInfo("", kDefaultCdmIdentifier, &usage_info);
     switch (status) {
       case KEY_MESSAGE: EXPECT_FALSE(usage_info.empty()); break;
       case NO_ERROR: EXPECT_TRUE(usage_info.empty()); break;
@@ -1406,7 +1408,8 @@ TEST_P(WvCdmStreamingUsageReportTest, UsageTest) {
   uint32_t num_usage_info = 0;
   CdmUsageInfo usage_info;
   CdmUsageInfoReleaseMessage release_msg;
-  CdmResponseType status = decryptor_.GetUsageInfo("", &usage_info);
+  CdmResponseType status = decryptor_.GetUsageInfo(
+      "", kDefaultCdmIdentifier, &usage_info);
   EXPECT_EQ(usage_info.empty() ? NO_ERROR : KEY_MESSAGE, status);
   while (usage_info.size() > 0) {
     for (size_t i = 0; i < usage_info.size(); ++i) {
@@ -1416,9 +1419,10 @@ TEST_P(WvCdmStreamingUsageReportTest, UsageTest) {
                              expected_seconds_since_last_playback);
       release_msg =
           GetUsageInfoResponse(g_license_server, g_client_auth, usage_info[i]);
-      EXPECT_EQ(NO_ERROR, decryptor_.ReleaseUsageInfo(release_msg));
+      EXPECT_EQ(NO_ERROR, decryptor_.ReleaseUsageInfo(release_msg,
+                                                      kDefaultCdmIdentifier));
     }
-    status = decryptor_.GetUsageInfo("", &usage_info);
+    status = decryptor_.GetUsageInfo("", kDefaultCdmIdentifier, &usage_info);
     switch (status) {
       case KEY_MESSAGE:
         EXPECT_FALSE(usage_info.empty());

libwvdrmengine/cdm/test/request_license_test.cpp

@@ -2540,7 +2540,8 @@ TEST_P(WvCdmUsageTest, WithClientId) {
   uint32_t num_usage_info = 0;
   CdmUsageInfo usage_info;
   CdmUsageInfoReleaseMessage release_msg;
-  CdmResponseType status = decryptor_.GetUsageInfo(app_id, &usage_info);
+  CdmResponseType status = decryptor_.GetUsageInfo(
+      app_id, kDefaultCdmIdentifier, &usage_info);
   EXPECT_EQ(usage_info.empty() ? NO_ERROR : KEY_MESSAGE, status);
 
   // Validate signed renewal request
@@ -2571,7 +2572,8 @@ TEST_P(WvCdmUsageTest, WithClientId) {
 
   release_msg =
       GetUsageInfoResponse(g_license_server, g_client_auth, usage_info[0]);
-  EXPECT_EQ(NO_ERROR, decryptor_.ReleaseUsageInfo(release_msg));
+  EXPECT_EQ(NO_ERROR, decryptor_.ReleaseUsageInfo(release_msg,
+                                                  kDefaultCdmIdentifier));
 }
 
 INSTANTIATE_TEST_CASE_P(
@@ -2622,20 +2624,23 @@ TEST_F(WvCdmRequestLicenseTest, UsageInfoRetryTest) {
   uint32_t num_usage_info = 0;
   CdmUsageInfo usage_info;
   CdmUsageInfoReleaseMessage release_msg;
-  CdmResponseType status = decryptor_.GetUsageInfo(app_id, &usage_info);
+  CdmResponseType status = decryptor_.GetUsageInfo(
+      app_id, kDefaultCdmIdentifier, &usage_info);
   EXPECT_EQ(usage_info.empty() ? NO_ERROR : KEY_MESSAGE, status);
 
   // Discard and retry to verify usage reports can be generated multiple times
   // before release.
-  status = decryptor_.GetUsageInfo(app_id, &usage_info);
+  status = decryptor_.GetUsageInfo(app_id, kDefaultCdmIdentifier, &usage_info);
   EXPECT_EQ(usage_info.empty() ? NO_ERROR : KEY_MESSAGE, status);
   while (usage_info.size() > 0) {
     for (size_t i = 0; i < usage_info.size(); ++i) {
       release_msg =
           GetUsageInfoResponse(g_license_server, g_client_auth, usage_info[i]);
-      EXPECT_EQ(NO_ERROR, decryptor_.ReleaseUsageInfo(release_msg));
+      EXPECT_EQ(NO_ERROR, decryptor_.ReleaseUsageInfo(release_msg,
+                                                      kDefaultCdmIdentifier));
     }
-    status = decryptor_.GetUsageInfo(app_id, &usage_info);
+    status = decryptor_.GetUsageInfo(
+        app_id, kDefaultCdmIdentifier, &usage_info);
     switch (status) {
       case KEY_MESSAGE:
         EXPECT_FALSE(usage_info.empty());
@@ -2718,15 +2723,19 @@ TEST_P(WvCdmUsageInfoTest, UsageInfo) {
   CdmUsageInfo usage_info;
   CdmUsageInfoReleaseMessage release_msg;
   CdmResponseType status =
-      decryptor_.GetUsageInfo(usage_info_data->app_id, &usage_info);
+      decryptor_.GetUsageInfo(usage_info_data->app_id, kDefaultCdmIdentifier,
+                              &usage_info);
   EXPECT_EQ(usage_info.empty() ? NO_ERROR : KEY_MESSAGE, status);
   while (usage_info.size() > 0) {
     for (size_t i = 0; i < usage_info.size(); ++i) {
       release_msg =
           GetUsageInfoResponse(g_license_server, g_client_auth, usage_info[i]);
-      EXPECT_EQ(NO_ERROR, decryptor_.ReleaseUsageInfo(release_msg));
+      EXPECT_EQ(
+          NO_ERROR,
+          decryptor_.ReleaseUsageInfo(release_msg, kDefaultCdmIdentifier));
     }
-    status = decryptor_.GetUsageInfo(usage_info_data->app_id, &usage_info);
+    status = decryptor_.GetUsageInfo(usage_info_data->app_id,
+                                     kDefaultCdmIdentifier, &usage_info);
     EXPECT_EQ(usage_info.empty() ? NO_ERROR : KEY_MESSAGE, status);
   }
 }
@@ -2795,25 +2804,46 @@ TEST_F(WvCdmRequestLicenseTest, UsageReleaseAllTest) {
   }
 
   CdmUsageInfo usage_info;
-  EXPECT_EQ(KEY_MESSAGE, decryptor_.GetUsageInfo(app_id_empty, &usage_info));
+  EXPECT_EQ(
+      KEY_MESSAGE,
+      decryptor_.GetUsageInfo(app_id_empty, kDefaultCdmIdentifier,
+                              &usage_info));
   EXPECT_TRUE(usage_info.size() > 0);
-  EXPECT_EQ(KEY_MESSAGE,
+  EXPECT_EQ(
-            decryptor_.GetUsageInfo(app_id_not_empty, &usage_info));
+      KEY_MESSAGE,
+      decryptor_.GetUsageInfo(app_id_not_empty, kDefaultCdmIdentifier,
+                              &usage_info));
   EXPECT_TRUE(usage_info.size() > 0);
 
 
-  EXPECT_EQ(NO_ERROR, decryptor_.ReleaseAllUsageInfo(app_id_not_empty));
+  EXPECT_EQ(
+      NO_ERROR,
+      decryptor_.ReleaseAllUsageInfo(app_id_not_empty, kDefaultCdmIdentifier));
 
-  EXPECT_EQ(NO_ERROR, decryptor_.GetUsageInfo(app_id_not_empty, &usage_info));
+  EXPECT_EQ(
+      NO_ERROR,
+      decryptor_.GetUsageInfo(app_id_not_empty, kDefaultCdmIdentifier,
+                              &usage_info));
   EXPECT_TRUE(usage_info.empty());
-  EXPECT_EQ(KEY_MESSAGE, decryptor_.GetUsageInfo(app_id_empty, &usage_info));
+  EXPECT_EQ(
+      KEY_MESSAGE,
+      decryptor_.GetUsageInfo(app_id_empty, kDefaultCdmIdentifier,
+                              &usage_info));
   EXPECT_TRUE(usage_info.size() > 0);
 
-  EXPECT_EQ(NO_ERROR, decryptor_.ReleaseAllUsageInfo(app_id_empty));
+  EXPECT_EQ(
+      NO_ERROR,
+      decryptor_.ReleaseAllUsageInfo(app_id_empty, kDefaultCdmIdentifier));
 
-  EXPECT_EQ(NO_ERROR, decryptor_.GetUsageInfo(app_id_not_empty, &usage_info));
+  EXPECT_EQ(
+      NO_ERROR,
+      decryptor_.GetUsageInfo(app_id_not_empty, kDefaultCdmIdentifier,
+                              &usage_info));
   EXPECT_TRUE(usage_info.empty());
-  EXPECT_EQ(NO_ERROR, decryptor_.GetUsageInfo(app_id_empty, &usage_info));
+  EXPECT_EQ(
+    NO_ERROR,
+    decryptor_.GetUsageInfo(app_id_empty, kDefaultCdmIdentifier,
+                            &usage_info));
   EXPECT_TRUE(usage_info.empty());
 }
 

libwvdrmengine/mediadrm/src/WVDrmPlugin.cpp

@@ -424,7 +424,7 @@ status_t WVDrmPlugin::getSecureStop(const Vector<uint8_t>& ssid,
   CdmUsageInfo cdmUsageInfo;
   CdmSecureStopId cdmSsid(ssid.begin(), ssid.end());
   CdmResponseType res = mCDM->GetUsageInfo(
-      mPropertySet.app_id(), cdmSsid, &cdmUsageInfo);
+      mPropertySet.app_id(), cdmSsid, mCdmIdentifier, &cdmUsageInfo);
   if (isCdmResponseTypeSuccess(res)) {
     secureStop.clear();
     for (CdmUsageInfo::const_iterator iter = cdmUsageInfo.begin();
@@ -442,7 +442,7 @@ status_t WVDrmPlugin::getSecureStop(const Vector<uint8_t>& ssid,
 status_t WVDrmPlugin::getSecureStops(List<Vector<uint8_t> >& secureStops) {
   CdmUsageInfo cdmUsageInfo;
   CdmResponseType res =
-      mCDM->GetUsageInfo(mPropertySet.app_id(), &cdmUsageInfo);
+      mCDM->GetUsageInfo(mPropertySet.app_id(), mCdmIdentifier, &cdmUsageInfo);
   if (isCdmResponseTypeSuccess(res)) {
     secureStops.clear();
     for (CdmUsageInfo::const_iterator iter = cdmUsageInfo.begin();
@@ -457,7 +457,8 @@ status_t WVDrmPlugin::getSecureStops(List<Vector<uint8_t> >& secureStops) {
 }
 
 status_t WVDrmPlugin::releaseAllSecureStops() {
-  CdmResponseType res = mCDM->ReleaseAllUsageInfo(mPropertySet.app_id());
+  CdmResponseType res = mCDM->ReleaseAllUsageInfo(mPropertySet.app_id(),
+                                                  mCdmIdentifier);
   return mapCdmResponseType(res);
 }
 
@@ -466,7 +467,7 @@ status_t WVDrmPlugin::releaseSecureStops(const Vector<uint8_t>& ssRelease) {
     return android::BAD_VALUE;
   }
   CdmUsageInfoReleaseMessage cdmMessage(ssRelease.begin(), ssRelease.end());
-  CdmResponseType res = mCDM->ReleaseUsageInfo(cdmMessage);
+  CdmResponseType res = mCDM->ReleaseUsageInfo(cdmMessage, mCdmIdentifier);
   return mapCdmResponseType(res);
 }
 

libwvdrmengine/mediadrm/src_hidl/WVDrmPlugin.cpp

@@ -533,12 +533,20 @@ Return<void> WVDrmPlugin::getSecureStop(
     return Void();
   }
   const std::vector<uint8_t> id = toVector(secureStopId);
+  SecureStop secureStop;
+
+  CdmIdentifier identifier;
+  status_t status = mCdmIdentifierBuilder.getCdmIdentifier(&identifier);
+  if (status != android::OK) {
+    _hidl_cb(toStatus(status), secureStop);
+    return Void();
+  }
+
   CdmUsageInfo cdmUsageInfo;
   CdmSecureStopId cdmSsId(id.begin(), id.end());
   CdmResponseType res = mCDM->GetUsageInfo(
-      mPropertySet.app_id(), cdmSsId, &cdmUsageInfo);
+      mPropertySet.app_id(), cdmSsId, identifier, &cdmUsageInfo);
 
-  SecureStop secureStop;
   if (isCdmResponseTypeSuccess(res)) {
     std::vector<uint8_t> cdmStopVec;
     for (CdmUsageInfo::const_iterator iter = cdmUsageInfo.begin();
@@ -557,10 +565,18 @@ Return<void> WVDrmPlugin::getSecureStop(
 Return<void> WVDrmPlugin::getSecureStops(getSecureStops_cb _hidl_cb) {
 
   std::list<std::vector<uint8_t> > secureStops;
+  std::vector<SecureStop> secureStopsVec;
+
+  CdmIdentifier identifier;
+  status_t status = mCdmIdentifierBuilder.getCdmIdentifier(&identifier);
+  if (status != android::OK) {
+    _hidl_cb(toStatus(status), toHidlVec(secureStopsVec));
+    return Void();
+  }
 
   CdmUsageInfo cdmUsageInfo;
   CdmResponseType res =
-      mCDM->GetUsageInfo(mPropertySet.app_id(), &cdmUsageInfo);
+      mCDM->GetUsageInfo(mPropertySet.app_id(), identifier, &cdmUsageInfo);
 
   if (isCdmResponseTypeSuccess(res)) {
     secureStops.clear();
@@ -572,7 +588,6 @@ Return<void> WVDrmPlugin::getSecureStops(getSecureStops_cb _hidl_cb) {
     }
   }
 
-  std::vector<SecureStop> secureStopsVec;
   std::list<std::vector<uint8_t> >::iterator iter = secureStops.begin();
   while (iter != secureStops.end()) {
     SecureStop secureStop;
@@ -586,7 +601,14 @@ Return<void> WVDrmPlugin::getSecureStops(getSecureStops_cb _hidl_cb) {
 
 Return<Status> WVDrmPlugin::releaseAllSecureStops() {
 
-  CdmResponseType res = mCDM->ReleaseAllUsageInfo(mPropertySet.app_id());
+  CdmIdentifier identifier;
+  status_t status = mCdmIdentifierBuilder.getCdmIdentifier(&identifier);
+  if (status != android::OK) {
+    return toStatus(status);
+  }
+
+  CdmResponseType res = mCDM->ReleaseAllUsageInfo(mPropertySet.app_id(),
+                                                  identifier);
   return toStatus(mapCdmResponseType(res));
 }
 
@@ -596,9 +618,16 @@ Return<Status> WVDrmPlugin::releaseSecureStop(
   if (!secureStopId.size()) {
     return Status::BAD_VALUE;
   }
+
+  CdmIdentifier identifier;
+  status_t status = mCdmIdentifierBuilder.getCdmIdentifier(&identifier);
+  if (status != android::OK) {
+    return toStatus(status);
+  }
+
   const std::vector<uint8_t> ssRelease = toVector(secureStopId);
   CdmUsageInfoReleaseMessage cdmMessage(ssRelease.begin(), ssRelease.end());
-  CdmResponseType res = mCDM->ReleaseUsageInfo(cdmMessage);
+  CdmResponseType res = mCDM->ReleaseUsageInfo(cdmMessage, identifier);
   return toStatus(mapCdmResponseType(res));
 }
 

libwvdrmengine/mediadrm/test/WVDrmPlugin_test.cpp

@@ -164,17 +164,20 @@ class MockCDM : public WvContentDecryptionModule {
   MOCK_METHOD2(Unprovision, CdmResponseType(CdmSecurityLevel,
                                             const CdmIdentifier&));
 
-  MOCK_METHOD2(GetUsageInfo, CdmResponseType(const std::string&,
-                                             CdmUsageInfo*));
-
   MOCK_METHOD3(GetUsageInfo, CdmResponseType(const std::string&,
-                                             const CdmSecureStopId&,
+                                             const CdmIdentifier&,
                                              CdmUsageInfo*));
 
-  MOCK_METHOD1(ReleaseAllUsageInfo, CdmResponseType(const std::string&));
+  MOCK_METHOD4(GetUsageInfo, CdmResponseType(const std::string&,
+                                             const CdmSecureStopId&,
+                                             const CdmIdentifier&,
+                                             CdmUsageInfo*));
 
-  MOCK_METHOD1(ReleaseUsageInfo,
+  MOCK_METHOD2(ReleaseAllUsageInfo, CdmResponseType(const std::string&,
-      CdmResponseType(const CdmUsageInfoReleaseMessage&));
+                                                    const CdmIdentifier&));
+
+  MOCK_METHOD2(ReleaseUsageInfo,
+      CdmResponseType(const CdmUsageInfoReleaseMessage&, const CdmIdentifier&));
 
   MOCK_METHOD1(IsValidServiceCertificate, bool(const std::string&));
 };
@@ -946,8 +949,8 @@ TEST_F(WVDrmPluginTest, GetsSecureStops) {
   }
 
   const char* app_id = "my_app_id";
-  EXPECT_CALL(*cdm, GetUsageInfo(StrEq(app_id), _))
+  EXPECT_CALL(*cdm, GetUsageInfo(StrEq(app_id), _, _))
-      .WillOnce(DoAll(SetArgPointee<1>(cdmStops),
+      .WillOnce(DoAll(SetArgPointee<2>(cdmStops),
                       testing::Return(wvcdm::NO_ERROR)));
 
   std::list<std::vector<uint8_t> > stops;
@@ -987,7 +990,7 @@ TEST_F(WVDrmPluginTest, ReleasesAllSecureStops) {
   StrictMock<MockCrypto> crypto;
   std::string appPackageName;
 
-  EXPECT_CALL(*cdm, ReleaseAllUsageInfo(StrEq("")))
+  EXPECT_CALL(*cdm, ReleaseAllUsageInfo(StrEq(""), _))
       .Times(1);
 
   WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto, false);
@@ -1015,7 +1018,8 @@ TEST_F(WVDrmPluginTest, ReleasesSecureStop) {
   message.assign(messageRaw, messageRaw + kMessageSize);
 
   EXPECT_CALL(*cdm, ReleaseUsageInfo(ElementsAreArray(messageRaw,
-                                                     kMessageSize)))
+                                                      kMessageSize),
+                                     _))
       .Times(1);
 
   WVDrmPlugin plugin(cdm.get(), appPackageName, &crypto, false);

libwvdrmengine/mediadrm/test/legacy_src/WVDrmPlugin_test.cpp

@@ -82,17 +82,20 @@ class MockCDM : public WvContentDecryptionModule {
   MOCK_METHOD2(Unprovision, CdmResponseType(CdmSecurityLevel,
                                             const CdmIdentifier&));
 
-  MOCK_METHOD2(GetUsageInfo, CdmResponseType(const std::string&,
-                                             CdmUsageInfo*));
-
   MOCK_METHOD3(GetUsageInfo, CdmResponseType(const std::string&,
-                                             const CdmSecureStopId&,
+                                             const CdmIdentifier&,
                                              CdmUsageInfo*));
 
-  MOCK_METHOD1(ReleaseAllUsageInfo, CdmResponseType(const std::string&));
+  MOCK_METHOD4(GetUsageInfo, CdmResponseType(const std::string&,
+                                             const CdmSecureStopId&,
+                                             const CdmIdentifier&,
+                                             CdmUsageInfo*));
 
-  MOCK_METHOD1(ReleaseUsageInfo,
+  MOCK_METHOD2(ReleaseAllUsageInfo, CdmResponseType(const std::string&,
-      CdmResponseType(const CdmUsageInfoReleaseMessage&));
+                                                    const CdmIdentifier&));
+
+  MOCK_METHOD2(ReleaseUsageInfo,
+      CdmResponseType(const CdmUsageInfoReleaseMessage&, const CdmIdentifier&));
 
   MOCK_METHOD1(IsValidServiceCertificate, bool(const std::string&));
 };
@@ -755,8 +758,8 @@ TEST_F(WVDrmPluginTest, GetsSecureStops) {
     cdmStops.push_back(string(stopsRaw[i], stopsRaw[i] + kStopSize));
   }
 
-  EXPECT_CALL(*cdm, GetUsageInfo(StrEq(app_id), _))
+  EXPECT_CALL(*cdm, GetUsageInfo(StrEq(app_id), _, _))
-      .WillOnce(DoAll(SetArgPointee<1>(cdmStops),
+      .WillOnce(DoAll(SetArgPointee<2>(cdmStops),
                       Return(wvcdm::NO_ERROR)));
 
   List<Vector<uint8_t> > stops;
@@ -786,7 +789,7 @@ TEST_F(WVDrmPluginTest, ReleasesAllSecureStops) {
   status_t res = plugin.setPropertyString(String8("appId"), String8(""));
   ASSERT_EQ(OK, res);
 
-  EXPECT_CALL(*cdm, ReleaseAllUsageInfo(StrEq("")))
+  EXPECT_CALL(*cdm, ReleaseAllUsageInfo(StrEq(""), _))
       .Times(1);
 
   res = plugin.releaseAllSecureStops();
@@ -808,7 +811,8 @@ TEST_F(WVDrmPluginTest, ReleasesSecureStops) {
   message.appendArray(messageRaw, kMessageSize);
 
   EXPECT_CALL(*cdm, ReleaseUsageInfo(ElementsAreArray(messageRaw,
-                                                     kMessageSize)))
+                                                      kMessageSize),
+                                     _))
       .Times(1);
 
   status_t res = plugin.releaseSecureStops(message);