favor DCHECK_CURRENTLY_ON for better logs in chrome/browser/devtools

chrome/browser/devtools/device/devtools_android_bridge.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/devtools/device/devtools_android_bridge.h"
 
 #include <map>
 #include <vector>
 
 #include "base/base64.h"
@@ skipping 96 matching lines @@
                      const std::string& response);
 
   DeviceListCallback callback_;
   CompleteDevices complete_devices_;
 };
 
 DevToolsAndroidBridge::DiscoveryRequest::DiscoveryRequest(
     AndroidDeviceManager* device_manager,
     const DeviceListCallback& callback)
     : callback_(callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   device_manager->QueryDevices(
       base::Bind(&DiscoveryRequest::ReceivedDevices, this));
 }
 
 DevToolsAndroidBridge::DiscoveryRequest::~DiscoveryRequest() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   callback_.Run(complete_devices_);
 }
 
 void DevToolsAndroidBridge::DiscoveryRequest::ReceivedDevices(
     const AndroidDeviceManager::Devices& devices) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   for (const auto& device : devices) {
     device->QueryDeviceInfo(
         base::Bind(&DiscoveryRequest::ReceivedDeviceInfo, this, device));
   }
 }
 
 void DevToolsAndroidBridge::DiscoveryRequest::ReceivedDeviceInfo(
     scoped_refptr<AndroidDeviceManager::Device> device,
     const AndroidDeviceManager::DeviceInfo& device_info) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   scoped_refptr<RemoteDevice> remote_device =
       new RemoteDevice(device->serial(), device_info);
   complete_devices_.push_back(std::make_pair(device, remote_device));
   for (RemoteBrowsers::iterator it = remote_device->browsers().begin();
        it != remote_device->browsers().end(); ++it) {
     device->SendJsonRequest(
         (*it)->socket(),
         kVersionRequest,
         base::Bind(&DiscoveryRequest::ReceivedVersion, this, *it));
     device->SendJsonRequest(
         (*it)->socket(),
         kPageListRequest,
         base::Bind(&DiscoveryRequest::ReceivedPages, this, *it));
   }
 }
 
 void DevToolsAndroidBridge::DiscoveryRequest::ReceivedVersion(
     scoped_refptr<RemoteBrowser> browser,
     int result,
     const std::string& response) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (result < 0)
     return;
   // Parse version, append to package name if available,
   scoped_ptr<base::Value> value(base::JSONReader::Read(response));
   base::DictionaryValue* dict;
   if (value && value->GetAsDictionary(&dict)) {
     std::string browser_name;
     if (dict->GetString("Browser", &browser_name)) {
       std::vector<std::string> parts;
       Tokenize(browser_name, "/", &parts);
       if (parts.size() == 2)
         browser->version_ = parts[1];
       else
         browser->version_ = browser_name;
     }
     std::string package;
     if (dict->GetString("Android-Package", &package)) {
       browser->display_name_ =
           AndroidDeviceManager::GetBrowserName(browser->socket(), package);
     }
   }
 }
 
 void DevToolsAndroidBridge::DiscoveryRequest::ReceivedPages(
     scoped_refptr<RemoteBrowser> browser,
     int result,
     const std::string& response) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (result < 0)
     return;
   scoped_ptr<base::Value> value(base::JSONReader::Read(response));
   base::ListValue* list_value;
   if (value && value->GetAsList(&list_value)) {
     for (const auto& page_value : *list_value) {
       base::DictionaryValue* dict;
       if (page_value->GetAsDictionary(&dict)) {
         browser->pages_.push_back(
             new RemotePage(browser->browser_id_, *dict, browser->IsWebView()));
@@ skipping 142 matching lines @@
 };
 
 // static
 scoped_refptr<content::DevToolsAgentHost>
 DevToolsAndroidBridge::AgentHostDelegate::GetOrCreateAgentHost(
     DevToolsAndroidBridge* bridge,
     const std::string& id,
     const BrowserId& browser_id,
     const std::string& debug_url,
     bool is_web_view) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   AgentHostDelegates::iterator it = bridge->host_delegates_.find(id);
   if (it != bridge->host_delegates_.end())
     return it->second->agent_host_;
 
   AgentHostDelegate* delegate =
       new AgentHostDelegate(bridge, id, browser_id, debug_url, is_web_view);
   scoped_refptr<content::DevToolsAgentHost> result =
       content::DevToolsAgentHost::Create(delegate);
   delegate->agent_host_ = result.get();
   return result;
@@ skipping 293 matching lines @@
   }
   device->SendJsonRequest(browser_id.second, request, callback);
 }
 
 void DevToolsAndroidBridge::SendProtocolCommand(
     const BrowserId& browser_id,
     const std::string& debug_url,
     const std::string& method,
     scoped_ptr<base::DictionaryValue> params,
     const base::Closure callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (debug_url.empty())
     return;
   scoped_refptr<AndroidDeviceManager::Device> device(
       FindDevice(browser_id.first));
   if (!device.get()) {
     callback.Run();
     return;
   }
   new ProtocolCommand(
       device, browser_id.second, debug_url,
@@ skipping 28 matching lines @@
     const std::string& serial) {
   DeviceMap::iterator it = device_map_.find(serial);
   return it == device_map_.end() ? nullptr : it->second;
 }
 
 void DevToolsAndroidBridge::RespondToOpenOnUIThread(
     scoped_refptr<RemoteBrowser> browser,
     const RemotePageCallback& callback,
     int result,
     const std::string& response) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (result < 0) {
     callback.Run(NULL);
     return;
   }
   scoped_ptr<base::Value> value(base::JSONReader::Read(response));
   base::DictionaryValue* dict;
   if (value && value->GetAsDictionary(&dict)) {
     scoped_refptr<RemotePage> new_page(
         new RemotePage(browser->browser_id_, *dict, browser->IsWebView()));
     callback.Run(new_page);
   }
 }
 
 void DevToolsAndroidBridge::OpenRemotePage(
     scoped_refptr<RemoteBrowser> browser,
     const std::string& input_url,
     const DevToolsAndroidBridge::RemotePageCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   GURL gurl(input_url);
   if (!gurl.is_valid()) {
     gurl = GURL("http://" + input_url);
     if (!gurl.is_valid())
       return;
   }
   std::string url = gurl.spec();
   RemoteBrowser::ParsedVersion parsed_version = browser->GetParsedVersion();
 
   if (browser->IsChrome() &&
@@ skipping 11 matching lines @@
                                AsWeakPtr(), browser, callback, url));
   }
 }
 
 void DevToolsAndroidBridge::PageCreatedOnUIThread(
     scoped_refptr<RemoteBrowser> browser,
     const RemotePageCallback& callback,
     const std::string& url,
     int result,
     const std::string& response) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (result < 0)
     return;
   // Navigating too soon after the page creation breaks navigation history
   // (crbug.com/311014). This can be avoided by adding a moderate delay.
   BrowserThread::PostDelayedTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&DevToolsAndroidBridge::NavigatePageOnUIThread,
                  AsWeakPtr(), browser, callback, result, response, url),
       base::TimeDelta::FromMilliseconds(kNewPageNavigateDelayMs));
 }
 
 void DevToolsAndroidBridge::NavigatePageOnUIThread(
     scoped_refptr<RemoteBrowser> browser,
     const RemotePageCallback& callback,
     int result,
     const std::string& response,
     const std::string& url) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   scoped_ptr<base::Value> value(base::JSONReader::Read(response));
   base::DictionaryValue* dict;
 
   if (value && value->GetAsDictionary(&dict)) {
     RemotePageTarget new_page(this, browser->browser_id_, *dict,
                               browser->IsWebView());
     new_page.Navigate(url,
         base::Bind(&DevToolsAndroidBridge::RespondToOpenOnUIThread,
                    AsWeakPtr(), browser, callback, result, response));
   }
@@ skipping 28 matching lines @@
     Profile* profile,
     SigninManagerBase* signin_manager,
     ProfileOAuth2TokenService* const token_service)
     : profile_(profile),
       signin_manager_(signin_manager),
       token_service_(token_service),
       device_manager_(AndroidDeviceManager::Create()),
       task_scheduler_(base::Bind(&DevToolsAndroidBridge::ScheduleTaskDefault)),
       port_forwarding_controller_(new PortForwardingController(profile, this)),
       weak_factory_(this) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   pref_change_registrar_.Init(profile_->GetPrefs());
   pref_change_registrar_.Add(prefs::kDevToolsDiscoverUsbDevicesEnabled,
       base::Bind(&DevToolsAndroidBridge::CreateDeviceProviders,
                  base::Unretained(this)));
   CreateDeviceProviders();
 }
 
 void DevToolsAndroidBridge::AddDeviceListListener(
     DeviceListListener* listener) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   bool polling_was_off = !NeedsDeviceListPolling();
   device_list_listeners_.push_back(listener);
   if (polling_was_off)
     StartDeviceListPolling();
 }
 
 void DevToolsAndroidBridge::RemoveDeviceListListener(
     DeviceListListener* listener) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DeviceListListeners::iterator it = std::find(
       device_list_listeners_.begin(), device_list_listeners_.end(), listener);
   DCHECK(it != device_list_listeners_.end());
   device_list_listeners_.erase(it);
   if (!NeedsDeviceListPolling())
     StopDeviceListPolling();
 }
 
 void DevToolsAndroidBridge::AddDeviceCountListener(
     DeviceCountListener* listener) {
   device_count_listeners_.push_back(listener);
   if (device_count_listeners_.size() == 1)
     StartDeviceCountPolling();
 }
 
 void DevToolsAndroidBridge::RemoveDeviceCountListener(
     DeviceCountListener* listener) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DeviceCountListeners::iterator it = std::find(
       device_count_listeners_.begin(), device_count_listeners_.end(), listener);
   DCHECK(it != device_count_listeners_.end());
   device_count_listeners_.erase(it);
   if (device_count_listeners_.empty())
     StopDeviceCountPolling();
 }
 
 void DevToolsAndroidBridge::AddPortForwardingListener(
     PortForwardingListener* listener) {
   bool polling_was_off = !NeedsDeviceListPolling();
   port_forwarding_listeners_.push_back(listener);
   if (polling_was_off)
     StartDeviceListPolling();
 }
 
 void DevToolsAndroidBridge::RemovePortForwardingListener(
     PortForwardingListener* listener) {
   PortForwardingListeners::iterator it = std::find(
       port_forwarding_listeners_.begin(),
       port_forwarding_listeners_.end(),
       listener);
   DCHECK(it != port_forwarding_listeners_.end());
   port_forwarding_listeners_.erase(it);
   if (!NeedsDeviceListPolling())
     StopDeviceListPolling();
 }
 
 bool DevToolsAndroidBridge::HasDevToolsWindow(const std::string& agent_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return host_delegates_.find(agent_id) != host_delegates_.end();
 }
 
 DevToolsAndroidBridge::~DevToolsAndroidBridge() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(device_list_listeners_.empty());
   DCHECK(device_count_listeners_.empty());
   DCHECK(port_forwarding_listeners_.empty());
 }
 
 void DevToolsAndroidBridge::StartDeviceListPolling() {
   device_list_callback_.Reset(
       base::Bind(&DevToolsAndroidBridge::ReceivedDeviceList, AsWeakPtr()));
   RequestDeviceList(device_list_callback_.callback());
 }
 
 void DevToolsAndroidBridge::StopDeviceListPolling() {
   device_list_callback_.Cancel();
   device_map_.clear();
 }
 
 bool DevToolsAndroidBridge::NeedsDeviceListPolling() {
   return !device_list_listeners_.empty() || !port_forwarding_listeners_.empty();
 }
 
 void DevToolsAndroidBridge::RequestDeviceList(
     const DeviceListCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (!NeedsDeviceListPolling() ||
       !callback.Equals(device_list_callback_.callback()))
     return;
 
   new DiscoveryRequest(device_manager_.get(), callback);
 }
 
 void DevToolsAndroidBridge::ReceivedDeviceList(
     const CompleteDevices& complete_devices) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   device_map_.clear();
   RemoteDevices remote_devices;
   for (const auto& pair : complete_devices) {
     device_map_[pair.first->serial()] = pair.first;
     remote_devices.push_back(pair.second);
   }
 
   DeviceListListeners copy(device_list_listeners_);
   for (DeviceListListeners::iterator it = copy.begin(); it != copy.end(); ++it)
@@ skipping 20 matching lines @@
       base::Bind(&DevToolsAndroidBridge::ReceivedDeviceCount, AsWeakPtr()));
   RequestDeviceCount(device_count_callback_.callback());
 }
 
 void DevToolsAndroidBridge::StopDeviceCountPolling() {
   device_count_callback_.Cancel();
 }
 
 void DevToolsAndroidBridge::RequestDeviceCount(
     const base::Callback<void(int)>& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (device_count_listeners_.empty() ||
       !callback.Equals(device_count_callback_.callback()))
     return;
 
   UsbDeviceProvider::CountDevices(callback);
 }
 
 void DevToolsAndroidBridge::ReceivedDeviceCount(int count) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   DeviceCountListeners copy(device_count_listeners_);
   for (DeviceCountListeners::iterator it = copy.begin(); it != copy.end(); ++it)
     (*it)->DeviceCountChanged(count);
 
   if (device_count_listeners_.empty())
      return;
 
   task_scheduler_.Run(
       base::Bind(&DevToolsAndroidBridge::RequestDeviceCount,
@@ skipping 34 matching lines @@
     device_providers.push_back(
         new WebRTCDeviceProvider(profile_, signin_manager_, token_service_));
   }
 
   device_manager_->SetDeviceProviders(device_providers);
   if (NeedsDeviceListPolling()) {
     StopDeviceListPolling();
     StartDeviceListPolling();
   }
 }