Added completion notification to Profile's ClearNetworkingHistorySince.

chrome/browser/browsing_data/browsing_data_remover.cc

 // Copyright (c) 2012 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/browsing_data_remover.h"
 
 #include <map>
 #include <set>
 
 #include "base/bind.h"
@@ skipping 129 matching lines @@
       waiting_for_clear_cookies_count_(0),
       waiting_for_clear_history_(false),
       waiting_for_clear_local_storage_(false),
       waiting_for_clear_session_storage_(false),
       waiting_for_clear_networking_history_(false),
       waiting_for_clear_server_bound_certs_(false),
       waiting_for_clear_plugin_data_(false),
       waiting_for_clear_quota_managed_data_(false),
       waiting_for_clear_content_licenses_(false),
       waiting_for_clear_form_(false),
+      waiting_for_clear_hostname_resolution_cache_(false),
+      waiting_for_clear_network_predictor_(false),
       remove_mask_(0),
       remove_origin_(GURL()),
       origin_set_mask_(0) {
   DCHECK(profile);
   // crbug.com/140910: Many places were calling this with base::Time() as
   // delete_end, even though they should've used base::Time::Max(). Work around
   // it here. New code should use base::Time::Max().
   DCHECK(delete_end_ != base::Time());
   if (delete_end_ == base::Time())
     delete_end_ = base::Time::Max();
@@ skipping 81 matching lines @@
           delete_begin_, history_end_,
           &request_consumer_,
           base::Bind(&BrowsingDataRemover::OnHistoryDeletionDone,
                      base::Unretained(this)));
     }
 
     // Need to clear the host cache and accumulated speculative data, as it also
     // reveals some history: we have no mechanism to track when these items were
     // created, so we'll clear them all. Better safe than sorry.
     if (g_browser_process->io_thread()) {
-      waiting_for_clear_networking_history_ = true;
+      waiting_for_clear_hostname_resolution_cache_ = true;
       BrowserThread::PostTask(
           BrowserThread::IO, FROM_HERE,
-          base::Bind(&BrowsingDataRemover::ClearNetworkingHistory,
-                     base::Unretained(this), g_browser_process->io_thread()));
+          base::Bind(
+              &BrowsingDataRemover::ClearHostnameResolutionCacheOnIOThread,
+              base::Unretained(this),
+              g_browser_process->io_thread()));
+    }
+    if (profile_->GetNetworkPredictor()) {
+      waiting_for_clear_network_predictor_ = true;
+      BrowserThread::PostTask(
+          BrowserThread::IO, FROM_HERE,
+          base::Bind(&BrowsingDataRemover::ClearNetworkPredictorOnIOThread,
+                     base::Unretained(this)));
     }
 
     // As part of history deletion we also delete the auto-generated keywords.
     TemplateURLService* keywords_model =
         TemplateURLServiceFactory::GetForProfile(profile_);
     if (keywords_model && !keywords_model->loaded()) {
       registrar_.Add(this, chrome::NOTIFICATION_TEMPLATE_URL_SERVICE_LOADED,
                      content::Source<TemplateURLService>(keywords_model));
       keywords_model->Load();
     } else if (keywords_model) {
@@ skipping 217 matching lines @@
 
     waiting_for_clear_content_licenses_ = true;
     if (!pepper_flash_settings_manager_.get()) {
       pepper_flash_settings_manager_.reset(
           new PepperFlashSettingsManager(this, profile_));
     }
     deauthorize_content_licenses_request_id_ =
         pepper_flash_settings_manager_->DeauthorizeContentLicenses();
   }
 
-  // Also delete cached network related data (like TransportSecurityState,
-  // HttpServerProperties data).
-  profile_->ClearNetworkingHistorySince(delete_begin_);
-
-  NotifyAndDeleteIfDone();
+  // Always wipe accumulated network related data (TransportSecurityState and
+  // HttpServerPropertiesManager data).
+  waiting_for_clear_networking_history_ = true;
+  profile_->ClearNetworkingHistorySince(
+      delete_begin_,
+      base::Bind(&BrowsingDataRemover::OnClearedNetworkingHistory,
+                 base::Unretained(this)));
 }
 
 void BrowsingDataRemover::AddObserver(Observer* observer) {
   observer_list_.AddObserver(observer);
 }
 
 void BrowsingDataRemover::RemoveObserver(Observer* observer) {
   observer_list_.RemoveObserver(observer);
 }
 
@@ skipping 40 matching lines @@
       !waiting_for_clear_nacl_cache_ &&
       !waiting_for_clear_cookies_count_&&
       !waiting_for_clear_history_ &&
       !waiting_for_clear_local_storage_ &&
       !waiting_for_clear_session_storage_ &&
       !waiting_for_clear_networking_history_ &&
       !waiting_for_clear_server_bound_certs_ &&
       !waiting_for_clear_plugin_data_ &&
       !waiting_for_clear_quota_managed_data_ &&
       !waiting_for_clear_content_licenses_ &&
-      !waiting_for_clear_form_;
+      !waiting_for_clear_form_ &&
+      !waiting_for_clear_hostname_resolution_cache_ &&
+      !waiting_for_clear_network_predictor_;

[Mike West, 2012/10/30 10:33:22]

Nit: Since you're already touching this, can you sort it?

[engedy, 2012/10/30 11:01:14]

Done.

 }
 
 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();
@@ skipping 19 matching lines @@
       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;
-
+void BrowsingDataRemover::OnClearedHostnameResolutionCache() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  waiting_for_clear_hostname_resolution_cache_ = false;
   NotifyAndDeleteIfDone();
 }
 
-void BrowsingDataRemover::ClearNetworkingHistory(IOThread* io_thread) {
-  // This function should be called on the IO thread.
+void BrowsingDataRemover::ClearHostnameResolutionCacheOnIOThread(
+    IOThread* io_thread) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   io_thread->ClearHostCache();
 
+  // Notify the UI thread that we are done.
+  BrowserThread::PostTask(
+      BrowserThread::UI,
+      FROM_HERE,
+      base::Bind(&BrowsingDataRemover::OnClearedHostnameResolutionCache,
+                 base::Unretained(this)));
+}
+
+void BrowsingDataRemover::OnClearedNetworkPredictor() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  waiting_for_clear_network_predictor_ = false;
+  NotifyAndDeleteIfDone();
+}
+
+void BrowsingDataRemover::ClearNetworkPredictorOnIOThread() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
   chrome_browser_net::Predictor* predictor = profile_->GetNetworkPredictor();
   if (predictor) {
     predictor->DiscardInitialNavigationHistory();
     predictor->DiscardAllResults();
   }
 
   // Notify the UI thread that we are done.
   BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
-      base::Bind(&BrowsingDataRemover::ClearedNetworkHistory,
+      BrowserThread::UI,
+      FROM_HERE,
+      base::Bind(&BrowsingDataRemover::OnClearedNetworkPredictor,
                  base::Unretained(this)));
 }
 
+void BrowsingDataRemover::OnClearedNetworkingHistory() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  waiting_for_clear_networking_history_ = false;
+  NotifyAndDeleteIfDone();
+}
+
 void BrowsingDataRemover::ClearedCache() {
   waiting_for_clear_cache_ = false;
 
   NotifyAndDeleteIfDone();
 }
 
 void BrowsingDataRemover::ClearCacheOnIOThread() {
   // This function should be called on the IO thread.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK_EQ(STATE_NONE, next_cache_state_);
@@ skipping 334 matching lines @@
       BrowserThread::UI, FROM_HERE,
       base::Bind(&BrowsingDataRemover::OnClearedFormData,
                  base::Unretained(this)));
 }
 
 void BrowsingDataRemover::OnClearedFormData() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   waiting_for_clear_form_ = false;
   NotifyAndDeleteIfDone();
 }