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