Merge "Check if license exists before calling remove." into udc-widevine-dev

libwvdrmengine/mediadrm/src/WVDrmPlugin.cpp

@@ -1063,29 +1063,42 @@ Status WVDrmPlugin::unprovisionDevice() {
 
 ::ndk::ScopedAStatus WVDrmPlugin::removeOfflineLicense(
     const ::aidl::android::hardware::drm::KeySetId& in_keySetId) {
-  if (!in_keySetId.keySetId.size()) {
+  if (in_keySetId.keySetId.empty()) {
     return toNdkScopedAStatus(Status::BAD_VALUE);
   }
 
   CdmIdentifier identifier;
-  auto status = mCdmIdentifierBuilder.getCdmIdentifier(&identifier);
+  const auto status = mCdmIdentifierBuilder.getCdmIdentifier(&identifier);
   if (status != Status::OK) {
     return toNdkScopedAStatus(status);
   }
 
-  CdmResponseType res(wvcdm::UNKNOWN_ERROR);
+  const std::vector<CdmSecurityLevel> levels = {wvcdm::kSecurityLevelL1,
+                                                wvcdm::kSecurityLevelL3};
+  const CdmKeySetId cdmKeySetId(in_keySetId.keySetId.begin(),
+                                in_keySetId.keySetId.end());
 
-  res = mCDM->RemoveOfflineLicense(
+  for (const CdmSecurityLevel level : levels) {
-      std::string(in_keySetId.keySetId.begin(), in_keySetId.keySetId.end()),
+    std::vector<CdmKeySetId> keySetIds;
-      wvcdm::kSecurityLevelL1, identifier);
+    const CdmResponseType res =
-  if (!isCdmResponseTypeSuccess(res)) {
+        mCDM->ListStoredLicenses(level, identifier, &keySetIds);
-    CdmResponseType res = mCDM->RemoveOfflineLicense(
+    if (!isCdmResponseTypeSuccess(res)) {
-        std::string(in_keySetId.keySetId.begin(), in_keySetId.keySetId.end()),
+      // This could failure for several reasons, but none that are
-        wvcdm::kSecurityLevelL3, identifier);
+      // worth returning to the app at this time.
-    return toNdkScopedAStatus(mapCdmResponseType(res));
+      ALOGW("Failed to list stored licenses: res = %d", static_cast<int>(res));
+      continue;
+    }
+    // Check if exists.
+    if (keySetIds.empty() || std::find(keySetIds.begin(), keySetIds.end(),
+                                       cdmKeySetId) == keySetIds.end()) {
+      // Does not exist for this security level.
+      continue;
+    }
+    return toNdkScopedAStatus(mapCdmResponseType(
+        mCDM->RemoveOfflineLicense(cdmKeySetId, level, identifier)));
   }
-
+  // Could only reach this state if the key set could not be found.
-  return toNdkScopedAStatus(Status::OK);
+  return toNdkScopedAStatus(Status::BAD_VALUE);
 }
 
 ::ndk::ScopedAStatus WVDrmPlugin::getPropertyString(

libwvdrmengine/mediadrm/test/WVDrmPlugin_hal_test.cpp

@@ -2971,13 +2971,78 @@ TEST_F(WVDrmPluginHalTest, GetOfflineLicenseState) {
   ASSERT_EQ(OfflineLicenseState::UNKNOWN, result);
 }
 
-TEST_F(WVDrmPluginHalTest, RemoveOfflineLicense) {
+TEST_F(WVDrmPluginHalTest, RemoveOfflineLicense_L1) {
-  EXPECT_CALL(
+  // Key set to remove.
-      *mCdm, RemoveOfflineLicense(_, kSecurityLevelL1, HasOrigin(EMPTY_ORIGIN)))
+  const CdmKeySetId cdmKeySetId = "ksidDEADBEAF";
-      .Times(1);
+  const KeySetId keySetId{
+      std::vector<uint8_t>(cdmKeySetId.begin(), cdmKeySetId.end())};
+  // Desired key set ID found in L1.
+  const std::vector<CdmKeySetId> cdmKeySetIdsL1 = {"ksid1234", "ksid9876",
+                                                   "ksid9999", cdmKeySetId,
+                                                   "ksidBAD",  "ksidCAFEB0BA"};
 
-  auto ret = mPlugin->removeOfflineLicense(keySetId);
+  EXPECT_CALL(*mCdm, ListStoredLicenses(kSecurityLevelL1, _, NotNull()))
-  EXPECT_TRUE(ret.isOk());
+      .WillOnce(DoAll(SetArgPointee<2>(cdmKeySetIdsL1),
+                      testing::Return(CdmResponseType(wvcdm::NO_ERROR))));
+  // Only call L1.
+  EXPECT_CALL(*mCdm, RemoveOfflineLicense(cdmKeySetId, kSecurityLevelL1, _))
+      .WillOnce(testing::Return(CdmResponseType(wvcdm::NO_ERROR)));
+  EXPECT_CALL(*mCdm, RemoveOfflineLicense(_, kSecurityLevelL3, _)).Times(0);
+
+  const auto status = mPlugin->removeOfflineLicense(keySetId);
+  ASSERT_TRUE(status.isOk());
+}
+
+TEST_F(WVDrmPluginHalTest, RemoveOfflineLicense_L3) {
+  // Key set to remove.
+  const CdmKeySetId cdmKeySetId = "ksidDEADBEAF";
+  const KeySetId keySetId{
+      std::vector<uint8_t>(cdmKeySetId.begin(), cdmKeySetId.end())};
+  // Desired key set ID is not found in L1.
+  const std::vector<CdmKeySetId> cdmKeySetIdsL1 = {"ksid1234", "ksid9876",
+                                                   "ksid9999"};
+  // Desired key set ID found in L3.
+  const std::vector<CdmKeySetId> cdmKeySetIdsL3 = {
+      "ksidDEADC0DE", "ksid1337", cdmKeySetId, "ksidBAD", "ksidCAFEB0BA"};
+
+  EXPECT_CALL(*mCdm, ListStoredLicenses(kSecurityLevelL1, _, NotNull()))
+      .WillOnce(DoAll(SetArgPointee<2>(cdmKeySetIdsL1),
+                      testing::Return(CdmResponseType(wvcdm::NO_ERROR))));
+  EXPECT_CALL(*mCdm, ListStoredLicenses(kSecurityLevelL3, _, NotNull()))
+      .WillOnce(DoAll(SetArgPointee<2>(cdmKeySetIdsL3),
+                      testing::Return(CdmResponseType(wvcdm::NO_ERROR))));
+  // Only call L3.
+  EXPECT_CALL(*mCdm, RemoveOfflineLicense(_, kSecurityLevelL1, _)).Times(0);
+  EXPECT_CALL(*mCdm, RemoveOfflineLicense(cdmKeySetId, kSecurityLevelL3, _))
+      .WillOnce(testing::Return(CdmResponseType(wvcdm::NO_ERROR)));
+
+  const auto status = mPlugin->removeOfflineLicense(keySetId);
+  ASSERT_TRUE(status.isOk());
+}
+
+TEST_F(WVDrmPluginHalTest, RemoveOfflineLicense_NotFound) {
+  // Key set to remove.
+  const CdmKeySetId cdmKeySetId = "ksidDEADBEAF";
+  const KeySetId keySetId{
+      std::vector<uint8_t>(cdmKeySetId.begin(), cdmKeySetId.end())};
+  // Desired key set ID is not found in L1.
+  const std::vector<CdmKeySetId> cdmKeySetIdsL1 = {"ksid1234", "ksid9876",
+                                                   "ksid9999"};
+  // Desired key set ID is not found in L3.
+  const std::vector<CdmKeySetId> cdmKeySetIdsL3 = {"ksidDEADC0DE", "ksid1337",
+                                                   "ksidBAD", "ksidCAFEB0BA"};
+
+  EXPECT_CALL(*mCdm, ListStoredLicenses(kSecurityLevelL1, _, NotNull()))
+      .WillOnce(DoAll(SetArgPointee<2>(cdmKeySetIdsL1),
+                      testing::Return(CdmResponseType(wvcdm::NO_ERROR))));
+  EXPECT_CALL(*mCdm, ListStoredLicenses(kSecurityLevelL3, _, NotNull()))
+      .WillOnce(DoAll(SetArgPointee<2>(cdmKeySetIdsL3),
+                      testing::Return(CdmResponseType(wvcdm::NO_ERROR))));
+  // No call to RemoveOfflineLicense should be made.
+  EXPECT_CALL(*mCdm, RemoveOfflineLicense(_, _, _)).Times(0);
+
+  const auto status = mPlugin->removeOfflineLicense(keySetId);
+  ASSERT_FALSE(status.isOk());
 }
 
 TEST_F(WVDrmPluginHalTest, CanStoreAtscLicense) {