Browsing Data Deletion: Style fixes

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 <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/prefs/pref_service.h"
 #include "chrome/browser/autofill/personal_data_manager_factory.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browsing_data/browsing_data_helper.h"
 #include "chrome/browser/chrome_notification_types.h"
@@ skipping 215 matching lines @@
   is_removing_ = is_removing;
 }
 
 void BrowsingDataRemover::Remove(int remove_mask, int origin_set_mask) {
   RemoveImpl(remove_mask, GURL(), origin_set_mask);
 }
 
 void BrowsingDataRemover::RemoveImpl(int remove_mask,
                                      const GURL& origin,
                                      int origin_set_mask) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   set_removing(true);
   remove_mask_ = remove_mask;
   remove_origin_ = origin;
   origin_set_mask_ = origin_set_mask;
 
   PrefService* prefs = profile_->GetPrefs();
   bool may_delete_history = prefs->GetBoolean(
       prefs::kAllowDeletingBrowserHistory);
 
   // All the UI entry points into the BrowsingDataRemover should be disabled,
@@ skipping 570 matching lines @@
     completion_inhibitor_->OnBrowsingDataRemoverWouldComplete(
         this,
         base::Bind(&BrowsingDataRemover::NotifyAndDelete,
                    base::Unretained(this)));
   } else {
     NotifyAndDelete();
   }
 }
 
 void BrowsingDataRemover::OnClearedHostnameResolutionCache() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   waiting_for_clear_hostname_resolution_cache_ = false;
   NotifyAndDeleteIfDone();
 }
 
 void BrowsingDataRemover::ClearHostnameResolutionCacheOnIOThread(
     IOThread* io_thread) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(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::OnClearedLoggedInPredictor() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(waiting_for_clear_logged_in_predictor_);
   waiting_for_clear_logged_in_predictor_ = false;
   NotifyAndDeleteIfDone();
 }
 
 void BrowsingDataRemover::ClearLoggedInPredictor() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!waiting_for_clear_logged_in_predictor_);
 
   predictors::PredictorDatabase* predictor_db =
       predictors::PredictorDatabaseFactory::GetForProfile(profile_);
   if (!predictor_db)
     return;
 
   predictors::LoggedInPredictorTable* logged_in_table =
       predictor_db->logged_in_table().get();
   if (!logged_in_table)
     return;
 
   waiting_for_clear_logged_in_predictor_ = true;
 
   BrowserThread::PostTaskAndReply(
       BrowserThread::DB,
       FROM_HERE,
       base::Bind(&predictors::LoggedInPredictorTable::DeleteAllCreatedBetween,
                  logged_in_table,
                  delete_begin_,
                  delete_end_),
       base::Bind(&BrowsingDataRemover::OnClearedLoggedInPredictor,
                  base::Unretained(this)));
 }
 
 void BrowsingDataRemover::OnClearedNetworkPredictor() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   waiting_for_clear_network_predictor_ = false;
   NotifyAndDeleteIfDone();
 }
 
 void BrowsingDataRemover::ClearNetworkPredictorOnIOThread(
     chrome_browser_net::Predictor* predictor) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(predictor);
 
   predictor->DiscardInitialNavigationHistory();
   predictor->DiscardAllResults();
 
   // Notify the UI thread that we are done.
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&BrowsingDataRemover::OnClearedNetworkPredictor,
                  base::Unretained(this)));
 }
 
 void BrowsingDataRemover::OnClearedNetworkingHistory() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(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_CURRENTLY_ON(BrowserThread::IO);
   DCHECK_EQ(STATE_NONE, next_cache_state_);
   DCHECK(main_context_getter_.get());
   DCHECK(media_context_getter_.get());
 
   next_cache_state_ = STATE_CREATE_MAIN;
   DoClearCache(net::OK);
 }
 
 // The expected state sequence is STATE_NONE --> STATE_CREATE_MAIN -->
 // STATE_DELETE_MAIN --> STATE_CREATE_MEDIA --> STATE_DELETE_MEDIA -->
@@ skipping 72 matching lines @@
         next_cache_state_ = STATE_NONE;  // Stop looping.
         return;
       }
     }
   }
 }
 
 #if !defined(DISABLE_NACL)
 void BrowsingDataRemover::ClearedNaClCache() {
   // This function should be called on the UI thread.
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   waiting_for_clear_nacl_cache_ = false;
 
   NotifyAndDeleteIfDone();
 }
 
 void BrowsingDataRemover::ClearedNaClCacheOnIOThread() {
   // This function should be called on the IO thread.
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // Notify the UI thread that we are done.
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&BrowsingDataRemover::ClearedNaClCache,
                  base::Unretained(this)));
 }
 
 void BrowsingDataRemover::ClearNaClCacheOnIOThread() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   nacl::NaClBrowser::GetInstance()->ClearValidationCache(
       base::Bind(&BrowsingDataRemover::ClearedNaClCacheOnIOThread,
                  base::Unretained(this)));
 }
 
 void BrowsingDataRemover::ClearedPnaclCache() {
   // This function should be called on the UI thread.
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   waiting_for_clear_pnacl_cache_ = false;
 
   NotifyAndDeleteIfDone();
 }
 
 void BrowsingDataRemover::ClearedPnaclCacheOnIOThread() {
   // This function should be called on the IO thread.
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // Notify the UI thread that we are done.
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&BrowsingDataRemover::ClearedPnaclCache,
                  base::Unretained(this)));
 }
 
 void BrowsingDataRemover::ClearPnaclCacheOnIOThread(base::Time begin,
                                                     base::Time end) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   pnacl::PnaclHost::GetInstance()->ClearTranslationCacheEntriesBetween(
       begin, end,
       base::Bind(&BrowsingDataRemover::ClearedPnaclCacheOnIOThread,
                  base::Unretained(this)));
 }
 #endif
 
 void BrowsingDataRemover::OnWaitableEventSignaled(
     base::WaitableEvent* waitable_event) {
@@ skipping 35 matching lines @@
     return;
   }
 
   DCHECK_GT(waiting_for_clear_cookies_count_, 0);
   --waiting_for_clear_cookies_count_;
   NotifyAndDeleteIfDone();
 }
 
 void BrowsingDataRemover::ClearCookiesOnIOThread(
     net::URLRequestContextGetter* rq_context) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   net::CookieStore* cookie_store = rq_context->
       GetURLRequestContext()->cookie_store();
   cookie_store->DeleteAllCreatedBetweenAsync(
       delete_begin_, delete_end_,
       base::Bind(&BrowsingDataRemover::OnClearedCookies,
                  base::Unretained(this)));
 }
 
 void BrowsingDataRemover::ClearChannelIDsOnIOThread(
     net::URLRequestContextGetter* rq_context) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   net::ChannelIDService* channel_id_service =
       rq_context->GetURLRequestContext()->channel_id_service();
   channel_id_service->GetChannelIDStore()->DeleteAllCreatedBetween(
       delete_begin_, delete_end_,
       base::Bind(&BrowsingDataRemover::OnClearedChannelIDsOnIOThread,
                  base::Unretained(this), base::Unretained(rq_context)));
 }
 
 void BrowsingDataRemover::OnClearedChannelIDsOnIOThread(
     net::URLRequestContextGetter* rq_context) {
   // Need to close open SSL connections which may be using the channel ids we
   // are deleting.
   // TODO(mattm): http://crbug.com/166069 Make the server bound cert
   // service/store have observers that can notify relevant things directly.
   rq_context->GetURLRequestContext()->ssl_config_service()->
       NotifySSLConfigChange();
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&BrowsingDataRemover::OnClearedChannelIDs,
                  base::Unretained(this)));
 }
 
 void BrowsingDataRemover::OnClearedChannelIDs() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   waiting_for_clear_channel_ids_ = false;
   NotifyAndDeleteIfDone();
 }
 
 void BrowsingDataRemover::OnClearedFormData() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   waiting_for_clear_form_ = false;
   NotifyAndDeleteIfDone();
 }
 
 void BrowsingDataRemover::OnClearedAutofillOriginURLs() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   waiting_for_clear_autofill_origin_urls_ = false;
   NotifyAndDeleteIfDone();
 }
 
 void BrowsingDataRemover::OnClearedStoragePartitionData() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   waiting_for_clear_storage_partition_data_ = false;
   NotifyAndDeleteIfDone();
 }
 
 #if defined(ENABLE_WEBRTC)
 void BrowsingDataRemover::OnClearedWebRtcLogs() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   waiting_for_clear_webrtc_logs_ = false;
   NotifyAndDeleteIfDone();
 }
 #endif
 
 void BrowsingDataRemover::OnClearedDomainReliabilityMonitor() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   waiting_for_clear_domain_reliability_monitor_ = false;
   NotifyAndDeleteIfDone();
 }