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