Support restricting browsing data removal for downloads by origin.

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 49 matching lines @@
 #include "content/public/browser/storage_partition.h"
 #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"
 
 #if defined(OS_ANDROID)
 #include "chrome/browser/precache/precache_manager_factory.h"
 #include "components/precache/content/precache_manager.h"
 #endif
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chromeos/attestation/attestation_constants.h"
 #include "chromeos/dbus/cryptohome_client.h"
@@ skipping 145 matching lines @@
       waiting_for_clear_plugin_data_(false),
       waiting_for_clear_pnacl_cache_(false),
 #if defined(OS_ANDROID)
       waiting_for_clear_precache_history_(false),
 #endif
       waiting_for_clear_storage_partition_data_(false),
 #if defined(ENABLE_WEBRTC)
       waiting_for_clear_webrtc_logs_(false),
 #endif
       remove_mask_(0),
-      remove_origin_(GURL()),
       origin_type_mask_(0),
       storage_partition_for_testing_(NULL) {
   DCHECK(profile);
   // crbug.com/140910: Many places were calling this with base::Time() as
   // delete_end, even though they should've used base::Time::Max(). Work around
   // it here. New code should use base::Time::Max().
   DCHECK(delete_end_ != base::Time());
   if (delete_end_ == base::Time())
     delete_end_ = base::Time::Max();
 }
 
 BrowsingDataRemover::~BrowsingDataRemover() {
   DCHECK(AllDone());
 }
 
 // Static.
 void BrowsingDataRemover::set_removing(bool is_removing) {
   DCHECK(is_removing_ != is_removing);
   is_removing_ = is_removing;
 }
 
 void BrowsingDataRemover::Remove(int remove_mask, int origin_type_mask) {
   RemoveImpl(remove_mask, GURL(), origin_type_mask);
 }
 
 void BrowsingDataRemover::RemoveImpl(int remove_mask,
-                                     const GURL& origin,
+                                     const GURL& remove_url,
                                      int origin_type_mask) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   set_removing(true);
   remove_mask_ = remove_mask;
-  remove_origin_ = origin;
   origin_type_mask_ = origin_type_mask;
+  url::Origin remove_origin(remove_url);
 
   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 16 matching lines @@
                                   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) {
       std::set<GURL> restrict_urls;
-      if (!remove_origin_.is_empty())
-        restrict_urls.insert(remove_origin_);
+      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,
                      base::Unretained(this)),
           &history_task_tracker_);
 
@@ skipping 43 matching lines @@
     // As part of history deletion we also delete the auto-generated keywords.
     TemplateURLService* keywords_model =
         TemplateURLServiceFactory::GetForProfile(profile_);
     if (keywords_model && !keywords_model->loaded()) {
       template_url_sub_ = keywords_model->RegisterOnLoadedCallback(
           base::Bind(&BrowsingDataRemover::OnKeywordsLoaded,
                      base::Unretained(this)));
       keywords_model->Load();
       waiting_for_clear_keyword_data_ = true;
     } else if (keywords_model) {
-      keywords_model->RemoveAutoGeneratedForOriginBetween(remove_origin_,
-          delete_begin_, delete_end_);
+      keywords_model->RemoveAutoGeneratedForOriginBetween(
+          remove_url, delete_begin_, delete_end_);
     }
 
     // The PrerenderManager keeps history of prerendered pages, so clear that.
     // It also may have a prerendered page. If so, the page could be
     // considered to have a small amount of historical information, so delete
     // it, too.
     prerender::PrerenderManager* prerender_manager =
         prerender::PrerenderManagerFactory::GetForProfile(profile_);
     if (prerender_manager) {
       prerender_manager->ClearData(
           prerender::PrerenderManager::CLEAR_PRERENDER_CONTENTS |
           prerender::PrerenderManager::CLEAR_PRERENDER_HISTORY);
     }
 
     // If the caller is removing history for all hosts, then clear ancillary
     // historical information.
-    if (remove_origin_.is_empty()) {
+    if (remove_url.is_empty()) {
       // We also delete the list of recently closed tabs. Since these expire,
       // they can't be more than a day old, so we can simply clear them all.
       TabRestoreService* tab_service =
           TabRestoreServiceFactory::GetForProfile(profile_);
       if (tab_service) {
         tab_service->ClearEntries();
         tab_service->DeleteLastSession();
       }
 
 #if defined(ENABLE_SESSION_SERVICE)
@@ skipping 62 matching lines @@
           base::Bind(&BrowsingDataRemover::OnClearedPrecacheHistory,
                      base::Unretained(this)));
     }
 #endif
   }
 
   if ((remove_mask & REMOVE_DOWNLOADS) && may_delete_history) {
     content::RecordAction(UserMetricsAction("ClearBrowsingData_Downloads"));
     content::DownloadManager* download_manager =
         BrowserContext::GetDownloadManager(profile_);
-    download_manager->RemoveDownloadsBetween(delete_begin_, delete_end_);
+    if (remove_origin.unique())
+      download_manager->RemoveDownloadsBetween(delete_begin_, delete_end_);
+    else
+      download_manager->RemoveDownloadsByOriginAndTime(
+          remove_origin, delete_begin_, delete_end_);
     DownloadPrefs* download_prefs = DownloadPrefs::FromDownloadManager(
         download_manager);
     download_prefs->SetSaveFilePath(download_prefs->DownloadPath());
   }
 
   uint32 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 219 matching lines @@
     if (delete_begin_ == base::Time() ||
         origin_type_mask_ &
           (BrowsingDataHelper::PROTECTED_WEB | BrowsingDataHelper::EXTENSION)) {
       // If we're deleting since the beginning of time, or we're removing
       // protected origins, then remove persistent quota data.
       quota_storage_remove_mask |=
           content::StoragePartition::QUOTA_MANAGED_STORAGE_MASK_PERSISTENT;
     }
 
     storage_partition->ClearData(
-        storage_partition_remove_mask,
-        quota_storage_remove_mask,
-        remove_origin_,
-        base::Bind(&DoesOriginMatchMask, origin_type_mask_),
-        delete_begin_,
+        storage_partition_remove_mask, quota_storage_remove_mask, remove_url,
+        base::Bind(&DoesOriginMatchMask, origin_type_mask_), delete_begin_,
         delete_end_,
         base::Bind(&BrowsingDataRemover::OnClearedStoragePartitionData,
                    base::Unretained(this)));
   }
 
 #if defined(ENABLE_PLUGINS)
   if (remove_mask & REMOVE_CONTENT_LICENSES) {
     content::RecordAction(
         UserMetricsAction("ClearBrowsingData_ContentLicenses"));
 
@@ skipping 420 matching lines @@
   waiting_for_clear_domain_reliability_monitor_ = false;
   NotifyAndDeleteIfDone();
 }
 
 // static
 BrowsingDataRemover::CallbackSubscription
     BrowsingDataRemover::RegisterOnBrowsingDataRemovedCallback(
         const BrowsingDataRemover::Callback& callback) {
   return GetOnBrowsingDataRemovedCallbacks()->Add(callback);
 }