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