Adding chrome::NOTIFICATION_BROWSING_DATA_REMOVED.

chrome/browser/browsing_data_remover.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/browsing_data_remover.h"
 
 #include <map>
 #include <set>
 
 #include "base/bind.h"
@@ skipping 27 matching lines @@
 #include "chrome/browser/sessions/tab_restore_service.h"
 #include "chrome/browser/sessions/tab_restore_service_factory.h"
 #include "chrome/browser/webdata/web_data_service.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "content/browser/download/download_manager.h"
 #include "content/browser/in_process_webkit/webkit_context.h"
 #include "content/browser/user_metrics.h"
 #include "content/public/browser/browser_thread.h"
-#include "content/public/browser/notification_source.h"
+#include "content/public/browser/notification_service.h"
 #include "content/public/browser/plugin_data_remover.h"
 #include "net/base/cookie_monster.h"
 #include "net/base/net_errors.h"
 #include "net/base/transport_security_state.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/http/http_cache.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "webkit/quota/quota_manager.h"
 #include "webkit/quota/quota_types.h"
 
 using content::BrowserThread;
 
 // Done so that we can use PostTask on BrowsingDataRemovers and not have
 // BrowsingDataRemover implement RefCounted.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(BrowsingDataRemover);
 
 bool BrowsingDataRemover::removing_ = false;
 
+BrowsingDataRemover::NotificationDetails::NotificationDetails()
+    : removal_begin(base::Time()),
+      removal_mask(-1) {
+}
+
+BrowsingDataRemover::NotificationDetails::NotificationDetails(
+    const BrowsingDataRemover::NotificationDetails& details)
+    : removal_begin(details.removal_begin),
+      removal_mask(details.removal_mask) {
+}
+
+BrowsingDataRemover::NotificationDetails::NotificationDetails(
+    base::Time removal_begin,
+    int removal_mask)
+    : removal_begin(removal_begin),
+      removal_mask(removal_mask) {
+}
+
+BrowsingDataRemover::NotificationDetails::~NotificationDetails() {}
+
 BrowsingDataRemover::BrowsingDataRemover(Profile* profile,
                                          base::Time delete_begin,
                                          base::Time delete_end)
     : profile_(profile),
       quota_manager_(NULL),
       special_storage_policy_(profile->GetExtensionSpecialStoragePolicy()),
       delete_begin_(delete_begin),
       delete_end_(delete_end),
       ALLOW_THIS_IN_INITIALIZER_LIST(cache_callback_(
           this, &BrowsingDataRemover::DoClearCache)),
       next_cache_state_(STATE_NONE),
       cache_(NULL),
       main_context_getter_(profile->GetRequestContext()),
       media_context_getter_(profile->GetRequestContextForMedia()),
       waiting_for_clear_history_(false),
       waiting_for_clear_quota_managed_data_(false),
       waiting_for_clear_networking_history_(false),
       waiting_for_clear_cookies_(false),
       waiting_for_clear_cache_(false),
-      waiting_for_clear_lso_data_(false) {
+      waiting_for_clear_lso_data_(false),
+      remove_mask_(0) {
   DCHECK(profile);
 }
 
 BrowsingDataRemover::BrowsingDataRemover(Profile* profile,
                                          TimePeriod time_period,
                                          base::Time delete_end)
     : profile_(profile),
       quota_manager_(NULL),
       special_storage_policy_(profile->GetExtensionSpecialStoragePolicy()),
       delete_begin_(CalculateBeginDeleteTime(time_period)),
       delete_end_(delete_end),
       ALLOW_THIS_IN_INITIALIZER_LIST(cache_callback_(
           this, &BrowsingDataRemover::DoClearCache)),
       next_cache_state_(STATE_NONE),
       cache_(NULL),
       main_context_getter_(profile->GetRequestContext()),
       media_context_getter_(profile->GetRequestContextForMedia()),
       waiting_for_clear_history_(false),
       waiting_for_clear_quota_managed_data_(false),
       waiting_for_clear_networking_history_(false),
       waiting_for_clear_cookies_(false),
       waiting_for_clear_cache_(false),
-      waiting_for_clear_lso_data_(false) {
+      waiting_for_clear_lso_data_(false),
+      remove_mask_(0) {
   DCHECK(profile);
 }
 
 BrowsingDataRemover::~BrowsingDataRemover() {
   DCHECK(all_done());
 }
 
 // Static.
 void BrowsingDataRemover::set_removing(bool removing) {
   DCHECK(removing_ != removing);
   removing_ = removing;
 }
 
 void BrowsingDataRemover::Remove(int remove_mask) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   set_removing(true);
+  remove_mask_ = remove_mask;
 
   if (remove_mask & REMOVE_HISTORY) {
     HistoryService* history_service =
         profile_->GetHistoryService(Profile::EXPLICIT_ACCESS);
     if (history_service) {
       std::set<GURL> restrict_urls;
       UserMetrics::RecordAction(UserMetricsAction("ClearBrowsingData_History"));
       waiting_for_clear_history_ = true;
       history_service->ExpireHistoryBetween(restrict_urls,
           delete_begin_, delete_end_,
@@ skipping 206 matching lines @@
 }
 
 void BrowsingDataRemover::Observe(int type,
                                   const content::NotificationSource& source,
                                   const content::NotificationDetails& details) {
   // TODO(brettw) bug 1139736: This should also observe session
   // clearing (what about other things such as passwords, etc.?) and wait for
   // them to complete before continuing.
   DCHECK(type == chrome::NOTIFICATION_TEMPLATE_URL_SERVICE_LOADED);
   TemplateURLService* model = content::Source<TemplateURLService>(source).ptr();
-  if (model->profile() == profile_->GetOriginalProfile()) {
+  if (model->profile() == profile_) {
     registrar_.RemoveAll();
     model->RemoveAutoGeneratedBetween(delete_begin_, delete_end_);
     NotifyAndDeleteIfDone();
   }
 }
 
 void BrowsingDataRemover::NotifyAndDeleteIfDone() {
   // TODO(brettw) bug 1139736: see TODO in Observe() above.
   if (!all_done())
     return;
 
   // The NetLog contains download history, but may also contain form data,
   // cookies and passwords.  Simplest just to always clear it.  Must be cleared
   // after the cache, as cleaning up the disk cache exposes some of the history
   // in the NetLog.
   if (g_browser_process->net_log())
     g_browser_process->net_log()->ClearAllPassivelyCapturedEvents();
 
   set_removing(false);
+
+  // Send global notification, then notify any explicit observers.
+  BrowsingDataRemover::NotificationDetails details(delete_begin_, remove_mask_);
+  content::NotificationService::current()->Notify(
+      chrome::NOTIFICATION_BROWSING_DATA_REMOVED,
+      content::Source<Profile>(profile_),
+      content::Details<BrowsingDataRemover::NotificationDetails>(&details));
+
   FOR_EACH_OBSERVER(Observer, observer_list_, OnBrowsingDataRemoverDone());
 
   // History requests aren't happy if you delete yourself from the callback.
   // As such, we do a delete later.
   MessageLoop::current()->DeleteSoon(FROM_HERE, this);
 }
 
 void BrowsingDataRemover::ClearedNetworkHistory() {
   waiting_for_clear_networking_history_ = false;
 
@@ skipping 203 matching lines @@
       GetURLRequestContext()->cookie_store()->GetCookieMonster();
   if (cookie_monster) {
       cookie_monster->DeleteAllCreatedBetweenAsync(
           delete_begin_, delete_end_,
           base::Bind(&BrowsingDataRemover::OnClearedCookies,
                      base::Unretained(this)));
   } else {
     OnClearedCookies(0);
   }
 }