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.
DoesOriginMatchMask(int origin_set_mask,const GURL & origin,quota::SpecialStoragePolicy * special_storage_policy)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
NotificationDetails()111 BrowsingDataRemover::NotificationDetails::NotificationDetails()
112 : removal_begin(base::Time()),
113 removal_mask(-1),
114 origin_set_mask(-1) {
115 }
116
NotificationDetails(const BrowsingDataRemover::NotificationDetails & details)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
NotificationDetails(base::Time removal_begin,int removal_mask,int origin_set_mask)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
~NotificationDetails()133 BrowsingDataRemover::NotificationDetails::~NotificationDetails() {}
134
135 // Static.
CreateForUnboundedRange(Profile * profile)136 BrowsingDataRemover* BrowsingDataRemover::CreateForUnboundedRange(
137 Profile* profile) {
138 return new BrowsingDataRemover(profile, base::Time(), base::Time::Max());
139 }
140
141 // Static.
CreateForRange(Profile * profile,base::Time start,base::Time end)142 BrowsingDataRemover* BrowsingDataRemover::CreateForRange(Profile* profile,
143 base::Time start, base::Time end) {
144 return new BrowsingDataRemover(profile, start, end);
145 }
146
147 // Static.
CreateForPeriod(Profile * profile,TimePeriod period)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
BrowsingDataRemover(Profile * profile,base::Time delete_begin,base::Time delete_end)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
~BrowsingDataRemover()223 BrowsingDataRemover::~BrowsingDataRemover() {
224 DCHECK(AllDone());
225 }
226
227 // Static.
set_removing(bool is_removing)228 void BrowsingDataRemover::set_removing(bool is_removing) {
229 DCHECK(is_removing_ != is_removing);
230 is_removing_ = is_removing;
231 }
232
Remove(int remove_mask,int origin_set_mask)233 void BrowsingDataRemover::Remove(int remove_mask, int origin_set_mask) {
234 RemoveImpl(remove_mask, GURL(), origin_set_mask);
235 }
236
RemoveImpl(int remove_mask,const GURL & origin,int origin_set_mask)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
AddObserver(Observer * observer)695 void BrowsingDataRemover::AddObserver(Observer* observer) {
696 observer_list_.AddObserver(observer);
697 }
698
RemoveObserver(Observer * observer)699 void BrowsingDataRemover::RemoveObserver(Observer* observer) {
700 observer_list_.RemoveObserver(observer);
701 }
702
OnHistoryDeletionDone()703 void BrowsingDataRemover::OnHistoryDeletionDone() {
704 waiting_for_clear_history_ = false;
705 NotifyAndDeleteIfDone();
706 }
707
OverrideStoragePartitionForTesting(content::StoragePartition * storage_partition)708 void BrowsingDataRemover::OverrideStoragePartitionForTesting(
709 content::StoragePartition* storage_partition) {
710 storage_partition_for_testing_ = storage_partition;
711 }
712
CalculateBeginDeleteTime(TimePeriod time_period)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
AllDone()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
OnKeywordsLoaded()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
NotifyAndDelete()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
NotifyAndDeleteIfDone()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
OnClearedHostnameResolutionCache()809 void BrowsingDataRemover::OnClearedHostnameResolutionCache() {
810 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
811 waiting_for_clear_hostname_resolution_cache_ = false;
812 NotifyAndDeleteIfDone();
813 }
814
ClearHostnameResolutionCacheOnIOThread(IOThread * io_thread)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
OnClearedLoggedInPredictor()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
ClearLoggedInPredictor()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
OnClearedNetworkPredictor()863 void BrowsingDataRemover::OnClearedNetworkPredictor() {
864 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
865 waiting_for_clear_network_predictor_ = false;
866 NotifyAndDeleteIfDone();
867 }
868
ClearNetworkPredictorOnIOThread(chrome_browser_net::Predictor * predictor)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
OnClearedNetworkingHistory()885 void BrowsingDataRemover::OnClearedNetworkingHistory() {
886 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
887 waiting_for_clear_networking_history_ = false;
888 NotifyAndDeleteIfDone();
889 }
890
ClearedCache()891 void BrowsingDataRemover::ClearedCache() {
892 waiting_for_clear_cache_ = false;
893
894 NotifyAndDeleteIfDone();
895 }
896
ClearCacheOnIOThread()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.
DoClearCache(int rv)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)
ClearedNaClCache()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
ClearedNaClCacheOnIOThread()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
ClearNaClCacheOnIOThread()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
ClearedPnaclCache()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
ClearedPnaclCacheOnIOThread()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
ClearPnaclCacheOnIOThread(base::Time begin,base::Time end)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
OnWaitableEventSignaled(base::WaitableEvent * waitable_event)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)
OnDeauthorizeContentLicensesCompleted(uint32 request_id,bool)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)
OnClearPlatformKeys(chromeos::DBusMethodCallStatus call_status,bool result)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
OnClearedCookies(int num_deleted)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
ClearCookiesOnIOThread(net::URLRequestContextGetter * rq_context)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
ClearServerBoundCertsOnIOThread(net::URLRequestContextGetter * rq_context)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
OnClearedServerBoundCertsOnIOThread(net::URLRequestContextGetter * rq_context)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
OnClearedServerBoundCerts()1130 void BrowsingDataRemover::OnClearedServerBoundCerts() {
1131 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1132 waiting_for_clear_server_bound_certs_ = false;
1133 NotifyAndDeleteIfDone();
1134 }
1135
OnClearedFormData()1136 void BrowsingDataRemover::OnClearedFormData() {
1137 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1138 waiting_for_clear_form_ = false;
1139 NotifyAndDeleteIfDone();
1140 }
1141
OnClearedAutofillOriginURLs()1142 void BrowsingDataRemover::OnClearedAutofillOriginURLs() {
1143 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1144 waiting_for_clear_autofill_origin_urls_ = false;
1145 NotifyAndDeleteIfDone();
1146 }
1147
OnClearedStoragePartitionData()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)
OnClearedWebRtcLogs()1155 void BrowsingDataRemover::OnClearedWebRtcLogs() {
1156 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1157 waiting_for_clear_webrtc_logs_ = false;
1158 NotifyAndDeleteIfDone();
1159 }
1160 #endif
1161
OnClearedDomainReliabilityMonitor()1162 void BrowsingDataRemover::OnClearedDomainReliabilityMonitor() {
1163 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1164 waiting_for_clear_domain_reliability_monitor_ = false;
1165 NotifyAndDeleteIfDone();
1166 }
1167