chrome/browser/browsing_data/browsing_data_remover.cc

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