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