favor DCHECK_CURRENTLY_ON for better logs in chrome/browser/devtools

chrome/browser/devtools/device/usb/android_usb_device.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/usb/android_usb_device.h"
 
 #include <set>
 
 #include "base/barrier_closure.h"
 #include "base/base64.h"
@@ skipping 162 matching lines @@
 
   // Return all claimed devices.
   AndroidUsbDevices result(g_devices.Get().begin(), g_devices.Get().end());
   callback.Run(result);
 }
 
 static void RespondOnFileThread(
     const AndroidUsbDevicesCallback& callback,
     AndroidUsbDevices* devices,
     scoped_refptr<base::MessageLoopProxy> caller_message_loop_proxy) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   caller_message_loop_proxy->PostTask(
       FROM_HERE,
       base::Bind(&RespondOnCallerThread, callback, devices));
 }
 
 static void OpenAndroidDeviceOnFileThread(
     AndroidUsbDevices* devices,
     crypto::RSAPrivateKey* rsa_key,
     const base::Closure& barrier,
     scoped_refptr<UsbDevice> device,
     int interface_id,
     bool success) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   if (success) {
     base::string16 serial;
     if (device->GetSerialNumber(&serial) && !serial.empty()) {
       const UsbConfigDescriptor* config = device->GetConfiguration();
       if (config) {
         scoped_refptr<UsbDeviceHandle> usb_handle = device->Open();
         if (usb_handle.get()) {
           scoped_refptr<AndroidUsbDevice> android_device = ClaimInterface(
               rsa_key, usb_handle, serial, config->interfaces[interface_id]);
           if (android_device.get())
             devices->push_back(android_device);
           else
             usb_handle->Close();
         }
       }
     }
   }
   barrier.Run();
 }
 
 static int CountOnFileThread() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   UsbService* service = device::DeviceClient::Get()->GetUsbService();
   UsbDevices usb_devices;
   if (service != NULL)
     service->GetDevices(&usb_devices);
   int device_count = 0;
   for (const scoped_refptr<UsbDevice>& device : usb_devices) {
     const UsbConfigDescriptor* config = device->GetConfiguration();
     if (config) {
       for (const UsbInterfaceDescriptor& iface : config->interfaces) {
         if (IsAndroidInterface(iface)) {
           ++device_count;
         }
       }
     }
   }
   return device_count;
 }
 
 static void EnumerateOnFileThread(
     crypto::RSAPrivateKey* rsa_key,
     const AndroidUsbDevicesCallback& callback,
     scoped_refptr<base::MessageLoopProxy> caller_message_loop_proxy) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
   UsbService* service = device::DeviceClient::Get()->GetUsbService();
   UsbDevices usb_devices;
   if (service != NULL)
     service->GetDevices(&usb_devices);
 
   // Add new devices.
   AndroidUsbDevices* devices = new AndroidUsbDevices();
   base::Closure barrier = base::BarrierClosure(
       usb_devices.size(), base::Bind(&RespondOnFileThread,
@@ skipping 353 matching lines @@
 
 void AndroidUsbDevice::TransferError(UsbTransferStatus status) {
   DCHECK(message_loop_ == base::MessageLoop::current());
 
   message_loop_->PostTask(FROM_HERE,
                           base::Bind(&AndroidUsbDevice::Terminate, this));
 }
 
 void AndroidUsbDevice::TerminateIfReleased(
     scoped_refptr<UsbDeviceHandle> usb_handle) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   if (usb_handle->GetDevice().get())
     return;
   message_loop_->PostTask(FROM_HERE,
                           base::Bind(&AndroidUsbDevice::Terminate, this));
 }
 
 void AndroidUsbDevice::Terminate() {
   DCHECK(message_loop_ == base::MessageLoop::current());
 
   std::vector<AndroidUsbDevice*>::iterator it =
@@ skipping 20 matching lines @@
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&ReleaseInterface, usb_handle, interface_id_));
 }
 
 void AndroidUsbDevice::SocketDeleted(uint32 socket_id) {
   DCHECK(message_loop_ == base::MessageLoop::current());
 
   sockets_.erase(socket_id);
 }