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

device/hid/hid_connection_mac.cc

 // Copyright (c) 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/hid/hid_connection_mac.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/mac/foundation_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
+#include "components/device_event_log/device_event_log.h"
 #include "device/hid/hid_connection_mac.h"
 
 namespace device {
 
+namespace {
+
+std::string HexErrorCode(IOReturn error_code) {
+  return base::StringPrintf("0x%04x", error_code);
+}
+
+}  // namespace
+
 HidConnectionMac::HidConnectionMac(
     IOHIDDeviceRef device,
     scoped_refptr<HidDeviceInfo> device_info,
     scoped_refptr<base::SingleThreadTaskRunner> file_task_runner)
     : HidConnection(device_info),
       device_(device, base::scoped_policy::RETAIN),
       file_task_runner_(file_task_runner) {
   task_runner_ = base::ThreadTaskRunnerHandle::Get();
   DCHECK(task_runner_.get());
 
@@ skipping 25 matching lines @@
     IOHIDDeviceRegisterInputReportCallback(
         device_.get(), &inbound_buffer_[0], inbound_buffer_.size(), NULL, this);
     // Release the reference taken when this callback was registered.
     Release();
   }
 
   IOHIDDeviceUnscheduleFromRunLoop(
       device_.get(), CFRunLoopGetMain(), kCFRunLoopDefaultMode);
   IOReturn result = IOHIDDeviceClose(device_.get(), 0);
   if (result != kIOReturnSuccess) {
-    VLOG(1) << "Failed to close HID device: "
-            << base::StringPrintf("0x%04x", result);
+    HID_LOG(EVENT) << "Failed to close HID device: " << HexErrorCode(result);
   }
 
   while (!pending_reads_.empty()) {
     pending_reads_.front().callback.Run(false, NULL, 0);
     pending_reads_.pop();
   }
 }
 
 void HidConnectionMac::PlatformRead(const ReadCallback& callback) {
   DCHECK(thread_checker().CalledOnValidThread());
@@ skipping 39 matching lines @@
 // static
 void HidConnectionMac::InputReportCallback(void* context,
                                            IOReturn result,
                                            void* sender,
                                            IOHIDReportType type,
                                            uint32_t report_id,
                                            uint8_t* report_bytes,
                                            CFIndex report_length) {
   HidConnectionMac* connection = static_cast<HidConnectionMac*>(context);
   if (result != kIOReturnSuccess) {
-    VLOG(1) << "Failed to read input report: "
-            << base::StringPrintf("0x%08x", result);
+    HID_LOG(EVENT) << "Failed to read input report: " << HexErrorCode(result);
     return;
   }
 
   scoped_refptr<net::IOBufferWithSize> buffer;
   if (connection->device_info()->has_report_id()) {
     // report_id is already contained in report_bytes
     buffer = new net::IOBufferWithSize(report_length);
     memcpy(buffer->data(), report_bytes, report_length);
   } else {
     buffer = new net::IOBufferWithSize(report_length + 1);
@@ skipping 44 matching lines @@
                            report_id,
                            reinterpret_cast<uint8_t*>(buffer->data()),
                            &report_size);
   if (result == kIOReturnSuccess) {
     task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&HidConnectionMac::ReturnAsyncResult,
                    this,
                    base::Bind(callback, true, buffer, report_size)));
   } else {
-    VLOG(1) << "Failed to get feature report: "
-            << base::StringPrintf("0x%08x", result);
+    HID_LOG(EVENT) << "Failed to get feature report: " << HexErrorCode(result);
     task_runner_->PostTask(FROM_HERE,
                            base::Bind(&HidConnectionMac::ReturnAsyncResult,
                                       this,
                                       base::Bind(callback, false, nullptr, 0)));
   }
 }
 
 void HidConnectionMac::SetReportAsync(IOHIDReportType report_type,
                                       scoped_refptr<net::IOBuffer> buffer,
                                       size_t size,
@@ skipping 14 matching lines @@
   // of this function and believe it is a simple enough wrapper around the
   // kernel API that this is safe.
   IOReturn result =
       IOHIDDeviceSetReport(device_.get(), report_type, report_id, data, size);
   if (result == kIOReturnSuccess) {
     task_runner_->PostTask(FROM_HERE,
                            base::Bind(&HidConnectionMac::ReturnAsyncResult,
                                       this,
                                       base::Bind(callback, true)));
   } else {
-    VLOG(1) << "Failed to set report: " << base::StringPrintf("0x%08x", result);
+    HID_LOG(EVENT) << "Failed to set report: " << HexErrorCode(result);
     task_runner_->PostTask(FROM_HERE,
                            base::Bind(&HidConnectionMac::ReturnAsyncResult,
                                       this,
                                       base::Bind(callback, false)));
   }
 }
 
 void HidConnectionMac::ReturnAsyncResult(const base::Closure& callback) {
   callback.Run();
 }
 
 }  // namespace device