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