Add an OriginFilterBuilder class for [white|black]listing origins.

chrome/browser/browsing_data/browsing_data_remover.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/browsing_data/browsing_data_remover.h"
 
 #include <map>
 #include <set>
 #include <string>
 
@@ skipping 57 matching lines @@
 #include "content/public/browser/user_metrics.h"
 #include "net/base/net_errors.h"
 #include "net/cookies/cookie_store.h"
 #include "net/http/transport_security_state.h"
 #include "net/ssl/channel_id_service.h"
 #include "net/ssl/channel_id_store.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "storage/browser/quota/special_storage_policy.h"
 #include "url/origin.h"
+#include "url/origin_filter.h"
 
 #if BUILDFLAG(ANDROID_JAVA_UI)
 #include "chrome/browser/android/offline_pages/offline_page_model_factory.h"
 #include "chrome/browser/android/webapps/webapp_registry.h"
 #include "chrome/browser/precache/precache_manager_factory.h"
 #include "components/offline_pages/offline_page_feature.h"
 #include "components/offline_pages/offline_page_model.h"
 #include "components/precache/content/precache_manager.h"
 #endif
 
@@ skipping 248 matching lines @@
 
   // crbug.com/140910: Many places were calling this with base::Time() as
   // delete_end, even though they should've used base::Time::Max().
   DCHECK_NE(base::Time(), time_range.end);
 
   SetRemoving(true);
   delete_begin_ = time_range.begin;
   delete_end_ = time_range.end;
   remove_mask_ = remove_mask;
   origin_type_mask_ = origin_type_mask;
-  url::Origin remove_origin(remove_url);
+
+  scoped_ptr<url::OriginFilter> filter = url::OriginFilter::Empty();
+  if (!remove_url.is_empty()) {
+    // Make sure that only URLs representing origins, with no extra components,
+    // are passed to this class.
+    DCHECK_EQ(remove_url, remove_url.GetOrigin());
+
+    std::vector<url::Origin> whitelist;
+    whitelist.push_back(url::Origin(remove_url));
+    filter = url::OriginFilter::AsWhitelist(whitelist);
+  }
 
   PrefService* prefs = profile_->GetPrefs();
   bool may_delete_history = prefs->GetBoolean(
       prefs::kAllowDeletingBrowserHistory);
 
   // All the UI entry points into the BrowsingDataRemover should be disabled,
   // but this will fire if something was missed or added.
   DCHECK(may_delete_history || (remove_mask & REMOVE_NOCHECKS) ||
       (!(remove_mask & REMOVE_HISTORY) && !(remove_mask & REMOVE_DOWNLOADS)));
 
@@ skipping 15 matching lines @@
       BrowsingDataHelper::ALL == (BrowsingDataHelper::UNPROTECTED_WEB |
                                   BrowsingDataHelper::PROTECTED_WEB |
                                   BrowsingDataHelper::EXTENSION),
       "OriginTypeMask has been updated without updating user metrics");
 
   if ((remove_mask & REMOVE_HISTORY) && may_delete_history) {
     history::HistoryService* history_service =
         HistoryServiceFactory::GetForProfile(
             profile_, ServiceAccessType::EXPLICIT_ACCESS);
     if (history_service) {
+      // Selective history deletion is currently done through HistoryUI ->
+      // HistoryBackend -> HistoryService, and that is for individual URLs,
+      // not origins. The code below is currently unused, as the only callsite
+      // supplying |remove_url| is the unittest.
+      // TODO(msramek): Investigate whether history deletion, especially in the
+      // case of web history, understands an origin parameter as the deletion
+      // of all URLs from that origin, or just the URL with empty path.
+      // TODO(msramek): Replace |remove_url| with OriginFilter.
       std::set<GURL> restrict_urls;
       if (!remove_url.is_empty())
         restrict_urls.insert(remove_url);
       content::RecordAction(UserMetricsAction("ClearBrowsingData_History"));
       waiting_for_clear_history_ = true;
 
       history_service->ExpireLocalAndRemoteHistoryBetween(
           WebHistoryServiceFactory::GetForProfile(profile_), restrict_urls,
           delete_begin_, delete_end_,
           base::Bind(&BrowsingDataRemover::OnHistoryDeletionDone,
@@ skipping 160 matching lines @@
         data_reduction_proxy_service->compression_stats()
             ->DeleteBrowsingHistory(delete_begin_, delete_end_);
       }
     }
   }
 
   if ((remove_mask & REMOVE_DOWNLOADS) && may_delete_history) {
     content::RecordAction(UserMetricsAction("ClearBrowsingData_Downloads"));
     content::DownloadManager* download_manager =
         BrowserContext::GetDownloadManager(profile_);
-    if (remove_origin.unique())
-      download_manager->RemoveDownloadsBetween(delete_begin_, delete_end_);
-    else
-      download_manager->RemoveDownloadsByOriginAndTime(
-          remove_origin, delete_begin_, delete_end_);
+    download_manager->RemoveDownloadsByOriginAndTime(
+        filter.get(), delete_begin_, delete_end_);
     DownloadPrefs* download_prefs = DownloadPrefs::FromDownloadManager(
         download_manager);
     download_prefs->SetSaveFilePath(download_prefs->DownloadPath());
   }
 
   uint32_t storage_partition_remove_mask = 0;
 
   // We ignore the REMOVE_COOKIES request if UNPROTECTED_WEB is not set,
   // so that callers who request REMOVE_SITE_DATA with PROTECTED_WEB
   // don't accidentally remove the cookies that are associated with the
@@ skipping 611 matching lines @@
   waiting_for_clear_domain_reliability_monitor_ = false;
   NotifyIfDone();
 }
 
 // static
 BrowsingDataRemover::CallbackSubscription
     BrowsingDataRemover::RegisterOnBrowsingDataRemovedCallback(
         const BrowsingDataRemover::Callback& callback) {
   return GetOnBrowsingDataRemovedCallbacks()->Add(callback);
 }