Add origin-based deletion to BrowsingDataRemover

chrome/browser/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_remover.h"
 
 #include <map>
 #include <set>
 
 #include "base/bind.h"
@@ skipping 85 matching lines @@
       cache_(NULL),
       main_context_getter_(profile->GetRequestContext()),
       media_context_getter_(profile->GetRequestContextForMedia()),
       waiting_for_clear_cache_(false),
       waiting_for_clear_cookies_(false),
       waiting_for_clear_history_(false),
       waiting_for_clear_networking_history_(false),
       waiting_for_clear_origin_bound_certs_(false),
       waiting_for_clear_plugin_data_(false),
       waiting_for_clear_quota_managed_data_(false),
-      remove_mask_(0) {
+      remove_mask_(0),
+      remove_origin_(GURL()),
+      remove_protected_(false) {
   DCHECK(profile);
 }
 
 BrowsingDataRemover::BrowsingDataRemover(Profile* profile,
                                          TimePeriod time_period,
                                          base::Time delete_end)
     : profile_(profile),
       quota_manager_(NULL),
       special_storage_policy_(profile->GetExtensionSpecialStoragePolicy()),
       delete_begin_(CalculateBeginDeleteTime(time_period)),
       delete_end_(delete_end),
       next_cache_state_(STATE_NONE),
       cache_(NULL),
       main_context_getter_(profile->GetRequestContext()),
       media_context_getter_(profile->GetRequestContextForMedia()),
       waiting_for_clear_cache_(false),
       waiting_for_clear_cookies_(false),
       waiting_for_clear_history_(false),
       waiting_for_clear_networking_history_(false),
       waiting_for_clear_origin_bound_certs_(false),
       waiting_for_clear_plugin_data_(false),
       waiting_for_clear_quota_managed_data_(false),
-      remove_mask_(0) {
+      remove_mask_(0),
+      remove_origin_(GURL()),
+      remove_protected_(false) {
   DCHECK(profile);
 }
 
 BrowsingDataRemover::~BrowsingDataRemover() {
   DCHECK(all_done());
 }
 
 // Static.
 void BrowsingDataRemover::set_removing(bool removing) {
   DCHECK(removing_ != removing);
   removing_ = removing;
 }
 
 // Static.
 int BrowsingDataRemover::GenerateQuotaClientMask(int remove_mask) {
   int quota_client_mask = 0;
   if (remove_mask & BrowsingDataRemover::REMOVE_FILE_SYSTEMS)
     quota_client_mask |= quota::QuotaClient::kFileSystem;
   if (remove_mask & BrowsingDataRemover::REMOVE_WEBSQL)
     quota_client_mask |= quota::QuotaClient::kDatabase;
   if (remove_mask & BrowsingDataRemover::REMOVE_APPCACHE)
     quota_client_mask |= quota::QuotaClient::kAppcache;
   if (remove_mask & BrowsingDataRemover::REMOVE_INDEXEDDB)
     quota_client_mask |= quota::QuotaClient::kIndexedDatabase;
 
   return quota_client_mask;
 }
 
 void BrowsingDataRemover::Remove(int remove_mask) {
+  RemoveImpl(remove_mask, GURL(), false);
+}
+
+void BrowsingDataRemover::RemoveImpl(int remove_mask,
+                                     const GURL& origin,
+                                     bool remove_protected_origins) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   set_removing(true);
   remove_mask_ = remove_mask;
+  remove_origin_ = origin;
+  remove_protected_ = remove_protected_origins;
 
   if (remove_mask & REMOVE_HISTORY) {
     HistoryService* history_service =
         profile_->GetHistoryService(Profile::EXPLICIT_ACCESS);
     if (history_service) {
       std::set<GURL> restrict_urls;
+      if (!remove_origin_.is_empty())
+        restrict_urls.insert(remove_origin_);
       content::RecordAction(UserMetricsAction("ClearBrowsingData_History"));
       waiting_for_clear_history_ = true;
       history_service->ExpireHistoryBetween(restrict_urls,
           delete_begin_, delete_end_,
           &request_consumer_,
           base::Bind(&BrowsingDataRemover::OnHistoryDeletionDone,
                      base::Unretained(this)));
     }
 
     // Need to clear the host cache and accumulated speculative data, as it also
-    // reveals some history.
+    // reveals some history: we have no mechanism to track when these items were
+    // created, so we'll clear them all. Better safe than sorry.
     if (g_browser_process->io_thread()) {
       waiting_for_clear_networking_history_ = true;
       BrowserThread::PostTask(
           BrowserThread::IO, FROM_HERE,
           base::Bind(&BrowsingDataRemover::ClearNetworkingHistory,
                      base::Unretained(this), g_browser_process->io_thread()));
     }
 
     // As part of history deletion we also delete the auto-generated keywords.
     TemplateURLService* keywords_model =
         TemplateURLServiceFactory::GetForProfile(profile_);
     if (keywords_model && !keywords_model->loaded()) {
       registrar_.Add(this, chrome::NOTIFICATION_TEMPLATE_URL_SERVICE_LOADED,
                      content::Source<TemplateURLService>(keywords_model));
       keywords_model->Load();
     } else if (keywords_model) {
-      keywords_model->RemoveAutoGeneratedBetween(delete_begin_, delete_end_);
+      keywords_model->RemoveAutoGeneratedForOriginBetween(remove_origin_,
+          delete_begin_, delete_end_);
     }
 
-    // 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();
-    }
-
-    // We also delete the last session when we delete the history.
-    SessionService* session_service =
-        SessionServiceFactory::GetForProfile(profile_);
-    if (session_service)
-      session_service->DeleteLastSession();
-
     // 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.
+    // 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()) {
+      // 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();
+      }
+
+      // We also delete the last session when we delete the history.
+      SessionService* session_service =
+          SessionServiceFactory::GetForProfile(profile_);
+      if (session_service)
+        session_service->DeleteLastSession();
+    }
   }
 
   if (remove_mask & REMOVE_DOWNLOADS) {
     content::RecordAction(UserMetricsAction("ClearBrowsingData_Downloads"));
     DownloadManager* download_manager =
         DownloadServiceFactory::GetForProfile(profile_)->GetDownloadManager();
     download_manager->RemoveDownloadsBetween(delete_begin_, delete_end_);
     download_manager->ClearLastDownloadPath();
   }
 
@@ skipping 425 matching lines @@
       BrowserThread::UI, FROM_HERE,
       base::Bind(&BrowsingDataRemover::OnClearedOriginBoundCerts,
                  base::Unretained(this)));
 }
 
 void BrowsingDataRemover::OnClearedOriginBoundCerts() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   waiting_for_clear_origin_bound_certs_ = false;
   NotifyAndDeleteIfDone();
 }