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
91using base::UserMetricsAction;
92using content::BrowserContext;
93using content::BrowserThread;
94using content::DOMStorageContext;
95
96bool BrowsingDataRemover::is_removing_ = false;
97
98BrowsingDataRemover::CompletionInhibitor*
99    BrowsingDataRemover::completion_inhibitor_ = NULL;
100
101// Helper to create callback for BrowsingDataRemover::DoesOriginMatchMask.
102// Static.
103bool 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
111BrowsingDataRemover::NotificationDetails::NotificationDetails()
112    : removal_begin(base::Time()),
113      removal_mask(-1),
114      origin_set_mask(-1) {
115}
116
117BrowsingDataRemover::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
124BrowsingDataRemover::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
133BrowsingDataRemover::NotificationDetails::~NotificationDetails() {}
134
135// Static.
136BrowsingDataRemover* BrowsingDataRemover::CreateForUnboundedRange(
137    Profile* profile) {
138  return new BrowsingDataRemover(profile, base::Time(), base::Time::Max());
139}
140
141// Static.
142BrowsingDataRemover* BrowsingDataRemover::CreateForRange(Profile* profile,
143    base::Time start, base::Time end) {
144  return new BrowsingDataRemover(profile, start, end);
145}
146
147// Static.
148BrowsingDataRemover* 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
177BrowsingDataRemover::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
223BrowsingDataRemover::~BrowsingDataRemover() {
224  DCHECK(AllDone());
225}
226
227// Static.
228void BrowsingDataRemover::set_removing(bool is_removing) {
229  DCHECK(is_removing_ != is_removing);
230  is_removing_ = is_removing;
231}
232
233void BrowsingDataRemover::Remove(int remove_mask, int origin_set_mask) {
234  RemoveImpl(remove_mask, GURL(), origin_set_mask);
235}
236
237void 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
695void BrowsingDataRemover::AddObserver(Observer* observer) {
696  observer_list_.AddObserver(observer);
697}
698
699void BrowsingDataRemover::RemoveObserver(Observer* observer) {
700  observer_list_.RemoveObserver(observer);
701}
702
703void BrowsingDataRemover::OnHistoryDeletionDone() {
704  waiting_for_clear_history_ = false;
705  NotifyAndDeleteIfDone();
706}
707
708void BrowsingDataRemover::OverrideStoragePartitionForTesting(
709    content::StoragePartition* storage_partition) {
710  storage_partition_for_testing_ = storage_partition;
711}
712
713base::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
740bool 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
761void 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
773void 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
791void 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
809void BrowsingDataRemover::OnClearedHostnameResolutionCache() {
810  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
811  waiting_for_clear_hostname_resolution_cache_ = false;
812  NotifyAndDeleteIfDone();
813}
814
815void 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
829void 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
836void 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
863void BrowsingDataRemover::OnClearedNetworkPredictor() {
864  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
865  waiting_for_clear_network_predictor_ = false;
866  NotifyAndDeleteIfDone();
867}
868
869void 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
885void BrowsingDataRemover::OnClearedNetworkingHistory() {
886  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
887  waiting_for_clear_networking_history_ = false;
888  NotifyAndDeleteIfDone();
889}
890
891void BrowsingDataRemover::ClearedCache() {
892  waiting_for_clear_cache_ = false;
893
894  NotifyAndDeleteIfDone();
895}
896
897void 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.
911void 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)
990void 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
999void 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
1010void 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
1018void 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
1027void 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
1038void 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
1049void BrowsingDataRemover::OnWaitableEventSignaled(
1050    base::WaitableEvent* waitable_event) {
1051  waiting_for_clear_plugin_data_ = false;
1052  NotifyAndDeleteIfDone();
1053}
1054
1055#if defined(ENABLE_PLUGINS)
1056void 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)
1068void 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
1080void 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
1094void 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
1105void 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
1116void 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
1130void BrowsingDataRemover::OnClearedServerBoundCerts() {
1131  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1132  waiting_for_clear_server_bound_certs_ = false;
1133  NotifyAndDeleteIfDone();
1134}
1135
1136void BrowsingDataRemover::OnClearedFormData() {
1137  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1138  waiting_for_clear_form_ = false;
1139  NotifyAndDeleteIfDone();
1140}
1141
1142void BrowsingDataRemover::OnClearedAutofillOriginURLs() {
1143  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1144  waiting_for_clear_autofill_origin_urls_ = false;
1145  NotifyAndDeleteIfDone();
1146}
1147
1148void 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)
1155void BrowsingDataRemover::OnClearedWebRtcLogs() {
1156  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1157  waiting_for_clear_webrtc_logs_ = false;
1158  NotifyAndDeleteIfDone();
1159}
1160#endif
1161
1162void BrowsingDataRemover::OnClearedDomainReliabilityMonitor() {
1163  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1164  waiting_for_clear_domain_reliability_monitor_ = false;
1165  NotifyAndDeleteIfDone();
1166}
1167