Log device/usb messages to chrome://device-log.

device/usb/usb_device_impl.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 "device/usb/usb_device_impl.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "device/usb/usb_context.h"
 #include "device/usb/usb_descriptors.h"
 #include "device/usb/usb_device_handle_impl.h"
 #include "device/usb/usb_error.h"
+#include "device/usb/usb_log.h"
 #include "third_party/libusb/src/libusb/libusb.h"
 
 #if defined(OS_CHROMEOS)
 #include "base/sys_info.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/permission_broker_client.h"
 #endif  // defined(OS_CHROMEOS)
 
 #if defined(USE_UDEV)
 #include "device/udev_linux/scoped_udev.h"
@@ skipping 184 matching lines @@
 scoped_refptr<UsbDeviceHandle> UsbDeviceImpl::Open() {
   DCHECK(thread_checker_.CalledOnValidThread());
   PlatformUsbDeviceHandle handle;
   const int rv = libusb_open(platform_device_, &handle);
   if (LIBUSB_SUCCESS == rv) {
     scoped_refptr<UsbDeviceHandleImpl> device_handle =
         new UsbDeviceHandleImpl(context_, this, handle);
     handles_.push_back(device_handle);
     return device_handle;
   } else {
-    VLOG(1) << "Failed to open device: " << ConvertPlatformUsbErrorToString(rv);
+    USB_LOG(DEBUG) << "Failed to open device: "
+                   << ConvertPlatformUsbErrorToString(rv);

[stevenjb, 2015/02/20 00:01:27]

These seem like they should be actual ERROR events.

     return NULL;
   }
 }
 
 bool UsbDeviceImpl::Close(scoped_refptr<UsbDeviceHandle> handle) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   for (HandlesVector::iterator it = handles_.begin(); it != handles_.end();
        ++it) {
     if (it->get() == handle.get()) {
@@ skipping 60 matching lines @@
   for (const scoped_refptr<UsbDeviceHandleImpl>& handle : handles_) {
     handle->InternalClose();
   }
 }
 
 void UsbDeviceImpl::RefreshConfiguration() {
   libusb_config_descriptor* platform_config;
   int rv =
       libusb_get_active_config_descriptor(platform_device_, &platform_config);
   if (rv != LIBUSB_SUCCESS) {
-    VLOG(1) << "Failed to get config descriptor: "
-            << ConvertPlatformUsbErrorToString(rv);
+    USB_LOG(DEBUG) << "Failed to get config descriptor: "
+                   << ConvertPlatformUsbErrorToString(rv);
     return;
   }
 
   configuration_.reset(new UsbConfigDescriptor());
   configuration_->configuration_value = platform_config->bConfigurationValue;
   configuration_->self_powered = (platform_config->bmAttributes & 0x40) != 0;
   configuration_->remote_wakeup = (platform_config->bmAttributes & 0x20) != 0;
   configuration_->maximum_power = platform_config->MaxPower * 2;
 
   for (size_t i = 0; i < platform_config->bNumInterfaces; ++i) {
@@ skipping 58 matching lines @@
         device_handle->GetStringDescriptor(desc.iManufacturer, &manufacturer_);
       }
       if (desc.iProduct != 0) {
         device_handle->GetStringDescriptor(desc.iProduct, &product_);
       }
       if (desc.iSerialNumber != 0) {
         device_handle->GetStringDescriptor(desc.iSerialNumber, &serial_number_);
       }
       device_handle->Close();
     } else {
-      VLOG(1) << "Failed to open device to cache string descriptors.";
+      USB_LOG(DEBUG) << "Failed to open device to cache string descriptors.";
     }
   } else {
-    VLOG(1) << "Failed to read device descriptor to cache string descriptors: "
-            << ConvertPlatformUsbErrorToString(rv);
+    USB_LOG(DEBUG)
+        << "Failed to read device descriptor to cache string descriptors: "
+        << ConvertPlatformUsbErrorToString(rv);
   }
   strings_cached_ = true;
 }
 #endif  // !defined(USE_UDEV)
 
 }  // namespace device