src/chrome/browser/browsing_data/browsing_data_remover.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/browsing_data/browsing_data_remover.h"
   6
   7 #include <map>
   8 #include <set>
   9
  10 #include "base/bind.h"
  11 #include "base/bind_helpers.h"
  12 #include "base/callback.h"
  13 #include "base/logging.h"
  14 #include "base/platform_file.h"
  15 #include "base/prefs/pref_service.h"
  16 #include "chrome/browser/autofill/personal_data_manager_factory.h"
  17 #include "chrome/browser/browser_process.h"
  18 #include "chrome/browser/browsing_data/browsing_data_helper.h"
  19 #include "chrome/browser/chrome_notification_types.h"
  20 #if defined(OS_CHROMEOS)
  21 #include "chrome/browser/chromeos/login/user.h"
  22 #include "chrome/browser/chromeos/login/user_manager.h"
  23 #endif
  24 #include "chrome/browser/download/download_prefs.h"
  25 #include "chrome/browser/download/download_service_factory.h"
  26 #include "chrome/browser/extensions/activity_log/activity_log.h"
  27 #include "chrome/browser/extensions/extension_service.h"
  28 #include "chrome/browser/extensions/extension_special_storage_policy.h"
  29 #include "chrome/browser/history/history_service.h"
  30 #include "chrome/browser/history/history_service_factory.h"
  31 #include "chrome/browser/io_thread.h"
  32 #include "chrome/browser/nacl_host/pnacl_host.h"
  33 #include "chrome/browser/net/chrome_url_request_context.h"
  34 #include "chrome/browser/net/predictor.h"
  35 #include "chrome/browser/password_manager/password_store.h"
  36 #include "chrome/browser/password_manager/password_store_factory.h"
  37 #include "chrome/browser/predictors/logged_in_predictor_table.h"
  38 #include "chrome/browser/predictors/predictor_database.h"
  39 #include "chrome/browser/predictors/predictor_database_factory.h"
  40 #include "chrome/browser/prerender/prerender_manager.h"
  41 #include "chrome/browser/prerender/prerender_manager_factory.h"
  42 #include "chrome/browser/profiles/profile.h"
  43 #include "chrome/browser/renderer_host/web_cache_manager.h"
  44 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
  45 #include "chrome/browser/search_engines/template_url_service.h"
  46 #include "chrome/browser/search_engines/template_url_service_factory.h"
  47 #include "chrome/browser/sessions/session_service.h"
  48 #include "chrome/browser/sessions/session_service_factory.h"
  49 #include "chrome/browser/sessions/tab_restore_service.h"
  50 #include "chrome/browser/sessions/tab_restore_service_factory.h"
  51 #include "chrome/common/pref_names.h"
  52 #include "chrome/common/url_constants.h"
  53 #if defined(OS_CHROMEOS)
  54 #include "chromeos/attestation/attestation_constants.h"
  55 #include "chromeos/dbus/cryptohome_client.h"
  56 #include "chromeos/dbus/dbus_thread_manager.h"
  57 #endif
  58 #include "components/autofill/core/browser/personal_data_manager.h"
  59 #include "components/autofill/core/browser/webdata/autofill_webdata_service.h"
  60 #include "components/nacl/browser/nacl_browser.h"
  61 #include "content/public/browser/browser_thread.h"
  62 #include "content/public/browser/dom_storage_context.h"
  63 #include "content/public/browser/download_manager.h"
  64 #include "content/public/browser/local_storage_usage_info.h"
  65 #include "content/public/browser/notification_service.h"
  66 #include "content/public/browser/plugin_data_remover.h"
  67 #include "content/public/browser/session_storage_usage_info.h"
  68 #include "content/public/browser/storage_partition.h"
  69 #include "content/public/browser/user_metrics.h"
  70 #include "net/base/net_errors.h"
  71 #include "net/cookies/cookie_store.h"
  72 #include "net/disk_cache/disk_cache.h"
  73 #include "net/http/http_cache.h"
  74 #include "net/http/transport_security_state.h"
  75 #include "net/ssl/server_bound_cert_service.h"
  76 #include "net/ssl/server_bound_cert_store.h"
  77 #include "net/url_request/url_request_context.h"
  78 #include "net/url_request/url_request_context_getter.h"
  79 #include "webkit/browser/quota/quota_manager.h"
  80 #include "webkit/browser/quota/special_storage_policy.h"
  81 #include "webkit/common/quota/quota_types.h"
  82
  83 using content::BrowserContext;
  84 using content::BrowserThread;
  85 using content::DOMStorageContext;
  86 using content::UserMetricsAction;
  87
  88 bool BrowsingDataRemover::is_removing_ = false;
  89
  90 BrowsingDataRemover::NotificationDetails::NotificationDetails()
  91     : removal_begin(base::Time()),
  92       removal_mask(-1),
  93       origin_set_mask(-1) {
  94 }
  95
  96 BrowsingDataRemover::NotificationDetails::NotificationDetails(
  97     const BrowsingDataRemover::NotificationDetails& details)
  98     : removal_begin(details.removal_begin),
  99       removal_mask(details.removal_mask),
 100       origin_set_mask(details.origin_set_mask) {
 101 }
 102
 103 BrowsingDataRemover::NotificationDetails::NotificationDetails(
 104     base::Time removal_begin,
 105     int removal_mask,
 106     int origin_set_mask)
 107     : removal_begin(removal_begin),
 108       removal_mask(removal_mask),
 109       origin_set_mask(origin_set_mask) {
 110 }
 111
 112 BrowsingDataRemover::NotificationDetails::~NotificationDetails() {}
 113
 114 // Static.
 115 BrowsingDataRemover* BrowsingDataRemover::CreateForUnboundedRange(
 116     Profile* profile) {
 117   return new BrowsingDataRemover(profile, base::Time(), base::Time::Max());
 118 }
 119
 120 // Static.
 121 BrowsingDataRemover* BrowsingDataRemover::CreateForRange(Profile* profile,
 122     base::Time start, base::Time end) {
 123   return new BrowsingDataRemover(profile, start, end);
 124 }
 125
 126 // Static.
 127 BrowsingDataRemover* BrowsingDataRemover::CreateForPeriod(Profile* profile,
 128     TimePeriod period) {
 129   switch (period) {
 130     case LAST_HOUR:
 131       content::RecordAction(
 132           UserMetricsAction("ClearBrowsingData_LastHour"));
 133       break;
 134     case LAST_DAY:
 135       content::RecordAction(
 136           UserMetricsAction("ClearBrowsingData_LastDay"));
 137       break;
 138     case LAST_WEEK:
 139       content::RecordAction(
 140           UserMetricsAction("ClearBrowsingData_LastWeek"));
 141       break;
 142     case FOUR_WEEKS:
 143       content::RecordAction(
 144           UserMetricsAction("ClearBrowsingData_LastMonth"));
 145       break;
 146     case EVERYTHING:
 147       content::RecordAction(
 148           UserMetricsAction("ClearBrowsingData_Everything"));
 149       break;
 150   }
 151   return new BrowsingDataRemover(profile,
 152       BrowsingDataRemover::CalculateBeginDeleteTime(period),
 153       base::Time::Max());
 154 }
 155
 156 BrowsingDataRemover::BrowsingDataRemover(Profile* profile,
 157                                          base::Time delete_begin,
 158                                          base::Time delete_end)
 159     : profile_(profile),
 160       quota_manager_(NULL),
 161       dom_storage_context_(NULL),
 162       special_storage_policy_(profile->GetExtensionSpecialStoragePolicy()),
 163       delete_begin_(delete_begin),
 164       delete_end_(delete_end),
 165       next_cache_state_(STATE_NONE),
 166       cache_(NULL),
 167       main_context_getter_(profile->GetRequestContext()),
 168       media_context_getter_(profile->GetMediaRequestContext()),
 169       deauthorize_content_licenses_request_id_(0),
 170       waiting_for_clear_autofill_origin_urls_(false),
 171       waiting_for_clear_cache_(false),
 172       waiting_for_clear_content_licenses_(false),
 173       waiting_for_clear_cookies_count_(0),
 174       waiting_for_clear_form_(false),
 175       waiting_for_clear_history_(false),
 176       waiting_for_clear_hostname_resolution_cache_(false),
 177       waiting_for_clear_local_storage_(false),
 178       waiting_for_clear_logged_in_predictor_(false),
 179       waiting_for_clear_nacl_cache_(false),
 180       waiting_for_clear_network_predictor_(false),
 181       waiting_for_clear_networking_history_(false),
 182       waiting_for_clear_plugin_data_(false),
 183       waiting_for_clear_pnacl_cache_(false),
 184       waiting_for_clear_quota_managed_data_(false),
 185       waiting_for_clear_server_bound_certs_(false),
 186       waiting_for_clear_session_storage_(false),
 187       waiting_for_clear_shader_cache_(false),
 188       waiting_for_clear_webrtc_identity_store_(false),
 189       waiting_for_clear_keyword_data_(false),
 190       waiting_for_clear_platform_keys_(false),
 191       remove_mask_(0),
 192       remove_origin_(GURL()),
 193       origin_set_mask_(0) {
 194   DCHECK(profile);
 195   // crbug.com/140910: Many places were calling this with base::Time() as
 196   // delete_end, even though they should've used base::Time::Max(). Work around
 197   // it here. New code should use base::Time::Max().
 198   DCHECK(delete_end_ != base::Time());
 199   if (delete_end_ == base::Time())
 200     delete_end_ = base::Time::Max();
 201 }
 202
 203 BrowsingDataRemover::~BrowsingDataRemover() {
 204   DCHECK(AllDone());
 205 }
 206
 207 // Static.
 208 void BrowsingDataRemover::set_removing(bool is_removing) {
 209   DCHECK(is_removing_ != is_removing);
 210   is_removing_ = is_removing;
 211 }
 212
 213 // Static.
 214 int BrowsingDataRemover::GenerateQuotaClientMask(int remove_mask) {
 215   int quota_client_mask = 0;
 216   if (remove_mask & BrowsingDataRemover::REMOVE_FILE_SYSTEMS)
 217     quota_client_mask |= quota::QuotaClient::kFileSystem;
 218   if (remove_mask & BrowsingDataRemover::REMOVE_WEBSQL)
 219     quota_client_mask |= quota::QuotaClient::kDatabase;
 220   if (remove_mask & BrowsingDataRemover::REMOVE_APPCACHE)
 221     quota_client_mask |= quota::QuotaClient::kAppcache;
 222   if (remove_mask & BrowsingDataRemover::REMOVE_INDEXEDDB)
 223     quota_client_mask |= quota::QuotaClient::kIndexedDatabase;
 224
 225   return quota_client_mask;
 226 }
 227
 228 void BrowsingDataRemover::Remove(int remove_mask, int origin_set_mask) {
 229   RemoveImpl(remove_mask, GURL(), origin_set_mask);
 230 }
 231
 232 void BrowsingDataRemover::RemoveImpl(int remove_mask,
 233                                      const GURL& origin,
 234                                      int origin_set_mask) {
 235   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 236   set_removing(true);
 237   remove_mask_ = remove_mask;
 238   remove_origin_ = origin;
 239   origin_set_mask_ = origin_set_mask;
 240
 241   PrefService* prefs = profile_->GetPrefs();
 242   bool may_delete_history = prefs->GetBoolean(
 243       prefs::kAllowDeletingBrowserHistory);
 244
 245   // All the UI entry points into the BrowsingDataRemover should be disabled,
 246   // but this will fire if something was missed or added.
 247   DCHECK(may_delete_history ||
 248       (!(remove_mask & REMOVE_HISTORY) && !(remove_mask & REMOVE_DOWNLOADS)));
 249
 250   if (origin_set_mask_ & BrowsingDataHelper::UNPROTECTED_WEB) {
 251     content::RecordAction(
 252         UserMetricsAction("ClearBrowsingData_MaskContainsUnprotectedWeb"));
 253   }
 254   if (origin_set_mask_ & BrowsingDataHelper::PROTECTED_WEB) {
 255     content::RecordAction(
 256         UserMetricsAction("ClearBrowsingData_MaskContainsProtectedWeb"));
 257   }
 258   if (origin_set_mask_ & BrowsingDataHelper::EXTENSION) {
 259     content::RecordAction(
 260         UserMetricsAction("ClearBrowsingData_MaskContainsExtension"));
 261   }
 262   // If this fires, we added a new BrowsingDataHelper::OriginSetMask without
 263   // updating the user metrics above.
 264   COMPILE_ASSERT(
 265       BrowsingDataHelper::ALL == (BrowsingDataHelper::UNPROTECTED_WEB |
 266                                   BrowsingDataHelper::PROTECTED_WEB |
 267                                   BrowsingDataHelper::EXTENSION),
 268       forgotten_to_add_origin_mask_type);
 269
 270   if ((remove_mask & REMOVE_HISTORY) && may_delete_history) {
 271     HistoryService* history_service = HistoryServiceFactory::GetForProfile(
 272         profile_, Profile::EXPLICIT_ACCESS);
 273     if (history_service) {
 274       std::set<GURL> restrict_urls;
 275       if (!remove_origin_.is_empty())
 276         restrict_urls.insert(remove_origin_);
 277       content::RecordAction(UserMetricsAction("ClearBrowsingData_History"));
 278       waiting_for_clear_history_ = true;
 279
 280       history_service->ExpireLocalAndRemoteHistoryBetween(
 281           restrict_urls, delete_begin_, delete_end_,
 282           base::Bind(&BrowsingDataRemover::OnHistoryDeletionDone,
 283                      base::Unretained(this)),
 284           &history_task_tracker_);
 285
 286 #if defined(ENABLE_EXTENSIONS)
 287       // The extension activity contains details of which websites extensions
 288       // were active on. It therefore indirectly stores details of websites a
 289       // user has visited so best clean from here as well.
 290       extensions::ActivityLog::GetInstance(profile_)->RemoveURLs(restrict_urls);
 291 #endif
 292     }
 293
 294     // Need to clear the host cache and accumulated speculative data, as it also
 295     // reveals some history: we have no mechanism to track when these items were
 296     // created, so we'll clear them all. Better safe than sorry.
 297     if (g_browser_process->io_thread()) {
 298       waiting_for_clear_hostname_resolution_cache_ = true;
 299       BrowserThread::PostTask(
 300           BrowserThread::IO, FROM_HERE,
 301           base::Bind(
 302               &BrowsingDataRemover::ClearHostnameResolutionCacheOnIOThread,
 303               base::Unretained(this),
 304               g_browser_process->io_thread()));
 305     }
 306     if (profile_->GetNetworkPredictor()) {
 307       waiting_for_clear_network_predictor_ = true;
 308       BrowserThread::PostTask(
 309           BrowserThread::IO, FROM_HERE,
 310           base::Bind(&BrowsingDataRemover::ClearNetworkPredictorOnIOThread,
 311                      base::Unretained(this)));
 312     }
 313
 314     // As part of history deletion we also delete the auto-generated keywords.
 315     TemplateURLService* keywords_model =
 316         TemplateURLServiceFactory::GetForProfile(profile_);
 317     if (keywords_model && !keywords_model->loaded()) {
 318       template_url_sub_ = keywords_model->RegisterOnLoadedCallback(
 319           base::Bind(&BrowsingDataRemover::OnKeywordsLoaded,
 320                      base::Unretained(this)));
 321       keywords_model->Load();
 322       waiting_for_clear_keyword_data_ = true;
 323     } else if (keywords_model) {
 324       keywords_model->RemoveAutoGeneratedForOriginBetween(remove_origin_,
 325           delete_begin_, delete_end_);
 326     }
 327
 328     // The PrerenderManager keeps history of prerendered pages, so clear that.
 329     // It also may have a prerendered page. If so, the page could be
 330     // considered to have a small amount of historical information, so delete
 331     // it, too.
 332     prerender::PrerenderManager* prerender_manager =
 333         prerender::PrerenderManagerFactory::GetForProfile(profile_);
 334     if (prerender_manager) {
 335       prerender_manager->ClearData(
 336           prerender::PrerenderManager::CLEAR_PRERENDER_CONTENTS |
 337           prerender::PrerenderManager::CLEAR_PRERENDER_HISTORY);
 338     }
 339
 340     // If the caller is removing history for all hosts, then clear ancillary
 341     // historical information.
 342     if (remove_origin_.is_empty()) {
 343       // We also delete the list of recently closed tabs. Since these expire,
 344       // they can't be more than a day old, so we can simply clear them all.
 345       TabRestoreService* tab_service =
 346           TabRestoreServiceFactory::GetForProfile(profile_);
 347       if (tab_service) {
 348         tab_service->ClearEntries();
 349         tab_service->DeleteLastSession();
 350       }
 351
 352 #if defined(ENABLE_SESSION_SERVICE)
 353       // We also delete the last session when we delete the history.
 354       SessionService* session_service =
 355           SessionServiceFactory::GetForProfile(profile_);
 356       if (session_service)
 357         session_service->DeleteLastSession();
 358 #endif
 359     }
 360
 361     // The saved Autofill profiles and credit cards can include the origin from
 362     // which these profiles and credit cards were learned.  These are a form of
 363     // history, so clear them as well.
 364     scoped_refptr<autofill::AutofillWebDataService> web_data_service =
 365         autofill::AutofillWebDataService::FromBrowserContext(profile_);
 366     if (web_data_service.get()) {
 367       waiting_for_clear_autofill_origin_urls_ = true;
 368       web_data_service->RemoveOriginURLsModifiedBetween(
 369           delete_begin_, delete_end_);
 370       // The above calls are done on the UI thread but do their work on the DB
 371       // thread. So wait for it.
 372       BrowserThread::PostTaskAndReply(
 373           BrowserThread::DB, FROM_HERE,
 374           base::Bind(&base::DoNothing),
 375           base::Bind(&BrowsingDataRemover::OnClearedAutofillOriginURLs,
 376                      base::Unretained(this)));
 377
 378       autofill::PersonalDataManager* data_manager =
 379           autofill::PersonalDataManagerFactory::GetForProfile(profile_);
 380       if (data_manager)
 381         data_manager->Refresh();
 382     }
 383
 384   }
 385
 386   if ((remove_mask & REMOVE_DOWNLOADS) && may_delete_history) {
 387     content::RecordAction(UserMetricsAction("ClearBrowsingData_Downloads"));
 388     content::DownloadManager* download_manager =
 389         BrowserContext::GetDownloadManager(profile_);
 390     download_manager->RemoveDownloadsBetween(delete_begin_, delete_end_);
 391     DownloadPrefs* download_prefs = DownloadPrefs::FromDownloadManager(
 392         download_manager);
 393     download_prefs->SetSaveFilePath(download_prefs->DownloadPath());
 394   }
 395
 396   // We ignore the REMOVE_COOKIES request if UNPROTECTED_WEB is not set,
 397   // so that callers who request REMOVE_SITE_DATA with PROTECTED_WEB
 398   // don't accidentally remove the cookies that are associated with the
 399   // UNPROTECTED_WEB origin. This is necessary because cookies are not separated
 400   // between UNPROTECTED_WEB and PROTECTED_WEB.
 401   if (remove_mask & REMOVE_COOKIES &&
 402       origin_set_mask_ & BrowsingDataHelper::UNPROTECTED_WEB) {
 403     content::RecordAction(UserMetricsAction("ClearBrowsingData_Cookies"));
 404     // Since we are running on the UI thread don't call GetURLRequestContext().
 405     net::URLRequestContextGetter* rq_context = profile_->GetRequestContext();
 406     if (rq_context) {
 407       ++waiting_for_clear_cookies_count_;
 408       BrowserThread::PostTask(
 409           BrowserThread::IO, FROM_HERE,
 410           base::Bind(&BrowsingDataRemover::ClearCookiesOnIOThread,
 411                      base::Unretained(this), base::Unretained(rq_context)));
 412     }
 413     // Also delete the LoggedIn Predictor, which tries to keep track of which
 414     // sites a user is logged into.
 415     ClearLoggedInPredictor();
 416
 417 #if defined(FULL_SAFE_BROWSING) || defined(MOBILE_SAFE_BROWSING)
 418     // Clear the safebrowsing cookies only if time period is for "all time".  It
 419     // doesn't make sense to apply the time period of deleting in the last X
 420     // hours/days to the safebrowsing cookies since they aren't the result of
 421     // any user action.
 422     if (delete_begin_ == base::Time()) {
 423       SafeBrowsingService* sb_service =
 424           g_browser_process->safe_browsing_service();
 425       if (sb_service) {
 426         net::URLRequestContextGetter* sb_context =
 427             sb_service->url_request_context();
 428         ++waiting_for_clear_cookies_count_;
 429         BrowserThread::PostTask(
 430             BrowserThread::IO, FROM_HERE,
 431             base::Bind(&BrowsingDataRemover::ClearCookiesOnIOThread,
 432                        base::Unretained(this), base::Unretained(sb_context)));
 433       }
 434     }
 435 #endif
 436   }
 437
 438   // Server bound certs are not separated for protected and unprotected web
 439   // origins. We check the origin_set_mask_ to prevent unintended deletion.
 440   if (remove_mask & REMOVE_SERVER_BOUND_CERTS &&
 441       origin_set_mask_ & BrowsingDataHelper::UNPROTECTED_WEB) {
 442     content::RecordAction(
 443         UserMetricsAction("ClearBrowsingData_ServerBoundCerts"));
 444     // Since we are running on the UI thread don't call GetURLRequestContext().
 445     net::URLRequestContextGetter* rq_context = profile_->GetRequestContext();
 446     if (rq_context) {
 447       waiting_for_clear_server_bound_certs_ = true;
 448       BrowserThread::PostTask(
 449           BrowserThread::IO, FROM_HERE,
 450           base::Bind(&BrowsingDataRemover::ClearServerBoundCertsOnIOThread,
 451                      base::Unretained(this), base::Unretained(rq_context)));
 452     }
 453   }
 454
 455   if (remove_mask & REMOVE_LOCAL_STORAGE) {
 456     waiting_for_clear_local_storage_ = true;
 457     waiting_for_clear_session_storage_ = true;
 458     if (!dom_storage_context_) {
 459       dom_storage_context_ =
 460           BrowserContext::GetDefaultStoragePartition(profile_)->
 461               GetDOMStorageContext();
 462     }
 463     ClearLocalStorageOnUIThread();
 464     ClearSessionStorageOnUIThread();
 465   }
 466
 467   if (remove_mask & REMOVE_INDEXEDDB || remove_mask & REMOVE_WEBSQL ||
 468       remove_mask & REMOVE_APPCACHE || remove_mask & REMOVE_FILE_SYSTEMS) {
 469     if (!quota_manager_) {
 470       quota_manager_ =
 471           BrowserContext::GetDefaultStoragePartition(profile_)->
 472               GetQuotaManager();
 473     }
 474     waiting_for_clear_quota_managed_data_ = true;
 475     BrowserThread::PostTask(
 476         BrowserThread::IO, FROM_HERE,
 477         base::Bind(&BrowsingDataRemover::ClearQuotaManagedDataOnIOThread,
 478                    base::Unretained(this)));
 479   }
 480
 481 #if defined(ENABLE_PLUGINS)
 482   // Plugin is data not separated for protected and unprotected web origins. We
 483   // check the origin_set_mask_ to prevent unintended deletion.
 484   if (remove_mask & REMOVE_PLUGIN_DATA &&
 485       origin_set_mask_ & BrowsingDataHelper::UNPROTECTED_WEB) {
 486     content::RecordAction(UserMetricsAction("ClearBrowsingData_LSOData"));
 487
 488     waiting_for_clear_plugin_data_ = true;
 489     if (!plugin_data_remover_.get())
 490       plugin_data_remover_.reset(content::PluginDataRemover::Create(profile_));
 491     base::WaitableEvent* event =
 492         plugin_data_remover_->StartRemoving(delete_begin_);
 493
 494     base::WaitableEventWatcher::EventCallback watcher_callback =
 495         base::Bind(&BrowsingDataRemover::OnWaitableEventSignaled,
 496                    base::Unretained(this));
 497     watcher_.StartWatching(event, watcher_callback);
 498   }
 499 #endif
 500
 501   if (remove_mask & REMOVE_PASSWORDS) {
 502     content::RecordAction(UserMetricsAction("ClearBrowsingData_Passwords"));
 503     PasswordStore* password_store = PasswordStoreFactory::GetForProfile(
 504         profile_, Profile::EXPLICIT_ACCESS).get();
 505
 506     if (password_store)
 507       password_store->RemoveLoginsCreatedBetween(delete_begin_, delete_end_);
 508   }
 509
 510   if (remove_mask & REMOVE_FORM_DATA) {
 511     content::RecordAction(UserMetricsAction("ClearBrowsingData_Autofill"));
 512     scoped_refptr<autofill::AutofillWebDataService> web_data_service =
 513         autofill::AutofillWebDataService::FromBrowserContext(profile_);
 514
 515     if (web_data_service.get()) {
 516       waiting_for_clear_form_ = true;
 517       web_data_service->RemoveFormElementsAddedBetween(delete_begin_,
 518           delete_end_);
 519       web_data_service->RemoveAutofillDataModifiedBetween(
 520           delete_begin_, delete_end_);
 521       // The above calls are done on the UI thread but do their work on the DB
 522       // thread. So wait for it.
 523       BrowserThread::PostTaskAndReply(
 524           BrowserThread::DB, FROM_HERE,
 525           base::Bind(&base::DoNothing),
 526           base::Bind(&BrowsingDataRemover::OnClearedFormData,
 527                      base::Unretained(this)));
 528
 529       autofill::PersonalDataManager* data_manager =
 530           autofill::PersonalDataManagerFactory::GetForProfile(profile_);
 531       if (data_manager)
 532         data_manager->Refresh();
 533     }
 534   }
 535
 536   if (remove_mask & REMOVE_CACHE) {
 537     // Tell the renderers to clear their cache.
 538     WebCacheManager::GetInstance()->ClearCache();
 539
 540     // Invoke DoClearCache on the IO thread.
 541     waiting_for_clear_cache_ = true;
 542     content::RecordAction(UserMetricsAction("ClearBrowsingData_Cache"));
 543
 544     BrowserThread::PostTask(
 545         BrowserThread::IO, FROM_HERE,
 546         base::Bind(&BrowsingDataRemover::ClearCacheOnIOThread,
 547                    base::Unretained(this)));
 548
 549 #if !defined(DISABLE_NACL)
 550     waiting_for_clear_nacl_cache_ = true;
 551
 552     BrowserThread::PostTask(
 553         BrowserThread::IO, FROM_HERE,
 554         base::Bind(&BrowsingDataRemover::ClearNaClCacheOnIOThread,
 555                    base::Unretained(this)));
 556
 557     waiting_for_clear_pnacl_cache_ = true;
 558     BrowserThread::PostTask(
 559         BrowserThread::IO, FROM_HERE,
 560         base::Bind(&BrowsingDataRemover::ClearPnaclCacheOnIOThread,
 561                    base::Unretained(this), delete_begin_, delete_end_));
 562 #endif
 563
 564     // The PrerenderManager may have a page actively being prerendered, which
 565     // is essentially a preemptively cached page.
 566     prerender::PrerenderManager* prerender_manager =
 567         prerender::PrerenderManagerFactory::GetForProfile(profile_);
 568     if (prerender_manager) {
 569       prerender_manager->ClearData(
 570           prerender::PrerenderManager::CLEAR_PRERENDER_CONTENTS);
 571     }
 572
 573     // Tell the shader disk cache to clear.
 574     waiting_for_clear_shader_cache_ = true;
 575     content::RecordAction(UserMetricsAction("ClearBrowsingData_ShaderCache"));
 576
 577     ClearShaderCacheOnUIThread();
 578
 579     waiting_for_clear_webrtc_identity_store_ = true;
 580     BrowserContext::GetDefaultStoragePartition(profile_)->ClearDataForRange(
 581         content::StoragePartition::REMOVE_DATA_MASK_WEBRTC_IDENTITY,
 582         content::StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL,
 583         delete_begin_,
 584         delete_end_,
 585         base::Bind(&BrowsingDataRemover::OnClearWebRTCIdentityStore,
 586                    base::Unretained(this)));
 587   }
 588
 589 #if defined(ENABLE_PLUGINS)
 590   if (remove_mask & REMOVE_CONTENT_LICENSES) {
 591     content::RecordAction(
 592         UserMetricsAction("ClearBrowsingData_ContentLicenses"));
 593
 594     waiting_for_clear_content_licenses_ = true;
 595     if (!pepper_flash_settings_manager_.get()) {
 596       pepper_flash_settings_manager_.reset(
 597           new PepperFlashSettingsManager(this, profile_));
 598     }
 599     deauthorize_content_licenses_request_id_ =
 600         pepper_flash_settings_manager_->DeauthorizeContentLicenses(prefs);
 601 #if defined(OS_CHROMEOS)
 602     // On Chrome OS, also delete any content protection platform keys.
 603     chromeos::User* user = chromeos::UserManager::Get()->
 604         GetUserByProfile(profile_);
 605     if (!user) {
 606       LOG(WARNING) << "Failed to find user for current profile.";
 607     } else {
 608       chromeos::DBusThreadManager::Get()->GetCryptohomeClient()->
 609           TpmAttestationDeleteKeys(
 610               chromeos::attestation::KEY_USER,
 611               user->email(),
 612               chromeos::attestation::kContentProtectionKeyPrefix,
 613               base::Bind(&BrowsingDataRemover::OnClearPlatformKeys,
 614                          base::Unretained(this)));
 615       waiting_for_clear_platform_keys_ = true;
 616     }
 617 #endif
 618   }
 619 #endif
 620
 621   // Always wipe accumulated network related data (TransportSecurityState and
 622   // HttpServerPropertiesManager data).
 623   waiting_for_clear_networking_history_ = true;
 624   profile_->ClearNetworkingHistorySince(
 625       delete_begin_,
 626       base::Bind(&BrowsingDataRemover::OnClearedNetworkingHistory,
 627                  base::Unretained(this)));
 628 }
 629
 630 void BrowsingDataRemover::AddObserver(Observer* observer) {
 631   observer_list_.AddObserver(observer);
 632 }
 633
 634 void BrowsingDataRemover::RemoveObserver(Observer* observer) {
 635   observer_list_.RemoveObserver(observer);
 636 }
 637
 638 void BrowsingDataRemover::OnHistoryDeletionDone() {
 639   waiting_for_clear_history_ = false;
 640   NotifyAndDeleteIfDone();
 641 }
 642
 643 void BrowsingDataRemover::OverrideQuotaManagerForTesting(
 644     quota::QuotaManager* quota_manager) {
 645   quota_manager_ = quota_manager;
 646 }
 647
 648 base::Time BrowsingDataRemover::CalculateBeginDeleteTime(
 649     TimePeriod time_period) {
 650   base::TimeDelta diff;
 651   base::Time delete_begin_time = base::Time::Now();
 652   switch (time_period) {
 653     case LAST_HOUR:
 654       diff = base::TimeDelta::FromHours(1);
 655       break;
 656     case LAST_DAY:
 657       diff = base::TimeDelta::FromHours(24);
 658       break;
 659     case LAST_WEEK:
 660       diff = base::TimeDelta::FromHours(7*24);
 661       break;
 662     case FOUR_WEEKS:
 663       diff = base::TimeDelta::FromHours(4*7*24);
 664       break;
 665     case EVERYTHING:
 666       delete_begin_time = base::Time();
 667       break;
 668     default:
 669       NOTREACHED() << L"Missing item";
 670       break;
 671   }
 672   return delete_begin_time - diff;
 673 }
 674
 675 bool BrowsingDataRemover::AllDone() {
 676   return !waiting_for_clear_keyword_data_ &&
 677          !waiting_for_clear_autofill_origin_urls_ &&
 678          !waiting_for_clear_cache_ && !waiting_for_clear_nacl_cache_ &&
 679          !waiting_for_clear_cookies_count_ && !waiting_for_clear_history_ &&
 680          !waiting_for_clear_local_storage_ &&
 681          !waiting_for_clear_logged_in_predictor_ &&
 682          !waiting_for_clear_session_storage_ &&
 683          !waiting_for_clear_networking_history_ &&
 684          !waiting_for_clear_server_bound_certs_ &&
 685          !waiting_for_clear_plugin_data_ &&
 686          !waiting_for_clear_pnacl_cache_ &&
 687          !waiting_for_clear_quota_managed_data_ &&
 688          !waiting_for_clear_content_licenses_ && !waiting_for_clear_form_ &&
 689          !waiting_for_clear_hostname_resolution_cache_ &&
 690          !waiting_for_clear_network_predictor_ &&
 691          !waiting_for_clear_shader_cache_ &&
 692          !waiting_for_clear_webrtc_identity_store_ &&
 693          !waiting_for_clear_platform_keys_;
 694 }
 695
 696 void BrowsingDataRemover::OnKeywordsLoaded() {
 697   // Deletes the entries from the model, and if we're not waiting on anything
 698   // else notifies observers and deletes this BrowsingDataRemover.
 699   TemplateURLService* model =
 700       TemplateURLServiceFactory::GetForProfile(profile_);
 701   DCHECK_EQ(profile_, model->profile());
 702   model->RemoveAutoGeneratedBetween(delete_begin_, delete_end_);
 703   waiting_for_clear_keyword_data_ = false;
 704   template_url_sub_.reset();
 705   NotifyAndDeleteIfDone();
 706 }
 707
 708 void BrowsingDataRemover::NotifyAndDeleteIfDone() {
 709   // TODO(brettw) http://crbug.com/305259: This should also observe session
 710   // clearing (what about other things such as passwords, etc.?) and wait for
 711   // them to complete before continuing.
 712
 713   if (!AllDone())
 714     return;
 715
 716   set_removing(false);
 717
 718   // Send global notification, then notify any explicit observers.
 719   BrowsingDataRemover::NotificationDetails details(delete_begin_, remove_mask_,
 720       origin_set_mask_);
 721   content::NotificationService::current()->Notify(
 722       chrome::NOTIFICATION_BROWSING_DATA_REMOVED,
 723       content::Source<Profile>(profile_),
 724       content::Details<BrowsingDataRemover::NotificationDetails>(&details));
 725
 726   FOR_EACH_OBSERVER(Observer, observer_list_, OnBrowsingDataRemoverDone());
 727
 728   // History requests aren't happy if you delete yourself from the callback.
 729   // As such, we do a delete later.
 730   base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);
 731 }
 732
 733 void BrowsingDataRemover::OnClearedHostnameResolutionCache() {
 734   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 735   waiting_for_clear_hostname_resolution_cache_ = false;
 736   NotifyAndDeleteIfDone();
 737 }
 738
 739 void BrowsingDataRemover::ClearHostnameResolutionCacheOnIOThread(
 740     IOThread* io_thread) {
 741   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 742
 743   io_thread->ClearHostCache();
 744
 745   // Notify the UI thread that we are done.
 746   BrowserThread::PostTask(
 747       BrowserThread::UI,
 748       FROM_HERE,
 749       base::Bind(&BrowsingDataRemover::OnClearedHostnameResolutionCache,
 750                  base::Unretained(this)));
 751 }
 752
 753 void BrowsingDataRemover::OnClearedLoggedInPredictor() {
 754   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 755   DCHECK(waiting_for_clear_logged_in_predictor_);
 756   waiting_for_clear_logged_in_predictor_ = false;
 757   NotifyAndDeleteIfDone();
 758 }
 759
 760 void BrowsingDataRemover::ClearLoggedInPredictor() {
 761   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 762   DCHECK(!waiting_for_clear_logged_in_predictor_);
 763
 764   predictors::PredictorDatabase* predictor_db =
 765       predictors::PredictorDatabaseFactory::GetForProfile(profile_);
 766   if (!predictor_db)
 767     return;
 768
 769   predictors::LoggedInPredictorTable* logged_in_table =
 770       predictor_db->logged_in_table().get();
 771   if (!logged_in_table)
 772     return;
 773
 774   waiting_for_clear_logged_in_predictor_ = true;
 775
 776   BrowserThread::PostTaskAndReply(
 777       BrowserThread::DB,
 778       FROM_HERE,
 779       base::Bind(&predictors::LoggedInPredictorTable::DeleteAllCreatedBetween,
 780                  logged_in_table,
 781                  delete_begin_,
 782                  delete_end_),
 783       base::Bind(&BrowsingDataRemover::OnClearedLoggedInPredictor,
 784                  base::Unretained(this)));
 785 }
 786
 787 void BrowsingDataRemover::OnClearedNetworkPredictor() {
 788   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 789   waiting_for_clear_network_predictor_ = false;
 790   NotifyAndDeleteIfDone();
 791 }
 792
 793 void BrowsingDataRemover::ClearNetworkPredictorOnIOThread() {
 794   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 795
 796   chrome_browser_net::Predictor* predictor = profile_->GetNetworkPredictor();
 797   if (predictor) {
 798     predictor->DiscardInitialNavigationHistory();
 799     predictor->DiscardAllResults();
 800   }
 801
 802   // Notify the UI thread that we are done.
 803   BrowserThread::PostTask(
 804       BrowserThread::UI,
 805       FROM_HERE,
 806       base::Bind(&BrowsingDataRemover::OnClearedNetworkPredictor,
 807                  base::Unretained(this)));
 808 }
 809
 810 void BrowsingDataRemover::OnClearedNetworkingHistory() {
 811   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 812   waiting_for_clear_networking_history_ = false;
 813   NotifyAndDeleteIfDone();
 814 }
 815
 816 void BrowsingDataRemover::ClearedCache() {
 817   waiting_for_clear_cache_ = false;
 818
 819   NotifyAndDeleteIfDone();
 820 }
 821
 822 void BrowsingDataRemover::ClearCacheOnIOThread() {
 823   // This function should be called on the IO thread.
 824   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 825   DCHECK_EQ(STATE_NONE, next_cache_state_);
 826   DCHECK(main_context_getter_.get());
 827   DCHECK(media_context_getter_.get());
 828
 829   next_cache_state_ = STATE_CREATE_MAIN;
 830   DoClearCache(net::OK);
 831 }
 832
 833 // The expected state sequence is STATE_NONE --> STATE_CREATE_MAIN -->
 834 // STATE_DELETE_MAIN --> STATE_CREATE_MEDIA --> STATE_DELETE_MEDIA -->
 835 // STATE_DONE, and any errors are ignored.
 836 void BrowsingDataRemover::DoClearCache(int rv) {
 837   DCHECK_NE(STATE_NONE, next_cache_state_);
 838
 839   while (rv != net::ERR_IO_PENDING && next_cache_state_ != STATE_NONE) {
 840     switch (next_cache_state_) {
 841       case STATE_CREATE_MAIN:
 842       case STATE_CREATE_MEDIA: {
 843         // Get a pointer to the cache.
 844         net::URLRequestContextGetter* getter =
 845             (next_cache_state_ == STATE_CREATE_MAIN)
 846                 ? main_context_getter_.get()
 847                 : media_context_getter_.get();
 848         net::HttpTransactionFactory* factory =
 849             getter->GetURLRequestContext()->http_transaction_factory();
 850
 851         next_cache_state_ = (next_cache_state_ == STATE_CREATE_MAIN) ?
 852                                 STATE_DELETE_MAIN : STATE_DELETE_MEDIA;
 853         rv = factory->GetCache()->GetBackend(
 854             &cache_, base::Bind(&BrowsingDataRemover::DoClearCache,
 855                                 base::Unretained(this)));
 856         break;
 857       }
 858       case STATE_DELETE_MAIN:
 859       case STATE_DELETE_MEDIA: {
 860         next_cache_state_ = (next_cache_state_ == STATE_DELETE_MAIN) ?
 861                                 STATE_CREATE_MEDIA : STATE_DONE;
 862
 863         // |cache_| can be null if it cannot be initialized.
 864         if (cache_) {
 865           if (delete_begin_.is_null()) {
 866             rv = cache_->DoomAllEntries(
 867                 base::Bind(&BrowsingDataRemover::DoClearCache,
 868                            base::Unretained(this)));
 869           } else {
 870             rv = cache_->DoomEntriesBetween(
 871                 delete_begin_, delete_end_,
 872                 base::Bind(&BrowsingDataRemover::DoClearCache,
 873                            base::Unretained(this)));
 874           }
 875           cache_ = NULL;
 876         }
 877         break;
 878       }
 879       case STATE_DONE: {
 880         cache_ = NULL;
 881         next_cache_state_ = STATE_NONE;
 882
 883         // Notify the UI thread that we are done.
 884         BrowserThread::PostTask(
 885             BrowserThread::UI, FROM_HERE,
 886             base::Bind(&BrowsingDataRemover::ClearedCache,
 887                        base::Unretained(this)));
 888         return;
 889       }
 890       default: {
 891         NOTREACHED() << "bad state";
 892         next_cache_state_ = STATE_NONE;  // Stop looping.
 893         return;
 894       }
 895     }
 896   }
 897 }
 898
 899 void BrowsingDataRemover::ClearedShaderCache() {
 900   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 901
 902   waiting_for_clear_shader_cache_ = false;
 903   NotifyAndDeleteIfDone();
 904 }
 905
 906 void BrowsingDataRemover::ClearShaderCacheOnUIThread() {
 907   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 908
 909   BrowserContext::GetDefaultStoragePartition(profile_)->ClearDataForRange(
 910       content::StoragePartition::REMOVE_DATA_MASK_SHADER_CACHE,
 911       content::StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL,
 912       delete_begin_, delete_end_,
 913       base::Bind(&BrowsingDataRemover::ClearedShaderCache,
 914                  base::Unretained(this)));
 915 }
 916
 917 #if !defined(DISABLE_NACL)
 918 void BrowsingDataRemover::ClearedNaClCache() {
 919   // This function should be called on the UI thread.
 920   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 921
 922   waiting_for_clear_nacl_cache_ = false;
 923
 924   NotifyAndDeleteIfDone();
 925 }
 926
 927 void BrowsingDataRemover::ClearedNaClCacheOnIOThread() {
 928   // This function should be called on the IO thread.
 929   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 930
 931   // Notify the UI thread that we are done.
 932   BrowserThread::PostTask(
 933       BrowserThread::UI, FROM_HERE,
 934       base::Bind(&BrowsingDataRemover::ClearedNaClCache,
 935                  base::Unretained(this)));
 936 }
 937
 938 void BrowsingDataRemover::ClearNaClCacheOnIOThread() {
 939   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 940
 941   nacl::NaClBrowser::GetInstance()->ClearValidationCache(
 942       base::Bind(&BrowsingDataRemover::ClearedNaClCacheOnIOThread,
 943                  base::Unretained(this)));
 944 }
 945
 946 void BrowsingDataRemover::ClearedPnaclCache() {
 947   // This function should be called on the UI thread.
 948   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 949
 950   waiting_for_clear_pnacl_cache_ = false;
 951
 952   NotifyAndDeleteIfDone();
 953 }
 954
 955 void BrowsingDataRemover::ClearedPnaclCacheOnIOThread() {
 956   // This function should be called on the IO thread.
 957   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 958
 959   // Notify the UI thread that we are done.
 960   BrowserThread::PostTask(
 961       BrowserThread::UI, FROM_HERE,
 962       base::Bind(&BrowsingDataRemover::ClearedPnaclCache,
 963                  base::Unretained(this)));
 964 }
 965
 966 void BrowsingDataRemover::ClearPnaclCacheOnIOThread(base::Time begin,
 967                                                     base::Time end) {
 968   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 969
 970   PnaclHost::GetInstance()->ClearTranslationCacheEntriesBetween(
 971       begin, end,
 972       base::Bind(&BrowsingDataRemover::ClearedPnaclCacheOnIOThread,
 973                  base::Unretained(this)));
 974 }
 975 #endif
 976
 977 void BrowsingDataRemover::ClearLocalStorageOnUIThread() {
 978   DCHECK(waiting_for_clear_local_storage_);
 979   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 980   dom_storage_context_->GetLocalStorageUsage(
 981       base::Bind(&BrowsingDataRemover::OnGotLocalStorageUsageInfo,
 982                  base::Unretained(this)));
 983 }
 984
 985 void BrowsingDataRemover::OnGotLocalStorageUsageInfo(
 986     const std::vector<content::LocalStorageUsageInfo>& infos) {
 987   DCHECK(waiting_for_clear_local_storage_);
 988   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 989
 990   for (size_t i = 0; i < infos.size(); ++i) {
 991     if (!BrowsingDataHelper::DoesOriginMatchMask(
 992             infos[i].origin, origin_set_mask_, special_storage_policy_.get()))
 993       continue;
 994
 995     if (infos[i].last_modified >= delete_begin_ &&
 996         infos[i].last_modified <= delete_end_) {
 997       dom_storage_context_->DeleteLocalStorage(infos[i].origin);
 998     }
 999   }
1000   waiting_for_clear_local_storage_ = false;
1001   NotifyAndDeleteIfDone();
1002 }
1003
1004 void BrowsingDataRemover::ClearSessionStorageOnUIThread() {
1005   DCHECK(waiting_for_clear_session_storage_);
1006   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1007
1008   dom_storage_context_->GetSessionStorageUsage(
1009       base::Bind(&BrowsingDataRemover::OnGotSessionStorageUsageInfo,
1010                  base::Unretained(this)));
1011 }
1012
1013 void BrowsingDataRemover::OnGotSessionStorageUsageInfo(
1014     const std::vector<content::SessionStorageUsageInfo>& infos) {
1015   DCHECK(waiting_for_clear_session_storage_);
1016   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1017
1018   for (size_t i = 0; i < infos.size(); ++i) {
1019     if (!BrowsingDataHelper::DoesOriginMatchMask(
1020             infos[i].origin, origin_set_mask_, special_storage_policy_.get()))
1021       continue;
1022
1023     dom_storage_context_->DeleteSessionStorage(infos[i]);
1024   }
1025   waiting_for_clear_session_storage_ = false;
1026   NotifyAndDeleteIfDone();
1027 }
1028
1029 void BrowsingDataRemover::ClearQuotaManagedDataOnIOThread() {
1030   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
1031
1032   // Ask the QuotaManager for all origins with temporary quota modified within
1033   // the user-specified timeframe, and deal with the resulting set in
1034   // OnGotQuotaManagedOrigins().
1035   quota_managed_origins_to_delete_count_ = 0;
1036   quota_managed_storage_types_to_delete_count_ = 0;
1037
1038   if (delete_begin_ == base::Time() ||
1039       origin_set_mask_ &
1040           (BrowsingDataHelper::PROTECTED_WEB | BrowsingDataHelper::EXTENSION)) {
1041     // If we're deleting since the beginning of time, or we're removing
1042     // protected origins, then ask the QuotaManager for all origins with
1043     // persistent quota modified within the user-specified timeframe, and deal
1044     // with the resulting set in OnGotQuotaManagedOrigins.
1045     ++quota_managed_storage_types_to_delete_count_;
1046     quota_manager_->GetOriginsModifiedSince(
1047         quota::kStorageTypePersistent, delete_begin_,
1048         base::Bind(&BrowsingDataRemover::OnGotQuotaManagedOrigins,
1049                    base::Unretained(this)));
1050   }
1051
1052   // Do the same for temporary quota.
1053   ++quota_managed_storage_types_to_delete_count_;
1054   quota_manager_->GetOriginsModifiedSince(
1055       quota::kStorageTypeTemporary, delete_begin_,
1056       base::Bind(&BrowsingDataRemover::OnGotQuotaManagedOrigins,
1057                  base::Unretained(this)));
1058
1059   // Do the same for syncable quota.
1060   ++quota_managed_storage_types_to_delete_count_;
1061   quota_manager_->GetOriginsModifiedSince(
1062       quota::kStorageTypeSyncable, delete_begin_,
1063       base::Bind(&BrowsingDataRemover::OnGotQuotaManagedOrigins,
1064                  base::Unretained(this)));
1065 }
1066
1067 void BrowsingDataRemover::OnGotQuotaManagedOrigins(
1068     const std::set<GURL>& origins, quota::StorageType type) {
1069   DCHECK_GT(quota_managed_storage_types_to_delete_count_, 0);
1070   // Walk through the origins passed in, delete quota of |type| from each that
1071   // matches the |origin_set_mask_|.
1072   std::set<GURL>::const_iterator origin;
1073   for (origin = origins.begin(); origin != origins.end(); ++origin) {
1074     // TODO(mkwst): Clean this up, it's slow. http://crbug.com/130746
1075     if (!remove_origin_.is_empty() && remove_origin_ != origin->GetOrigin())
1076       continue;
1077
1078     if (!BrowsingDataHelper::DoesOriginMatchMask(origin->GetOrigin(),
1079                                                  origin_set_mask_,
1080                                                  special_storage_policy_.get()))
1081       continue;
1082
1083     ++quota_managed_origins_to_delete_count_;
1084     quota_manager_->DeleteOriginData(
1085         origin->GetOrigin(), type,
1086         BrowsingDataRemover::GenerateQuotaClientMask(remove_mask_),
1087         base::Bind(&BrowsingDataRemover::OnQuotaManagedOriginDeletion,
1088                    base::Unretained(this), origin->GetOrigin(), type));
1089   }
1090
1091   --quota_managed_storage_types_to_delete_count_;
1092   CheckQuotaManagedDataDeletionStatus();
1093 }
1094
1095 void BrowsingDataRemover::OnQuotaManagedOriginDeletion(
1096     const GURL& origin,
1097     quota::StorageType type,
1098     quota::QuotaStatusCode status) {
1099   DCHECK_GT(quota_managed_origins_to_delete_count_, 0);
1100   if (status != quota::kQuotaStatusOk) {
1101     DLOG(ERROR) << "Couldn't remove data of type " << type << " for origin "
1102                 << origin << ". Status: " << status;
1103   }
1104
1105   --quota_managed_origins_to_delete_count_;
1106   CheckQuotaManagedDataDeletionStatus();
1107 }
1108
1109 void BrowsingDataRemover::CheckQuotaManagedDataDeletionStatus() {
1110   if (quota_managed_storage_types_to_delete_count_ != 0 ||
1111       quota_managed_origins_to_delete_count_ != 0) {
1112     return;
1113   }
1114
1115   BrowserThread::PostTask(
1116       BrowserThread::UI, FROM_HERE,
1117       base::Bind(&BrowsingDataRemover::OnQuotaManagedDataDeleted,
1118                  base::Unretained(this)));
1119 }
1120
1121 void BrowsingDataRemover::OnQuotaManagedDataDeleted() {
1122   DCHECK(waiting_for_clear_quota_managed_data_);
1123   waiting_for_clear_quota_managed_data_ = false;
1124   NotifyAndDeleteIfDone();
1125 }
1126
1127 void BrowsingDataRemover::OnWaitableEventSignaled(
1128     base::WaitableEvent* waitable_event) {
1129   waiting_for_clear_plugin_data_ = false;
1130   NotifyAndDeleteIfDone();
1131 }
1132
1133 #if defined(ENABLE_PLUGINS)
1134 void BrowsingDataRemover::OnDeauthorizeContentLicensesCompleted(
1135     uint32 request_id,
1136     bool /* success */) {
1137   DCHECK(waiting_for_clear_content_licenses_);
1138   DCHECK_EQ(request_id, deauthorize_content_licenses_request_id_);
1139
1140   waiting_for_clear_content_licenses_ = false;
1141   NotifyAndDeleteIfDone();
1142 }
1143 #endif
1144
1145 #if defined(OS_CHROMEOS)
1146 void BrowsingDataRemover::OnClearPlatformKeys(
1147     chromeos::DBusMethodCallStatus call_status,
1148     bool result) {
1149   DCHECK(waiting_for_clear_platform_keys_);
1150   if (call_status != chromeos::DBUS_METHOD_CALL_SUCCESS || !result) {
1151     LOG(ERROR) << "Failed to clear platform keys.";
1152   }
1153   waiting_for_clear_platform_keys_ = false;
1154   NotifyAndDeleteIfDone();
1155 }
1156 #endif
1157
1158 void BrowsingDataRemover::OnClearedCookies(int num_deleted) {
1159   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
1160     BrowserThread::PostTask(
1161         BrowserThread::UI, FROM_HERE,
1162         base::Bind(&BrowsingDataRemover::OnClearedCookies,
1163                    base::Unretained(this), num_deleted));
1164     return;
1165   }
1166
1167   DCHECK_GT(waiting_for_clear_cookies_count_, 0);
1168   --waiting_for_clear_cookies_count_;
1169   NotifyAndDeleteIfDone();
1170 }
1171
1172 void BrowsingDataRemover::ClearCookiesOnIOThread(
1173     net::URLRequestContextGetter* rq_context) {
1174   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
1175   net::CookieStore* cookie_store = rq_context->
1176       GetURLRequestContext()->cookie_store();
1177   cookie_store->DeleteAllCreatedBetweenAsync(
1178       delete_begin_, delete_end_,
1179       base::Bind(&BrowsingDataRemover::OnClearedCookies,
1180                  base::Unretained(this)));
1181 }
1182
1183 void BrowsingDataRemover::ClearServerBoundCertsOnIOThread(
1184     net::URLRequestContextGetter* rq_context) {
1185   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
1186   net::ServerBoundCertService* server_bound_cert_service =
1187       rq_context->GetURLRequestContext()->server_bound_cert_service();
1188   server_bound_cert_service->GetCertStore()->DeleteAllCreatedBetween(
1189       delete_begin_, delete_end_,
1190       base::Bind(&BrowsingDataRemover::OnClearedServerBoundCertsOnIOThread,
1191                  base::Unretained(this), base::Unretained(rq_context)));
1192 }
1193
1194 void BrowsingDataRemover::OnClearedServerBoundCertsOnIOThread(
1195     net::URLRequestContextGetter* rq_context) {
1196   // Need to close open SSL connections which may be using the channel ids we
1197   // are deleting.
1198   // TODO(mattm): http://crbug.com/166069 Make the server bound cert
1199   // service/store have observers that can notify relevant things directly.
1200   rq_context->GetURLRequestContext()->ssl_config_service()->
1201       NotifySSLConfigChange();
1202   BrowserThread::PostTask(
1203       BrowserThread::UI, FROM_HERE,
1204       base::Bind(&BrowsingDataRemover::OnClearedServerBoundCerts,
1205                  base::Unretained(this)));
1206 }
1207
1208 void BrowsingDataRemover::OnClearedServerBoundCerts() {
1209   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1210   waiting_for_clear_server_bound_certs_ = false;
1211   NotifyAndDeleteIfDone();
1212 }
1213
1214 void BrowsingDataRemover::OnClearedFormData() {
1215   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1216   waiting_for_clear_form_ = false;
1217   NotifyAndDeleteIfDone();
1218 }
1219
1220 void BrowsingDataRemover::OnClearedAutofillOriginURLs() {
1221   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1222   waiting_for_clear_autofill_origin_urls_ = false;
1223   NotifyAndDeleteIfDone();
1224 }
1225
1226 void BrowsingDataRemover::OnClearWebRTCIdentityStore() {
1227   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1228   waiting_for_clear_webrtc_identity_store_ = false;
1229   NotifyAndDeleteIfDone();
1230 }