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/content_settings/host_content_settings_map.h"
  25 #include "chrome/browser/download/download_prefs.h"
  26 #include "chrome/browser/download/download_service_factory.h"
  27 #include "chrome/browser/extensions/activity_log/activity_log.h"
  28 #include "chrome/browser/extensions/extension_service.h"
  29 #include "chrome/browser/extensions/extension_special_storage_policy.h"
  30 #include "chrome/browser/history/history_service.h"
  31 #include "chrome/browser/history/history_service_factory.h"
  32 #include "chrome/browser/io_thread.h"
  33 #include "chrome/browser/media/media_device_id_salt.h"
  34 #if defined(ENABLE_WEBRTC)
  35 #include "chrome/browser/media/webrtc_log_list.h"
  36 #include "chrome/browser/media/webrtc_log_util.h"
  37 #endif
  38 #include "chrome/browser/net/chrome_url_request_context.h"
  39 #include "chrome/browser/net/predictor.h"
  40 #include "chrome/browser/password_manager/password_store_factory.h"
  41 #include "chrome/browser/predictors/logged_in_predictor_table.h"
  42 #include "chrome/browser/predictors/predictor_database.h"
  43 #include "chrome/browser/predictors/predictor_database_factory.h"
  44 #include "chrome/browser/prerender/prerender_manager.h"
  45 #include "chrome/browser/prerender/prerender_manager_factory.h"
  46 #include "chrome/browser/profiles/profile.h"
  47 #include "chrome/browser/renderer_host/web_cache_manager.h"
  48 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
  49 #include "chrome/browser/search_engines/template_url_service.h"
  50 #include "chrome/browser/search_engines/template_url_service_factory.h"
  51 #include "chrome/browser/sessions/session_service.h"
  52 #include "chrome/browser/sessions/session_service_factory.h"
  53 #include "chrome/browser/sessions/tab_restore_service.h"
  54 #include "chrome/browser/sessions/tab_restore_service_factory.h"
  55 #include "chrome/browser/webdata/web_data_service_factory.h"
  56 #include "chrome/common/pref_names.h"
  57 #include "chrome/common/url_constants.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 // Helper to create callback for BrowsingDataRemover::DoesOriginMatchMask.
  98 // Static.
  99 bool DoesOriginMatchMask(int origin_set_mask,
 100                          const GURL& origin,
 101                          quota::SpecialStoragePolicy* special_storage_policy) {
 102   return BrowsingDataHelper::DoesOriginMatchMask(
 103       origin, origin_set_mask,
 104       static_cast<ExtensionSpecialStoragePolicy*>(special_storage_policy));
 105 }
 106
 107 BrowsingDataRemover::NotificationDetails::NotificationDetails()
 108     : removal_begin(base::Time()),
 109       removal_mask(-1),
 110       origin_set_mask(-1) {
 111 }
 112
 113 BrowsingDataRemover::NotificationDetails::NotificationDetails(
 114     const BrowsingDataRemover::NotificationDetails& details)
 115     : removal_begin(details.removal_begin),
 116       removal_mask(details.removal_mask),
 117       origin_set_mask(details.origin_set_mask) {
 118 }
 119
 120 BrowsingDataRemover::NotificationDetails::NotificationDetails(
 121     base::Time removal_begin,
 122     int removal_mask,
 123     int origin_set_mask)
 124     : removal_begin(removal_begin),
 125       removal_mask(removal_mask),
 126       origin_set_mask(origin_set_mask) {
 127 }
 128
 129 BrowsingDataRemover::NotificationDetails::~NotificationDetails() {}
 130
 131 // Static.
 132 BrowsingDataRemover* BrowsingDataRemover::CreateForUnboundedRange(
 133     Profile* profile) {
 134   return new BrowsingDataRemover(profile, base::Time(), base::Time::Max());
 135 }
 136
 137 // Static.
 138 BrowsingDataRemover* BrowsingDataRemover::CreateForRange(Profile* profile,
 139     base::Time start, base::Time end) {
 140   return new BrowsingDataRemover(profile, start, end);
 141 }
 142
 143 // Static.
 144 BrowsingDataRemover* BrowsingDataRemover::CreateForPeriod(Profile* profile,
 145     TimePeriod period) {
 146   switch (period) {
 147     case LAST_HOUR:
 148       content::RecordAction(
 149           UserMetricsAction("ClearBrowsingData_LastHour"));
 150       break;
 151     case LAST_DAY:
 152       content::RecordAction(
 153           UserMetricsAction("ClearBrowsingData_LastDay"));
 154       break;
 155     case LAST_WEEK:
 156       content::RecordAction(
 157           UserMetricsAction("ClearBrowsingData_LastWeek"));
 158       break;
 159     case FOUR_WEEKS:
 160       content::RecordAction(
 161           UserMetricsAction("ClearBrowsingData_LastMonth"));
 162       break;
 163     case EVERYTHING:
 164       content::RecordAction(
 165           UserMetricsAction("ClearBrowsingData_Everything"));
 166       break;
 167   }
 168   return new BrowsingDataRemover(profile,
 169       BrowsingDataRemover::CalculateBeginDeleteTime(period),
 170       base::Time::Max());
 171 }
 172
 173 BrowsingDataRemover::BrowsingDataRemover(Profile* profile,
 174                                          base::Time delete_begin,
 175                                          base::Time delete_end)
 176     : profile_(profile),
 177       special_storage_policy_(profile->GetExtensionSpecialStoragePolicy()),
 178       delete_begin_(delete_begin),
 179       delete_end_(delete_end),
 180       next_cache_state_(STATE_NONE),
 181       cache_(NULL),
 182       main_context_getter_(profile->GetRequestContext()),
 183       media_context_getter_(profile->GetMediaRequestContext()),
 184       deauthorize_content_licenses_request_id_(0),
 185       waiting_for_clear_autofill_origin_urls_(false),
 186       waiting_for_clear_cache_(false),
 187       waiting_for_clear_content_licenses_(false),
 188       waiting_for_clear_cookies_count_(0),
 189       waiting_for_clear_form_(false),
 190       waiting_for_clear_history_(false),
 191       waiting_for_clear_hostname_resolution_cache_(false),
 192       waiting_for_clear_keyword_data_(false),
 193       waiting_for_clear_logged_in_predictor_(false),
 194       waiting_for_clear_nacl_cache_(false),
 195       waiting_for_clear_network_predictor_(false),
 196       waiting_for_clear_networking_history_(false),
 197       waiting_for_clear_platform_keys_(false),
 198       waiting_for_clear_plugin_data_(false),
 199       waiting_for_clear_pnacl_cache_(false),
 200       waiting_for_clear_server_bound_certs_(false),
 201       waiting_for_clear_storage_partition_data_(false),
 202 #if defined(ENABLE_WEBRTC)
 203       waiting_for_clear_webrtc_logs_(false),
 204 #endif
 205       remove_mask_(0),
 206       remove_origin_(GURL()),
 207       origin_set_mask_(0),
 208       storage_partition_for_testing_(NULL) {
 209   DCHECK(profile);
 210   // crbug.com/140910: Many places were calling this with base::Time() as
 211   // delete_end, even though they should've used base::Time::Max(). Work around
 212   // it here. New code should use base::Time::Max().
 213   DCHECK(delete_end_ != base::Time());
 214   if (delete_end_ == base::Time())
 215     delete_end_ = base::Time::Max();
 216 }
 217
 218 BrowsingDataRemover::~BrowsingDataRemover() {
 219   DCHECK(AllDone());
 220 }
 221
 222 // Static.
 223 void BrowsingDataRemover::set_removing(bool is_removing) {
 224   DCHECK(is_removing_ != is_removing);
 225   is_removing_ = is_removing;
 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         WebDataServiceFactory::GetAutofillWebDataForProfile(
 366             profile_, Profile::EXPLICIT_ACCESS);
 367     if (web_data_service.get()) {
 368       waiting_for_clear_autofill_origin_urls_ = true;
 369       web_data_service->RemoveOriginURLsModifiedBetween(
 370           delete_begin_, delete_end_);
 371       // The above calls are done on the UI thread but do their work on the DB
 372       // thread. So wait for it.
 373       BrowserThread::PostTaskAndReply(
 374           BrowserThread::DB, FROM_HERE,
 375           base::Bind(&base::DoNothing),
 376           base::Bind(&BrowsingDataRemover::OnClearedAutofillOriginURLs,
 377                      base::Unretained(this)));
 378
 379       autofill::PersonalDataManager* data_manager =
 380           autofill::PersonalDataManagerFactory::GetForProfile(profile_);
 381       if (data_manager)
 382         data_manager->Refresh();
 383     }
 384
 385 #if defined(ENABLE_WEBRTC)
 386     waiting_for_clear_webrtc_logs_ = true;
 387     BrowserThread::PostTaskAndReply(
 388         BrowserThread::FILE,
 389         FROM_HERE,
 390         base::Bind(
 391             &WebRtcLogUtil::DeleteOldAndRecentWebRtcLogFiles,
 392             WebRtcLogList::GetWebRtcLogDirectoryForProfile(profile_->GetPath()),
 393             delete_begin_),
 394         base::Bind(&BrowsingDataRemover::OnClearedWebRtcLogs,
 395                    base::Unretained(this)));
 396 #endif
 397   }
 398
 399   if ((remove_mask & REMOVE_DOWNLOADS) && may_delete_history) {
 400     content::RecordAction(UserMetricsAction("ClearBrowsingData_Downloads"));
 401     content::DownloadManager* download_manager =
 402         BrowserContext::GetDownloadManager(profile_);
 403     download_manager->RemoveDownloadsBetween(delete_begin_, delete_end_);
 404     DownloadPrefs* download_prefs = DownloadPrefs::FromDownloadManager(
 405         download_manager);
 406     download_prefs->SetSaveFilePath(download_prefs->DownloadPath());
 407   }
 408
 409   uint32 storage_partition_remove_mask = 0;
 410
 411   // We ignore the REMOVE_COOKIES request if UNPROTECTED_WEB is not set,
 412   // so that callers who request REMOVE_SITE_DATA with PROTECTED_WEB
 413   // don't accidentally remove the cookies that are associated with the
 414   // UNPROTECTED_WEB origin. This is necessary because cookies are not separated
 415   // between UNPROTECTED_WEB and PROTECTED_WEB.
 416   if (remove_mask & REMOVE_COOKIES &&
 417       origin_set_mask_ & BrowsingDataHelper::UNPROTECTED_WEB) {
 418     content::RecordAction(UserMetricsAction("ClearBrowsingData_Cookies"));
 419
 420     storage_partition_remove_mask |=
 421         content::StoragePartition::REMOVE_DATA_MASK_COOKIES;
 422
 423     // Also delete the LoggedIn Predictor, which tries to keep track of which
 424     // sites a user is logged into.
 425     ClearLoggedInPredictor();
 426
 427 #if defined(FULL_SAFE_BROWSING) || defined(MOBILE_SAFE_BROWSING)
 428     // Clear the safebrowsing cookies only if time period is for "all time".  It
 429     // doesn't make sense to apply the time period of deleting in the last X
 430     // hours/days to the safebrowsing cookies since they aren't the result of
 431     // any user action.
 432     if (delete_begin_ == base::Time()) {
 433       SafeBrowsingService* sb_service =
 434           g_browser_process->safe_browsing_service();
 435       if (sb_service) {
 436         net::URLRequestContextGetter* sb_context =
 437             sb_service->url_request_context();
 438         ++waiting_for_clear_cookies_count_;
 439         BrowserThread::PostTask(
 440             BrowserThread::IO, FROM_HERE,
 441             base::Bind(&BrowsingDataRemover::ClearCookiesOnIOThread,
 442                        base::Unretained(this), base::Unretained(sb_context)));
 443       }
 444     }
 445 #endif
 446     MediaDeviceIDSalt::Reset(profile_->GetPrefs());
 447   }
 448
 449   // Server bound certs are not separated for protected and unprotected web
 450   // origins. We check the origin_set_mask_ to prevent unintended deletion.
 451   if (remove_mask & REMOVE_SERVER_BOUND_CERTS &&
 452       origin_set_mask_ & BrowsingDataHelper::UNPROTECTED_WEB) {
 453     content::RecordAction(
 454         UserMetricsAction("ClearBrowsingData_ServerBoundCerts"));
 455     // Since we are running on the UI thread don't call GetURLRequestContext().
 456     net::URLRequestContextGetter* rq_context = profile_->GetRequestContext();
 457     if (rq_context) {
 458       waiting_for_clear_server_bound_certs_ = true;
 459       BrowserThread::PostTask(
 460           BrowserThread::IO, FROM_HERE,
 461           base::Bind(&BrowsingDataRemover::ClearServerBoundCertsOnIOThread,
 462                      base::Unretained(this), base::Unretained(rq_context)));
 463     }
 464   }
 465
 466   if (remove_mask & REMOVE_LOCAL_STORAGE) {
 467     storage_partition_remove_mask |=
 468         content::StoragePartition::REMOVE_DATA_MASK_LOCAL_STORAGE;
 469   }
 470
 471   if (remove_mask & REMOVE_INDEXEDDB) {
 472     storage_partition_remove_mask |=
 473         content::StoragePartition::REMOVE_DATA_MASK_INDEXEDDB;
 474   }
 475   if (remove_mask & REMOVE_WEBSQL) {
 476     storage_partition_remove_mask |=
 477         content::StoragePartition::REMOVE_DATA_MASK_WEBSQL;
 478   }
 479   if (remove_mask & REMOVE_APPCACHE) {
 480     storage_partition_remove_mask |=
 481         content::StoragePartition::REMOVE_DATA_MASK_APPCACHE;
 482   }
 483   if (remove_mask & REMOVE_FILE_SYSTEMS) {
 484     storage_partition_remove_mask |=
 485         content::StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS;
 486   }
 487
 488 #if defined(ENABLE_PLUGINS)
 489   // Plugin is data not separated for protected and unprotected web origins. We
 490   // check the origin_set_mask_ to prevent unintended deletion.
 491   if (remove_mask & REMOVE_PLUGIN_DATA &&
 492       origin_set_mask_ & BrowsingDataHelper::UNPROTECTED_WEB) {
 493     content::RecordAction(UserMetricsAction("ClearBrowsingData_LSOData"));
 494
 495     waiting_for_clear_plugin_data_ = true;
 496     if (!plugin_data_remover_.get())
 497       plugin_data_remover_.reset(content::PluginDataRemover::Create(profile_));
 498     base::WaitableEvent* event =
 499         plugin_data_remover_->StartRemoving(delete_begin_);
 500
 501     base::WaitableEventWatcher::EventCallback watcher_callback =
 502         base::Bind(&BrowsingDataRemover::OnWaitableEventSignaled,
 503                    base::Unretained(this));
 504     watcher_.StartWatching(event, watcher_callback);
 505   }
 506 #endif
 507
 508 #if defined(OS_ANDROID)
 509   if (remove_mask & REMOVE_APP_BANNER_DATA) {
 510     profile_->GetHostContentSettingsMap()->ClearSettingsForOneType(
 511         CONTENT_SETTINGS_TYPE_APP_BANNER);
 512   }
 513 #endif
 514
 515   if (remove_mask & REMOVE_PASSWORDS) {
 516     content::RecordAction(UserMetricsAction("ClearBrowsingData_Passwords"));
 517     password_manager::PasswordStore* password_store =
 518         PasswordStoreFactory::GetForProfile(profile_, Profile::EXPLICIT_ACCESS)
 519             .get();
 520
 521     if (password_store)
 522       password_store->RemoveLoginsCreatedBetween(delete_begin_, delete_end_);
 523   }
 524
 525   if (remove_mask & REMOVE_FORM_DATA) {
 526     content::RecordAction(UserMetricsAction("ClearBrowsingData_Autofill"));
 527     scoped_refptr<autofill::AutofillWebDataService> web_data_service =
 528         WebDataServiceFactory::GetAutofillWebDataForProfile(
 529             profile_, Profile::EXPLICIT_ACCESS);
 530
 531     if (web_data_service.get()) {
 532       waiting_for_clear_form_ = true;
 533       web_data_service->RemoveFormElementsAddedBetween(delete_begin_,
 534           delete_end_);
 535       web_data_service->RemoveAutofillDataModifiedBetween(
 536           delete_begin_, delete_end_);
 537       // The above calls are done on the UI thread but do their work on the DB
 538       // thread. So wait for it.
 539       BrowserThread::PostTaskAndReply(
 540           BrowserThread::DB, FROM_HERE,
 541           base::Bind(&base::DoNothing),
 542           base::Bind(&BrowsingDataRemover::OnClearedFormData,
 543                      base::Unretained(this)));
 544
 545       autofill::PersonalDataManager* data_manager =
 546           autofill::PersonalDataManagerFactory::GetForProfile(profile_);
 547       if (data_manager)
 548         data_manager->Refresh();
 549     }
 550   }
 551
 552   if (remove_mask & REMOVE_CACHE) {
 553     // Tell the renderers to clear their cache.
 554     WebCacheManager::GetInstance()->ClearCache();
 555
 556     // Invoke DoClearCache on the IO thread.
 557     waiting_for_clear_cache_ = true;
 558     content::RecordAction(UserMetricsAction("ClearBrowsingData_Cache"));
 559
 560     BrowserThread::PostTask(
 561         BrowserThread::IO, FROM_HERE,
 562         base::Bind(&BrowsingDataRemover::ClearCacheOnIOThread,
 563                    base::Unretained(this)));
 564
 565 #if !defined(DISABLE_NACL)
 566     waiting_for_clear_nacl_cache_ = true;
 567
 568     BrowserThread::PostTask(
 569         BrowserThread::IO, FROM_HERE,
 570         base::Bind(&BrowsingDataRemover::ClearNaClCacheOnIOThread,
 571                    base::Unretained(this)));
 572
 573     waiting_for_clear_pnacl_cache_ = true;
 574     BrowserThread::PostTask(
 575         BrowserThread::IO, FROM_HERE,
 576         base::Bind(&BrowsingDataRemover::ClearPnaclCacheOnIOThread,
 577                    base::Unretained(this), delete_begin_, delete_end_));
 578 #endif
 579
 580     // The PrerenderManager may have a page actively being prerendered, which
 581     // is essentially a preemptively cached page.
 582     prerender::PrerenderManager* prerender_manager =
 583         prerender::PrerenderManagerFactory::GetForProfile(profile_);
 584     if (prerender_manager) {
 585       prerender_manager->ClearData(
 586           prerender::PrerenderManager::CLEAR_PRERENDER_CONTENTS);
 587     }
 588
 589     // Tell the shader disk cache to clear.
 590     content::RecordAction(UserMetricsAction("ClearBrowsingData_ShaderCache"));
 591     storage_partition_remove_mask |=
 592         content::StoragePartition::REMOVE_DATA_MASK_SHADER_CACHE;
 593
 594     storage_partition_remove_mask |=
 595         content::StoragePartition::REMOVE_DATA_MASK_WEBRTC_IDENTITY;
 596   }
 597
 598   if (storage_partition_remove_mask) {
 599     waiting_for_clear_storage_partition_data_ = true;
 600
 601     content::StoragePartition* storage_partition;
 602     if (storage_partition_for_testing_)
 603       storage_partition = storage_partition_for_testing_;
 604     else
 605       storage_partition = BrowserContext::GetDefaultStoragePartition(profile_);
 606
 607     uint32 quota_storage_remove_mask =
 608         ~content::StoragePartition::QUOTA_MANAGED_STORAGE_MASK_PERSISTENT;
 609
 610     if (delete_begin_ == base::Time() ||
 611         origin_set_mask_ &
 612           (BrowsingDataHelper::PROTECTED_WEB | BrowsingDataHelper::EXTENSION)) {
 613       // If we're deleting since the beginning of time, or we're removing
 614       // protected origins, then remove persistent quota data.
 615       quota_storage_remove_mask |=
 616           content::StoragePartition::QUOTA_MANAGED_STORAGE_MASK_PERSISTENT;
 617     }
 618
 619     storage_partition->ClearData(
 620         storage_partition_remove_mask,
 621         quota_storage_remove_mask,
 622         remove_origin_,
 623         base::Bind(&DoesOriginMatchMask, origin_set_mask_),
 624         delete_begin_,
 625         delete_end_,
 626         base::Bind(&BrowsingDataRemover::OnClearedStoragePartitionData,
 627                    base::Unretained(this)));
 628   }
 629
 630 #if defined(ENABLE_PLUGINS)
 631   if (remove_mask & REMOVE_CONTENT_LICENSES) {
 632     content::RecordAction(
 633         UserMetricsAction("ClearBrowsingData_ContentLicenses"));
 634
 635     waiting_for_clear_content_licenses_ = true;
 636     if (!pepper_flash_settings_manager_.get()) {
 637       pepper_flash_settings_manager_.reset(
 638           new PepperFlashSettingsManager(this, profile_));
 639     }
 640     deauthorize_content_licenses_request_id_ =
 641         pepper_flash_settings_manager_->DeauthorizeContentLicenses(prefs);
 642 #if defined(OS_CHROMEOS)
 643     // On Chrome OS, also delete any content protection platform keys.
 644     chromeos::User* user = chromeos::UserManager::Get()->
 645         GetUserByProfile(profile_);
 646     if (!user) {
 647       LOG(WARNING) << "Failed to find user for current profile.";
 648     } else {
 649       chromeos::DBusThreadManager::Get()->GetCryptohomeClient()->
 650           TpmAttestationDeleteKeys(
 651               chromeos::attestation::KEY_USER,
 652               user->email(),
 653               chromeos::attestation::kContentProtectionKeyPrefix,
 654               base::Bind(&BrowsingDataRemover::OnClearPlatformKeys,
 655                          base::Unretained(this)));
 656       waiting_for_clear_platform_keys_ = true;
 657     }
 658 #endif
 659   }
 660 #endif
 661
 662   // Remove omnibox zero-suggest cache results.
 663   if ((remove_mask & (REMOVE_CACHE | REMOVE_COOKIES)))
 664     prefs->SetString(prefs::kZeroSuggestCachedResults, std::string());
 665
 666   // Always wipe accumulated network related data (TransportSecurityState and
 667   // HttpServerPropertiesManager data).
 668   waiting_for_clear_networking_history_ = true;
 669   profile_->ClearNetworkingHistorySince(
 670       delete_begin_,
 671       base::Bind(&BrowsingDataRemover::OnClearedNetworkingHistory,
 672                  base::Unretained(this)));
 673 }
 674
 675 void BrowsingDataRemover::AddObserver(Observer* observer) {
 676   observer_list_.AddObserver(observer);
 677 }
 678
 679 void BrowsingDataRemover::RemoveObserver(Observer* observer) {
 680   observer_list_.RemoveObserver(observer);
 681 }
 682
 683 void BrowsingDataRemover::OnHistoryDeletionDone() {
 684   waiting_for_clear_history_ = false;
 685   NotifyAndDeleteIfDone();
 686 }
 687
 688 void BrowsingDataRemover::OverrideStoragePartitionForTesting(
 689     content::StoragePartition* storage_partition) {
 690   storage_partition_for_testing_ = storage_partition;
 691 }
 692
 693 base::Time BrowsingDataRemover::CalculateBeginDeleteTime(
 694     TimePeriod time_period) {
 695   base::TimeDelta diff;
 696   base::Time delete_begin_time = base::Time::Now();
 697   switch (time_period) {
 698     case LAST_HOUR:
 699       diff = base::TimeDelta::FromHours(1);
 700       break;
 701     case LAST_DAY:
 702       diff = base::TimeDelta::FromHours(24);
 703       break;
 704     case LAST_WEEK:
 705       diff = base::TimeDelta::FromHours(7*24);
 706       break;
 707     case FOUR_WEEKS:
 708       diff = base::TimeDelta::FromHours(4*7*24);
 709       break;
 710     case EVERYTHING:
 711       delete_begin_time = base::Time();
 712       break;
 713     default:
 714       NOTREACHED() << L"Missing item";
 715       break;
 716   }
 717   return delete_begin_time - diff;
 718 }
 719
 720 bool BrowsingDataRemover::AllDone() {
 721   return !waiting_for_clear_keyword_data_ &&
 722          !waiting_for_clear_autofill_origin_urls_ &&
 723          !waiting_for_clear_cache_ && !waiting_for_clear_nacl_cache_ &&
 724          !waiting_for_clear_cookies_count_ && !waiting_for_clear_history_ &&
 725          !waiting_for_clear_logged_in_predictor_ &&
 726          !waiting_for_clear_networking_history_ &&
 727          !waiting_for_clear_server_bound_certs_ &&
 728          !waiting_for_clear_plugin_data_ &&
 729          !waiting_for_clear_pnacl_cache_ &&
 730          !waiting_for_clear_content_licenses_ && !waiting_for_clear_form_ &&
 731          !waiting_for_clear_hostname_resolution_cache_ &&
 732          !waiting_for_clear_network_predictor_ &&
 733          !waiting_for_clear_platform_keys_ &&
 734 #if defined(ENABLE_WEBRTC)
 735          !waiting_for_clear_webrtc_logs_ &&
 736 #endif
 737          !waiting_for_clear_storage_partition_data_;
 738 }
 739
 740 void BrowsingDataRemover::OnKeywordsLoaded() {
 741   // Deletes the entries from the model, and if we're not waiting on anything
 742   // else notifies observers and deletes this BrowsingDataRemover.
 743   TemplateURLService* model =
 744       TemplateURLServiceFactory::GetForProfile(profile_);
 745   DCHECK_EQ(profile_, model->profile());
 746   model->RemoveAutoGeneratedBetween(delete_begin_, delete_end_);
 747   waiting_for_clear_keyword_data_ = false;
 748   template_url_sub_.reset();
 749   NotifyAndDeleteIfDone();
 750 }
 751
 752 void BrowsingDataRemover::NotifyAndDeleteIfDone() {
 753   // TODO(brettw) http://crbug.com/305259: This should also observe session
 754   // clearing (what about other things such as passwords, etc.?) and wait for
 755   // them to complete before continuing.
 756
 757   if (!AllDone())
 758     return;
 759
 760   set_removing(false);
 761
 762   // Send global notification, then notify any explicit observers.
 763   BrowsingDataRemover::NotificationDetails details(delete_begin_, remove_mask_,
 764       origin_set_mask_);
 765   content::NotificationService::current()->Notify(
 766       chrome::NOTIFICATION_BROWSING_DATA_REMOVED,
 767       content::Source<Profile>(profile_),
 768       content::Details<BrowsingDataRemover::NotificationDetails>(&details));
 769
 770   FOR_EACH_OBSERVER(Observer, observer_list_, OnBrowsingDataRemoverDone());
 771
 772   // History requests aren't happy if you delete yourself from the callback.
 773   // As such, we do a delete later.
 774   base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);
 775 }
 776
 777 void BrowsingDataRemover::OnClearedHostnameResolutionCache() {
 778   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 779   waiting_for_clear_hostname_resolution_cache_ = false;
 780   NotifyAndDeleteIfDone();
 781 }
 782
 783 void BrowsingDataRemover::ClearHostnameResolutionCacheOnIOThread(
 784     IOThread* io_thread) {
 785   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 786
 787   io_thread->ClearHostCache();
 788
 789   // Notify the UI thread that we are done.
 790   BrowserThread::PostTask(
 791       BrowserThread::UI,
 792       FROM_HERE,
 793       base::Bind(&BrowsingDataRemover::OnClearedHostnameResolutionCache,
 794                  base::Unretained(this)));
 795 }
 796
 797 void BrowsingDataRemover::OnClearedLoggedInPredictor() {
 798   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 799   DCHECK(waiting_for_clear_logged_in_predictor_);
 800   waiting_for_clear_logged_in_predictor_ = false;
 801   NotifyAndDeleteIfDone();
 802 }
 803
 804 void BrowsingDataRemover::ClearLoggedInPredictor() {
 805   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 806   DCHECK(!waiting_for_clear_logged_in_predictor_);
 807
 808   predictors::PredictorDatabase* predictor_db =
 809       predictors::PredictorDatabaseFactory::GetForProfile(profile_);
 810   if (!predictor_db)
 811     return;
 812
 813   predictors::LoggedInPredictorTable* logged_in_table =
 814       predictor_db->logged_in_table().get();
 815   if (!logged_in_table)
 816     return;
 817
 818   waiting_for_clear_logged_in_predictor_ = true;
 819
 820   BrowserThread::PostTaskAndReply(
 821       BrowserThread::DB,
 822       FROM_HERE,
 823       base::Bind(&predictors::LoggedInPredictorTable::DeleteAllCreatedBetween,
 824                  logged_in_table,
 825                  delete_begin_,
 826                  delete_end_),
 827       base::Bind(&BrowsingDataRemover::OnClearedLoggedInPredictor,
 828                  base::Unretained(this)));
 829 }
 830
 831 void BrowsingDataRemover::OnClearedNetworkPredictor() {
 832   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 833   waiting_for_clear_network_predictor_ = false;
 834   NotifyAndDeleteIfDone();
 835 }
 836
 837 void BrowsingDataRemover::ClearNetworkPredictorOnIOThread() {
 838   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 839
 840   chrome_browser_net::Predictor* predictor = profile_->GetNetworkPredictor();
 841   if (predictor) {
 842     predictor->DiscardInitialNavigationHistory();
 843     predictor->DiscardAllResults();
 844   }
 845
 846   // Notify the UI thread that we are done.
 847   BrowserThread::PostTask(
 848       BrowserThread::UI,
 849       FROM_HERE,
 850       base::Bind(&BrowsingDataRemover::OnClearedNetworkPredictor,
 851                  base::Unretained(this)));
 852 }
 853
 854 void BrowsingDataRemover::OnClearedNetworkingHistory() {
 855   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 856   waiting_for_clear_networking_history_ = false;
 857   NotifyAndDeleteIfDone();
 858 }
 859
 860 void BrowsingDataRemover::ClearedCache() {
 861   waiting_for_clear_cache_ = false;
 862
 863   NotifyAndDeleteIfDone();
 864 }
 865
 866 void BrowsingDataRemover::ClearCacheOnIOThread() {
 867   // This function should be called on the IO thread.
 868   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 869   DCHECK_EQ(STATE_NONE, next_cache_state_);
 870   DCHECK(main_context_getter_.get());
 871   DCHECK(media_context_getter_.get());
 872
 873   next_cache_state_ = STATE_CREATE_MAIN;
 874   DoClearCache(net::OK);
 875 }
 876
 877 // The expected state sequence is STATE_NONE --> STATE_CREATE_MAIN -->
 878 // STATE_DELETE_MAIN --> STATE_CREATE_MEDIA --> STATE_DELETE_MEDIA -->
 879 // STATE_DONE, and any errors are ignored.
 880 void BrowsingDataRemover::DoClearCache(int rv) {
 881   DCHECK_NE(STATE_NONE, next_cache_state_);
 882
 883   while (rv != net::ERR_IO_PENDING && next_cache_state_ != STATE_NONE) {
 884     switch (next_cache_state_) {
 885       case STATE_CREATE_MAIN:
 886       case STATE_CREATE_MEDIA: {
 887         // Get a pointer to the cache.
 888         net::URLRequestContextGetter* getter =
 889             (next_cache_state_ == STATE_CREATE_MAIN)
 890                 ? main_context_getter_.get()
 891                 : media_context_getter_.get();
 892         net::HttpCache* http_cache =
 893             getter->GetURLRequestContext()->http_transaction_factory()->
 894                 GetCache();
 895
 896         next_cache_state_ = (next_cache_state_ == STATE_CREATE_MAIN) ?
 897                                 STATE_DELETE_MAIN : STATE_DELETE_MEDIA;
 898
 899         // Clear QUIC server information from memory and the disk cache.
 900         http_cache->GetSession()->quic_stream_factory()->
 901             ClearCachedStatesInCryptoConfig();
 902         rv = http_cache->GetBackend(
 903             &cache_, base::Bind(&BrowsingDataRemover::DoClearCache,
 904                                 base::Unretained(this)));
 905         break;
 906       }
 907       case STATE_DELETE_MAIN:
 908       case STATE_DELETE_MEDIA: {
 909         next_cache_state_ = (next_cache_state_ == STATE_DELETE_MAIN) ?
 910                                 STATE_CREATE_MEDIA : STATE_DONE;
 911
 912         // |cache_| can be null if it cannot be initialized.
 913         if (cache_) {
 914           if (delete_begin_.is_null()) {
 915             rv = cache_->DoomAllEntries(
 916                 base::Bind(&BrowsingDataRemover::DoClearCache,
 917                            base::Unretained(this)));
 918           } else {
 919             rv = cache_->DoomEntriesBetween(
 920                 delete_begin_, delete_end_,
 921                 base::Bind(&BrowsingDataRemover::DoClearCache,
 922                            base::Unretained(this)));
 923           }
 924           cache_ = NULL;
 925         }
 926         break;
 927       }
 928       case STATE_DONE: {
 929         cache_ = NULL;
 930         next_cache_state_ = STATE_NONE;
 931
 932         // Notify the UI thread that we are done.
 933         BrowserThread::PostTask(
 934             BrowserThread::UI, FROM_HERE,
 935             base::Bind(&BrowsingDataRemover::ClearedCache,
 936                        base::Unretained(this)));
 937         return;
 938       }
 939       default: {
 940         NOTREACHED() << "bad state";
 941         next_cache_state_ = STATE_NONE;  // Stop looping.
 942         return;
 943       }
 944     }
 945   }
 946 }
 947
 948 #if !defined(DISABLE_NACL)
 949 void BrowsingDataRemover::ClearedNaClCache() {
 950   // This function should be called on the UI thread.
 951   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 952
 953   waiting_for_clear_nacl_cache_ = false;
 954
 955   NotifyAndDeleteIfDone();
 956 }
 957
 958 void BrowsingDataRemover::ClearedNaClCacheOnIOThread() {
 959   // This function should be called on the IO thread.
 960   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 961
 962   // Notify the UI thread that we are done.
 963   BrowserThread::PostTask(
 964       BrowserThread::UI, FROM_HERE,
 965       base::Bind(&BrowsingDataRemover::ClearedNaClCache,
 966                  base::Unretained(this)));
 967 }
 968
 969 void BrowsingDataRemover::ClearNaClCacheOnIOThread() {
 970   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 971
 972   nacl::NaClBrowser::GetInstance()->ClearValidationCache(
 973       base::Bind(&BrowsingDataRemover::ClearedNaClCacheOnIOThread,
 974                  base::Unretained(this)));
 975 }
 976
 977 void BrowsingDataRemover::ClearedPnaclCache() {
 978   // This function should be called on the UI thread.
 979   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 980
 981   waiting_for_clear_pnacl_cache_ = false;
 982
 983   NotifyAndDeleteIfDone();
 984 }
 985
 986 void BrowsingDataRemover::ClearedPnaclCacheOnIOThread() {
 987   // This function should be called on the IO thread.
 988   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 989
 990   // Notify the UI thread that we are done.
 991   BrowserThread::PostTask(
 992       BrowserThread::UI, FROM_HERE,
 993       base::Bind(&BrowsingDataRemover::ClearedPnaclCache,
 994                  base::Unretained(this)));
 995 }
 996
 997 void BrowsingDataRemover::ClearPnaclCacheOnIOThread(base::Time begin,
 998                                                     base::Time end) {
 999   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
1000
1001   pnacl::PnaclHost::GetInstance()->ClearTranslationCacheEntriesBetween(
1002       begin, end,
1003       base::Bind(&BrowsingDataRemover::ClearedPnaclCacheOnIOThread,
1004                  base::Unretained(this)));
1005 }
1006 #endif
1007
1008 void BrowsingDataRemover::OnWaitableEventSignaled(
1009     base::WaitableEvent* waitable_event) {
1010   waiting_for_clear_plugin_data_ = false;
1011   NotifyAndDeleteIfDone();
1012 }
1013
1014 #if defined(ENABLE_PLUGINS)
1015 void BrowsingDataRemover::OnDeauthorizeContentLicensesCompleted(
1016     uint32 request_id,
1017     bool /* success */) {
1018   DCHECK(waiting_for_clear_content_licenses_);
1019   DCHECK_EQ(request_id, deauthorize_content_licenses_request_id_);
1020
1021   waiting_for_clear_content_licenses_ = false;
1022   NotifyAndDeleteIfDone();
1023 }
1024 #endif
1025
1026 #if defined(OS_CHROMEOS)
1027 void BrowsingDataRemover::OnClearPlatformKeys(
1028     chromeos::DBusMethodCallStatus call_status,
1029     bool result) {
1030   DCHECK(waiting_for_clear_platform_keys_);
1031   if (call_status != chromeos::DBUS_METHOD_CALL_SUCCESS || !result) {
1032     LOG(ERROR) << "Failed to clear platform keys.";
1033   }
1034   waiting_for_clear_platform_keys_ = false;
1035   NotifyAndDeleteIfDone();
1036 }
1037 #endif
1038
1039 void BrowsingDataRemover::OnClearedCookies(int num_deleted) {
1040   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
1041     BrowserThread::PostTask(
1042         BrowserThread::UI, FROM_HERE,
1043         base::Bind(&BrowsingDataRemover::OnClearedCookies,
1044                    base::Unretained(this), num_deleted));
1045     return;
1046   }
1047
1048   DCHECK_GT(waiting_for_clear_cookies_count_, 0);
1049   --waiting_for_clear_cookies_count_;
1050   NotifyAndDeleteIfDone();
1051 }
1052
1053 void BrowsingDataRemover::ClearCookiesOnIOThread(
1054     net::URLRequestContextGetter* rq_context) {
1055   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
1056   net::CookieStore* cookie_store = rq_context->
1057       GetURLRequestContext()->cookie_store();
1058   cookie_store->DeleteAllCreatedBetweenAsync(
1059       delete_begin_, delete_end_,
1060       base::Bind(&BrowsingDataRemover::OnClearedCookies,
1061                  base::Unretained(this)));
1062 }
1063
1064 void BrowsingDataRemover::ClearServerBoundCertsOnIOThread(
1065     net::URLRequestContextGetter* rq_context) {
1066   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
1067   net::ServerBoundCertService* server_bound_cert_service =
1068       rq_context->GetURLRequestContext()->server_bound_cert_service();
1069   server_bound_cert_service->GetCertStore()->DeleteAllCreatedBetween(
1070       delete_begin_, delete_end_,
1071       base::Bind(&BrowsingDataRemover::OnClearedServerBoundCertsOnIOThread,
1072                  base::Unretained(this), base::Unretained(rq_context)));
1073 }
1074
1075 void BrowsingDataRemover::OnClearedServerBoundCertsOnIOThread(
1076     net::URLRequestContextGetter* rq_context) {
1077   // Need to close open SSL connections which may be using the channel ids we
1078   // are deleting.
1079   // TODO(mattm): http://crbug.com/166069 Make the server bound cert
1080   // service/store have observers that can notify relevant things directly.
1081   rq_context->GetURLRequestContext()->ssl_config_service()->
1082       NotifySSLConfigChange();
1083   BrowserThread::PostTask(
1084       BrowserThread::UI, FROM_HERE,
1085       base::Bind(&BrowsingDataRemover::OnClearedServerBoundCerts,
1086                  base::Unretained(this)));
1087 }
1088
1089 void BrowsingDataRemover::OnClearedServerBoundCerts() {
1090   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1091   waiting_for_clear_server_bound_certs_ = false;
1092   NotifyAndDeleteIfDone();
1093 }
1094
1095 void BrowsingDataRemover::OnClearedFormData() {
1096   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1097   waiting_for_clear_form_ = false;
1098   NotifyAndDeleteIfDone();
1099 }
1100
1101 void BrowsingDataRemover::OnClearedAutofillOriginURLs() {
1102   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1103   waiting_for_clear_autofill_origin_urls_ = false;
1104   NotifyAndDeleteIfDone();
1105 }
1106
1107 void BrowsingDataRemover::OnClearedStoragePartitionData() {
1108   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1109   waiting_for_clear_storage_partition_data_ = false;
1110   NotifyAndDeleteIfDone();
1111 }
1112
1113 #if defined(ENABLE_WEBRTC)
1114 void BrowsingDataRemover::OnClearedWebRtcLogs() {
1115   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1116   waiting_for_clear_webrtc_logs_ = false;
1117   NotifyAndDeleteIfDone();
1118 }
1119 #endif