Support origin filtering when clearing media licenses

Clearing browser data can be done with filters that specify origin
white lists or black lists, so update the code that clears media licenses
to handle a filter if one provided.

BUG=901993
TEST=new browser_test passes

Change-Id: I413703b456479fc8b85916c96eda6df7cbea2550
Reviewed-on: https://chromium-review.googlesource.com/c/1383308Reviewed-by: Nasko Oskov <nasko@chromium.org>
Reviewed-by: Christian Dullweber <dullweber@chromium.org>
Commit-Queue: John Rummell <jrummell@chromium.org>
Cr-Commit-Position: refs/heads/master@{#620007}

chrome/browser/browsing_data/browsing_data_remover_browsertest.cc

@@ -1233,6 +1233,53 @@ IN_PROC_BROWSER_TEST_F(BrowsingDataRemoverBrowserTest,
   EXPECT_EQ(0, GetMediaLicenseCount());
   ExpectCookieTreeModelCount(0);
 }
+
+IN_PROC_BROWSER_TEST_F(BrowsingDataRemoverBrowserTest,
+                       MediaLicenseDeletionWithFilter) {
+  const std::string kMediaLicenseType = "MediaLicense";
+
+  GURL url =
+      embedded_test_server()->GetURL("/browsing_data/media_license.html");
+  ui_test_utils::NavigateToURL(browser(), url);
+
+  EXPECT_EQ(0, GetMediaLicenseCount());
+  EXPECT_FALSE(HasDataForType(kMediaLicenseType));
+
+  SetDataForType(kMediaLicenseType);
+  EXPECT_EQ(1, GetMediaLicenseCount());
+  EXPECT_TRUE(HasDataForType(kMediaLicenseType));
+
+  // Try to remove the Media Licenses using a whitelist that doesn't include
+  // the current URL. Media License should not be deleted.
+  std::unique_ptr<BrowsingDataFilterBuilder> filter_builder =
+      BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::WHITELIST);
+  filter_builder->AddOrigin(
+      url::Origin::CreateFromNormalizedTuple("https", "test-origin", 443));
+  RemoveWithFilterAndWait(
+      content::BrowsingDataRemover::DATA_TYPE_MEDIA_LICENSES,
+      std::move(filter_builder));
+  EXPECT_EQ(1, GetMediaLicenseCount());
+
+  // Now try with a blacklist that includes the current URL. Media License
+  // should not be deleted.
+  filter_builder =
+      BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::BLACKLIST);
+  filter_builder->AddOrigin(url::Origin::Create(url));
+  RemoveWithFilterAndWait(
+      content::BrowsingDataRemover::DATA_TYPE_MEDIA_LICENSES,
+      std::move(filter_builder));
+  EXPECT_EQ(1, GetMediaLicenseCount());
+
+  // Now try with a whitelist that includes the current URL. Media License
+  // should be deleted this time.
+  filter_builder =
+      BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::WHITELIST);
+  filter_builder->AddOrigin(url::Origin::Create(url));
+  RemoveWithFilterAndWait(
+      content::BrowsingDataRemover::DATA_TYPE_MEDIA_LICENSES,
+      std::move(filter_builder));
+  EXPECT_EQ(0, GetMediaLicenseCount());
+}
 #endif  // BUILDFLAG(ENABLE_LIBRARY_CDMS)
 
 const std::vector<std::string> kStorageTypes{

chrome/browser/browsing_data/chrome_browsing_data_remover_delegate.cc

@@ -977,34 +977,42 @@ void ChromeBrowsingDataRemoverDelegate::RemoveEmbedderData(
     base::RecordAction(UserMetricsAction("ClearBrowsingData_ContentLicenses"));
 
 #if BUILDFLAG(ENABLE_PLUGINS)
-    // Will be completed in OnDeauthorizeFlashContentLicensesCompleted()
-    num_pending_tasks_ += 1;
-    if (!pepper_flash_settings_manager_.get()) {
-      pepper_flash_settings_manager_.reset(
-          new PepperFlashSettingsManager(this, profile_));
+    // Flash does not support filtering by domain, so skip this if clearing only
+    // a specified set of sites.
+    if (filter_builder.GetMode() != BrowsingDataFilterBuilder::WHITELIST) {
+      // Will be completed in OnDeauthorizeFlashContentLicensesCompleted()
+      num_pending_tasks_ += 1;
+      if (!pepper_flash_settings_manager_.get()) {
+        pepper_flash_settings_manager_.reset(
+            new PepperFlashSettingsManager(this, profile_));
+      }
+      deauthorize_flash_content_licenses_request_id_ =
+          pepper_flash_settings_manager_->DeauthorizeContentLicenses(prefs);
     }
-    deauthorize_flash_content_licenses_request_id_ =
-        pepper_flash_settings_manager_->DeauthorizeContentLicenses(prefs);
 #endif  // BUILDFLAG(ENABLE_PLUGINS)
 
 #if defined(OS_CHROMEOS)
     // On Chrome OS, delete any content protection platform keys.
-    const user_manager::User* user =
-        chromeos::ProfileHelper::Get()->GetUserByProfile(profile_);
-    if (!user) {
-      LOG(WARNING) << "Failed to find user for current profile.";
-    } else {
-      chromeos::DBusThreadManager::Get()
-          ->GetCryptohomeClient()
-          ->TpmAttestationDeleteKeys(
-              chromeos::attestation::KEY_USER,
-              cryptohome::CreateAccountIdentifierFromAccountId(
-                  user->GetAccountId()),
-              chromeos::attestation::kContentProtectionKeyPrefix,
-              base::BindOnce(
-                  &ChromeBrowsingDataRemoverDelegate::OnClearPlatformKeys,
-                  weak_ptr_factory_.GetWeakPtr(),
-                  CreatePendingTaskCompletionClosure()));
+    // Platform keys do not support filtering by domain, so skip this if
+    // clearing only a specified set of sites.
+    if (filter_builder.GetMode() != BrowsingDataFilterBuilder::WHITELIST) {
+      const user_manager::User* user =
+          chromeos::ProfileHelper::Get()->GetUserByProfile(profile_);
+      if (!user) {
+        LOG(WARNING) << "Failed to find user for current profile.";
+      } else {
+        chromeos::DBusThreadManager::Get()
+            ->GetCryptohomeClient()
+            ->TpmAttestationDeleteKeys(
+                chromeos::attestation::KEY_USER,
+                cryptohome::CreateAccountIdentifierFromAccountId(
+                    user->GetAccountId()),
+                chromeos::attestation::kContentProtectionKeyPrefix,
+                base::BindOnce(
+                    &ChromeBrowsingDataRemoverDelegate::OnClearPlatformKeys,
+                    weak_ptr_factory_.GetWeakPtr(),
+                    CreatePendingTaskCompletionClosure()));
+      }
     }
 #endif  // defined(OS_CHROMEOS)
 

chrome/browser/browsing_data/chrome_browsing_data_remover_delegate.h

@@ -99,9 +99,10 @@ class ChromeBrowsingDataRemoverDelegate
 
     // Datatypes that can be deleted partially per URL / origin / domain,
     // whichever makes sense.
-    FILTERABLE_DATA_TYPES = DATA_TYPE_SITE_DATA |
-                            content::BrowsingDataRemover::DATA_TYPE_CACHE |
-                            content::BrowsingDataRemover::DATA_TYPE_DOWNLOADS,
+    FILTERABLE_DATA_TYPES =
+        DATA_TYPE_SITE_DATA | content::BrowsingDataRemover::DATA_TYPE_CACHE |
+        content::BrowsingDataRemover::DATA_TYPE_DOWNLOADS |
+        content::BrowsingDataRemover::DATA_TYPE_MEDIA_LICENSES,
 
     // Includes all the available remove options. Meant to be used by clients
     // that wish to wipe as much data as possible from a Profile, to make it

content/browser/plugin_private_storage_helper.cc

@@ -30,6 +30,7 @@
 #include "storage/browser/fileapi/file_system_context.h"
 #include "storage/browser/fileapi/isolated_context.h"
 #include "storage/browser/fileapi/obfuscated_file_util.h"
+#include "storage/browser/quota/special_storage_policy.h"
 #include "storage/common/fileapi/file_system_util.h"
 
 namespace content {
@@ -387,6 +388,8 @@ void PluginPrivateDataDeletionHelper::DecrementTaskCount(
 void ClearPluginPrivateDataOnFileTaskRunner(
     scoped_refptr<storage::FileSystemContext> filesystem_context,
     const GURL& storage_origin,
+    const StoragePartition::OriginMatcherFunction& origin_matcher,
+    const scoped_refptr<storage::SpecialStoragePolicy>& special_storage_policy,
     const base::Time begin,
     const base::Time end,
     const base::Closure& callback) {
@@ -413,6 +416,8 @@ void ClearPluginPrivateDataOnFileTaskRunner(
   // If a specific origin is provided, then check that it is in the list
   // returned and remove all the other origins.
   if (!storage_origin.is_empty()) {
+    DCHECK(origin_matcher.is_null()) << "Only 1 of |storage_origin| and "
+                                        "|origin_matcher| should be specified.";
     if (!base::ContainsKey(origins, storage_origin)) {
       // Nothing matches, so nothing to do.
       callback.Run();
@@ -424,6 +429,25 @@ void ClearPluginPrivateDataOnFileTaskRunner(
     origins.insert(storage_origin);
   }
 
+  // If a filter is provided, determine which origins match.
+  if (!origin_matcher.is_null()) {
+    DCHECK(storage_origin.is_empty())
+        << "Only 1 of |storage_origin| and |origin_matcher| should be "
+           "specified.";
+    std::set<GURL> origins_to_check;
+    origins_to_check.swap(origins);
+    for (const auto& origin : origins_to_check) {
+      if (origin_matcher.Run(origin, special_storage_policy.get()))
+        origins.insert(origin);
+    }
+
+    // If no origins matched, there is nothing to do.
+    if (origins.empty()) {
+      callback.Run();
+      return;
+    }
+  }
+
   PluginPrivateDataDeletionHelper* helper = new PluginPrivateDataDeletionHelper(
       std::move(filesystem_context), begin, end, callback);
   helper->CheckOriginsOnFileTaskRunner(origins);

content/browser/plugin_private_storage_helper.h

@@ -12,12 +12,14 @@
 #endif
 
 #include "base/callback_forward.h"
-#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_refptr.h"
 #include "base/time/time.h"
+#include "content/public/browser/storage_partition.h"
 #include "url/gurl.h"
 
 namespace storage {
 class FileSystemContext;
+class SpecialStoragePolicy;
 }
 
 namespace content {
@@ -30,6 +32,8 @@ namespace content {
 void ClearPluginPrivateDataOnFileTaskRunner(
     scoped_refptr<storage::FileSystemContext> filesystem_context,
     const GURL& storage_origin,
+    const StoragePartition::OriginMatcherFunction& origin_matcher,
+    const scoped_refptr<storage::SpecialStoragePolicy>& special_storage_policy,
     const base::Time begin,
     const base::Time end,
     const base::Closure& callback);

content/browser/storage_partition_impl.cc

@@ -1205,10 +1205,11 @@ void StoragePartitionImpl::DataDeletionHelper::ClearDataOnUIThread(
   if (remove_mask_ & REMOVE_DATA_MASK_PLUGIN_PRIVATE_DATA) {
     IncrementTaskCountOnUI();
     filesystem_context->default_file_task_runner()->PostTask(
-        FROM_HERE,
-        base::BindOnce(&ClearPluginPrivateDataOnFileTaskRunner,
-                       base::WrapRefCounted(filesystem_context), storage_origin,
-                       begin, end, std::move(decrement_callback)));
+        FROM_HERE, base::BindOnce(&ClearPluginPrivateDataOnFileTaskRunner,
+                                  base::WrapRefCounted(filesystem_context),
+                                  storage_origin, origin_matcher,
+                                  base::WrapRefCounted(special_storage_policy),
+                                  begin, end, std::move(decrement_callback)));
   }
 #endif  // BUILDFLAG(ENABLE_PLUGINS)