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