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

device/usb/usb_service_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_service_impl.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/memory/weak_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "device/usb/usb_error.h"
+#include "device/usb/usb_log.h"
 
 #if defined(OS_WIN)
 #include <usbiodef.h>
 
 #include "base/scoped_observer.h"
 #include "device/core/device_monitor_win.h"
 #endif  // OS_WIN
 
 namespace device {
 
@@ skipping 36 matching lines @@
   ScopedObserver<DeviceMonitorWin, DeviceMonitorWin::Observer> device_observer_;
 };
 #endif
 
 // static
 UsbService* UsbServiceImpl::Create(
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner) {
   PlatformUsbContext context = NULL;
   const int rv = libusb_init(&context);
   if (rv != LIBUSB_SUCCESS) {
-    VLOG(1) << "Failed to initialize libusb: "
-            << ConvertPlatformUsbErrorToString(rv);
+    USB_LOG(ERROR) << "Failed to initialize libusb: "
+                   << ConvertPlatformUsbErrorToString(rv);
     return nullptr;
   }
   if (!context) {
     return nullptr;
   }
 
   return new UsbServiceImpl(context, ui_task_runner);
 }
 
 scoped_refptr<UsbDevice> UsbServiceImpl::GetDeviceById(uint32 unique_id) {
@@ skipping 62 matching lines @@
   }
 }
 
 void UsbServiceImpl::RefreshDevices() {
   DCHECK(CalledOnValidThread());
 
   libusb_device** platform_devices = NULL;
   const ssize_t device_count =
       libusb_get_device_list(context_->context(), &platform_devices);
   if (device_count < 0) {
-    VLOG(1) << "Failed to get device list: "
-            << ConvertPlatformUsbErrorToString(device_count);
+    USB_LOG(ERROR) << "Failed to get device list: "
+                   << ConvertPlatformUsbErrorToString(device_count);
   }
 
   std::set<UsbDevice*> connected_devices;
   std::vector<PlatformUsbDevice> disconnected_devices;
 
   // Populates new devices.
   for (ssize_t i = 0; i < device_count; ++i) {
     if (!ContainsKey(platform_devices_, platform_devices[i])) {
       scoped_refptr<UsbDeviceImpl> new_device = AddDevice(platform_devices[i]);
       if (new_device) {
@@ skipping 38 matching lines @@
     } while (devices_.find(unique_id) != devices_.end());
 
     scoped_refptr<UsbDeviceImpl> new_device(new UsbDeviceImpl(
         context_, ui_task_runner_, platform_device, descriptor.idVendor,
         descriptor.idProduct, unique_id));
     platform_devices_[platform_device] = new_device;
     devices_[unique_id] = new_device;
     NotifyDeviceAdded(new_device);
     return new_device;
   } else {
-    VLOG(1) << "Failed to get device descriptor: "
-            << ConvertPlatformUsbErrorToString(rv);
+    USB_LOG(DEBUG) << "Failed to get device descriptor: "
+                   << ConvertPlatformUsbErrorToString(rv);
     return nullptr;
   }
 }
 
 // static
 int LIBUSB_CALL UsbServiceImpl::HotplugCallback(libusb_context* context,
                                                 PlatformUsbDevice device,
                                                 libusb_hotplug_event event,
                                                 void* user_data) {
   // It is safe to access the UsbServiceImpl* here because libusb takes a lock
@@ skipping 54 matching lines @@
     NotifyDeviceRemoved(device);
     device->OnDisconnect();
   } else {
     NOTREACHED();
   }
 
   libusb_unref_device(platform_device);
 }
 
 }  // namespace device