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

chrome/browser/local_discovery/wifi/wifi_manager_nonchromeos.cc

 // Copyright 2014 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/local_discovery/wifi/wifi_manager_nonchromeos.h"
 
 #include "base/cancelable_callback.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/thread.h"
 #include "components/onc/onc_constants.h"
@@ skipping 125 matching lines @@
     : wifi_manager_(wifi_manager),
       callback_runner_(base::MessageLoopProxy::current()),
       weak_factory_(this) {
 }
 
 WifiManagerNonChromeos::WifiServiceWrapper::~WifiServiceWrapper() {
   net::NetworkChangeNotifier::RemoveNetworkChangeObserver(this);
 }
 
 void WifiManagerNonChromeos::WifiServiceWrapper::Start() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::FILE);
   wifi_service_.reset(WiFiService::Create());
 
   wifi_service_->Initialize(base::MessageLoopProxy::current());
 
   wifi_service_->SetEventObservers(
       base::MessageLoopProxy::current(),
       base::Bind(&WifiServiceWrapper::OnNetworksChangedEvent, AsWeakPtr()),
       base::Bind(&WifiServiceWrapper::OnNetworkListChangedEvent, AsWeakPtr()));
 
   net::NetworkChangeNotifier::AddNetworkChangeObserver(this);
 }
 
 void WifiManagerNonChromeos::WifiServiceWrapper::GetSSIDList(
     const WifiManager::SSIDListCallback& callback) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::FILE);
 
   scoped_ptr<NetworkPropertiesList> ssid_list(new NetworkPropertiesList);
   GetSSIDListInternal(ssid_list.get());
 
   callback_runner_->PostTask(
       FROM_HERE,
       base::Bind(&WifiManagerNonChromeos::PostSSIDListCallback,
                  wifi_manager_,
                  callback,
                  base::Passed(&ssid_list)));
 }
 
 void WifiManagerNonChromeos::WifiServiceWrapper::ConfigureAndConnectPskNetwork(
     const std::string& ssid,
     const std::string& password,
     const WifiManager::SuccessCallback& callback) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::FILE);
   scoped_ptr<base::DictionaryValue> properties = MakeProperties(ssid, password);
 
   std::string network_guid;
   std::string error_string;
   // Will fail without changing system state if network already exists.
   wifi_service_->CreateNetwork(
       false, properties.Pass(), &network_guid, &error_string);
 
   if (error_string.empty()) {
     ConnectToNetworkByID(network_guid, callback);
     return;
   }
 
   // If we cannot create the network, attempt to configure and connect to an
   // existing network.
   if (FindAndConfigureNetwork(ssid, password, &network_guid)) {
     ConnectToNetworkByID(network_guid, callback);
   } else {
     if (!callback.is_null())
       PostClosure(base::Bind(callback, false /* success */));
   }
 }
 
 void WifiManagerNonChromeos::WifiServiceWrapper::OnNetworkListChangedEvent(
     const std::vector<std::string>& network_guids) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::FILE);
   scoped_ptr<NetworkPropertiesList> ssid_list(new NetworkPropertiesList);
   GetSSIDListInternal(ssid_list.get());
   callback_runner_->PostTask(
       FROM_HERE,
       base::Bind(&WifiManagerNonChromeos::OnNetworkListChanged,
                  wifi_manager_,
                  base::Passed(&ssid_list)));
 }
 
 void WifiManagerNonChromeos::WifiServiceWrapper::OnNetworksChangedEvent(
     const std::vector<std::string>& network_guids) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::FILE);
   if (connecting_network_guid_.empty() ||
       !IsConnected(connecting_network_guid_)) {
     return;
   }
 
   connecting_network_guid_.clear();
   connect_failure_callback_.Cancel();
 
   if (!connect_success_callback_.is_null())
     PostClosure(base::Bind(connect_success_callback_, true));
 
   connect_success_callback_.Reset();
 }
 
 base::WeakPtr<WifiManagerNonChromeos::WifiServiceWrapper>
 WifiManagerNonChromeos::WifiServiceWrapper::AsWeakPtr() {
   return weak_factory_.GetWeakPtr();
 }
 
 void WifiManagerNonChromeos::WifiServiceWrapper::RequestScan() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::FILE);
   wifi_service_->RequestNetworkScan();
 }
 
 void WifiManagerNonChromeos::WifiServiceWrapper::ConnectToNetworkByID(
     const std::string& network_guid,
     const WifiManager::SuccessCallback& callback) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::FILE);
 
   std::string connected_network_id = GetConnectedGUID();
   std::string error_string;
   wifi_service_->StartConnect(network_guid, &error_string);
 
   if (!error_string.empty()) {
     LOG(ERROR) << "Could not connect to network by ID: " << error_string;
     PostClosure(base::Bind(callback, false /* success */));
     wifi_service_->StartConnect(connected_network_id, &error_string);
     return;
@@ skipping 33 matching lines @@
   // connected to.
   if (!connected)
     wifi_service_->StartConnect(connected_network_guid_, &error_string);
 
   PostClosure(base::Bind(connect_success_callback, connected /* success */));
 }
 
 void WifiManagerNonChromeos::WifiServiceWrapper::RequestNetworkCredentials(
     const std::string& ssid,
     const WifiManager::CredentialsCallback& callback) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::FILE);
 
   bool success = true;
   std::string guid;
   std::string key;
 
   NetworkPropertiesList network_list;
 
   GetSSIDListInternal(&network_list);
 
   for (NetworkPropertiesList::iterator i = network_list.begin();
@@ skipping 155 matching lines @@
 }
 
 WifiManagerNonChromeos::~WifiManagerNonChromeos() {
   if (wifi_wrapper_) {
     content::BrowserThread::DeleteSoon(
         content::BrowserThread::FILE, FROM_HERE, wifi_wrapper_);
   }
 }
 
 void WifiManagerNonChromeos::Start() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   task_runner_ = content::BrowserThread::GetMessageLoopProxyForThread(
       content::BrowserThread::FILE);
 
   // Allocated on UI thread, but all initialization is done on file
   // thread. Destroyed on file thread, which should be safe since all of the
   // thread-unsafe members are created on the file thread.
   wifi_wrapper_ = new WifiServiceWrapper(weak_factory_.GetWeakPtr());
 
   task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&WifiServiceWrapper::Start, wifi_wrapper_->AsWeakPtr()));
 }
 
 void WifiManagerNonChromeos::GetSSIDList(const SSIDListCallback& callback) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   task_runner_->PostTask(FROM_HERE,
                          base::Bind(&WifiServiceWrapper::GetSSIDList,
                                     wifi_wrapper_->AsWeakPtr(),
                                     callback));
 }
 
 void WifiManagerNonChromeos::RequestScan() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&WifiServiceWrapper::RequestScan, wifi_wrapper_->AsWeakPtr()));
 }
 
 void WifiManagerNonChromeos::OnNetworkListChanged(
     scoped_ptr<NetworkPropertiesList> ssid_list) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   FOR_EACH_OBSERVER(NetworkListObserver,
                     network_list_observers_,
                     OnNetworkListChanged(*ssid_list));
 }
 
 void WifiManagerNonChromeos::PostClosure(const base::Closure& callback) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   callback.Run();
 }
 
 void WifiManagerNonChromeos::PostSSIDListCallback(
     const SSIDListCallback& callback,
     scoped_ptr<NetworkPropertiesList> ssid_list) {
   callback.Run(*ssid_list);
 }
 
 void WifiManagerNonChromeos::ConfigureAndConnectNetwork(
     const std::string& ssid,
     const WifiCredentials& credentials,
     const SuccessCallback& callback) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&WifiServiceWrapper::ConfigureAndConnectPskNetwork,
                  wifi_wrapper_->AsWeakPtr(),
                  ssid,
                  credentials.psk,
                  callback));
 }
 
 void WifiManagerNonChromeos::ConnectToNetworkByID(
     const std::string& internal_id,
     const SuccessCallback& callback) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   task_runner_->PostTask(FROM_HERE,
                          base::Bind(&WifiServiceWrapper::ConnectToNetworkByID,
                                     wifi_wrapper_->AsWeakPtr(),
                                     internal_id,
                                     callback));
 }
 
 void WifiManagerNonChromeos::RequestNetworkCredentials(
     const std::string& ssid,
     const CredentialsCallback& callback) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&WifiServiceWrapper::RequestNetworkCredentials,
                  wifi_wrapper_->AsWeakPtr(),
                  ssid,
                  callback));
 }
 
 void WifiManagerNonChromeos::AddNetworkListObserver(
     NetworkListObserver* observer) {
   network_list_observers_.AddObserver(observer);
 }
 
 void WifiManagerNonChromeos::RemoveNetworkListObserver(
     NetworkListObserver* observer) {
   network_list_observers_.RemoveObserver(observer);
 }
 
 }  // namespace wifi
 
 }  // namespace local_discovery