[chrome/browser/net] favor DCHECK_CURRENTLY_ON for better logs

chrome/browser/net/pref_proxy_config_tracker_impl.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/net/pref_proxy_config_tracker_impl.h"
 
 #include "base/bind.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/values.h"
@@ skipping 55 matching lines @@
 }
 
 void ChromeProxyConfigService::OnLazyPoll() {
   if (base_service_.get())
     base_service_->OnLazyPoll();
 }
 
 void ChromeProxyConfigService::UpdateProxyConfig(
     ProxyPrefs::ConfigState config_state,
     const net::ProxyConfig& config) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   pref_config_read_pending_ = false;
   pref_config_state_ = config_state;
   pref_config_ = config;
 
   if (!observers_.might_have_observers())
     return;
 
   // Evaluate the proxy configuration. If GetLatestProxyConfig returns
   // CONFIG_PENDING, we are using the system proxy service, but it doesn't have
   // a valid configuration yet. Once it is ready, OnProxyConfigChanged() will be
   // called and broadcast the proxy configuration.
   // Note: If a switch between a preference proxy configuration and the system
   // proxy configuration occurs an unnecessary notification might get send if
   // the two configurations agree. This case should be rare however, so we don't
   // handle that case specially.
   net::ProxyConfig new_config;
   ConfigAvailability availability = GetLatestProxyConfig(&new_config);
   if (availability != CONFIG_PENDING) {
     FOR_EACH_OBSERVER(net::ProxyConfigService::Observer, observers_,
                       OnProxyConfigChanged(new_config, availability));
   }
 }
 
 void ChromeProxyConfigService::OnProxyConfigChanged(
     const net::ProxyConfig& config,
     ConfigAvailability availability) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // Check whether there is a proxy configuration defined by preferences. In
   // this case that proxy configuration takes precedence and the change event
   // from the delegate proxy service can be disregarded.
   if (!PrefProxyConfigTrackerImpl::PrefPrecedes(pref_config_state_)) {
     net::ProxyConfig actual_config;
     availability = GetLatestProxyConfig(&actual_config);
     FOR_EACH_OBSERVER(net::ProxyConfigService::Observer, observers_,
                       OnProxyConfigChanged(actual_config, availability));
   }
 }
 
 void ChromeProxyConfigService::RegisterObserver() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!registered_observer_ && base_service_.get()) {
     base_service_->AddObserver(this);
     registered_observer_ = true;
   }
 }
 
 //========================= PrefProxyConfigTrackerImpl =========================
 
 PrefProxyConfigTrackerImpl::PrefProxyConfigTrackerImpl(
     PrefService* pref_service)
@@ skipping 18 matching lines @@
       new ChromeProxyConfigService(base_service.release());
   VLOG(1) << this << ": set chrome proxy config service to "
           << chrome_proxy_config_service_;
   if (chrome_proxy_config_service_ && update_pending_)
     OnProxyConfigChanged(config_state_, pref_config_);
 
   return scoped_ptr<net::ProxyConfigService>(chrome_proxy_config_service_);
 }
 
 void PrefProxyConfigTrackerImpl::DetachFromPrefService() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   // Stop notifications.
   proxy_prefs_.RemoveAll();
   pref_service_ = NULL;
   chrome_proxy_config_service_ = NULL;
 }
 
 // static
 bool PrefProxyConfigTrackerImpl::PrefPrecedes(
     ProxyPrefs::ConfigState config_state) {
   return config_state == ProxyPrefs::CONFIG_POLICY ||
@@ skipping 44 matching lines @@
     user_prefs::PrefRegistrySyncable* pref_service) {
   base::DictionaryValue* default_settings =
       ProxyConfigDictionary::CreateSystem();
   pref_service->RegisterDictionaryPref(prefs::kProxy, default_settings);
 }
 
 // static
 ProxyPrefs::ConfigState PrefProxyConfigTrackerImpl::ReadPrefConfig(
     const PrefService* pref_service,
     net::ProxyConfig* config) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // Clear the configuration and source.
   *config = net::ProxyConfig();
   ProxyPrefs::ConfigState config_state = ProxyPrefs::CONFIG_UNSET;
 
   const PrefService::Preference* pref =
       pref_service->FindPreference(prefs::kProxy);
   DCHECK(pref);
 
   const base::DictionaryValue* dict =
@@ skipping 12 matching lines @@
     } else  {
       config_state = ProxyPrefs::CONFIG_FALLBACK;
     }
   }
 
   return config_state;
 }
 
 ProxyPrefs::ConfigState PrefProxyConfigTrackerImpl::GetProxyConfig(
     net::ProxyConfig* config) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (config_state_ != ProxyPrefs::CONFIG_UNSET)
     *config = pref_config_;
   return config_state_;
 }
 
 void PrefProxyConfigTrackerImpl::OnProxyConfigChanged(
     ProxyPrefs::ConfigState config_state,
     const net::ProxyConfig& config) {
   if (!chrome_proxy_config_service_) {
     VLOG(1) << "No chrome proxy config service to push to UpdateProxyConfig";
@@ skipping 64 matching lines @@
     }
     case ProxyPrefs::kModeCount: {
       // Fall through to NOTREACHED().
     }
   }
   NOTREACHED() << "Unknown proxy mode, falling back to system settings.";
   return false;
 }
 
 void PrefProxyConfigTrackerImpl::OnProxyPrefChanged() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   net::ProxyConfig new_config;
   ProxyPrefs::ConfigState config_state = ReadPrefConfig(pref_service_,
                                                         &new_config);
   if (config_state_ != config_state ||
       (config_state_ != ProxyPrefs::CONFIG_UNSET &&
        !pref_config_.Equals(new_config))) {
     config_state_ = config_state;
     if (config_state_ != ProxyPrefs::CONFIG_UNSET)
       pref_config_ = new_config;
     update_pending_ = true;
   }
   if (update_pending_)
     OnProxyConfigChanged(config_state, new_config);
 }