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

device/hid/hid_connection_linux.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_linux.h"
 
 #include <errno.h>
 #include <linux/hidraw.h>
 #include <sys/ioctl.h>
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_pump_libevent.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread_restrictions.h"
+#include "components/device_event_log/device_event_log.h"
 #include "device/hid/hid_service.h"
 
 // These are already defined in newer versions of linux/hidraw.h.
 #ifndef HIDIOCSFEATURE
 #define HIDIOCSFEATURE(len) _IOC(_IOC_WRITE | _IOC_READ, 'H', 0x06, len)
 #endif
 #ifndef HIDIOCGFEATURE
 #define HIDIOCGFEATURE(len) _IOC(_IOC_WRITE | _IOC_READ, 'H', 0x07, len)
 #endif
 
@@ skipping 20 matching lines @@
 
   // Starts the FileDescriptorWatcher that reads input events from the device.
   // Must be called on a thread that has a base::MessageLoopForIO. The helper
   // object is owned by the thread where it was started.
   void Start() {
     base::ThreadRestrictions::AssertIOAllowed();
     thread_checker_.DetachFromThread();
     if (!base::MessageLoopForIO::current()->WatchFileDescriptor(
             platform_file_, true, base::MessageLoopForIO::WATCH_READ,
             &file_watcher_, this)) {
-      LOG(ERROR) << "Failed to start watching device file.";
+      HID_LOG(ERROR) << "Failed to start watching device file.";
     }
   }
 
  private:
   // base::MessagePumpLibevent::Watcher implementation.
   void OnFileCanReadWithoutBlocking(int fd) override {
     DCHECK(thread_checker_.CalledOnValidThread());
     DCHECK_EQ(fd, platform_file_);
 
     scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(report_buffer_size_));
     char* data = buffer->data();
     size_t length = report_buffer_size_;
     if (!has_report_id_) {
       // Linux will not prefix the buffer with a report ID if report IDs are not
       // used by the device. Prefix the buffer with 0.
       *data++ = 0;
       length--;
     }
 
     ssize_t bytes_read = HANDLE_EINTR(read(platform_file_, data, length));
     if (bytes_read < 0) {
       if (errno != EAGAIN) {
-        VPLOG(1) << "Read failed";
+        HID_PLOG(EVENT) << "Read failed";
         // This assumes that the error is unrecoverable and disables reading
         // from the device until it has been re-opened.
         // TODO(reillyg): Investigate starting and stopping the file descriptor
         // watcher in response to pending read requests so that per-request
         // errors can be returned to the client.
         file_watcher_.StopWatchingFileDescriptor();
       }
       return;
     }
     if (!has_report_id_) {
@@ skipping 111 matching lines @@
                  device_file_.GetPlatformFile(), HIDIOCSFEATURE(size), buffer,
                  base::Bind(&HidConnectionLinux::FinishSendFeatureReport,
                             weak_factory_.GetWeakPtr(), callback),
                  task_runner_));
 }
 
 void HidConnectionLinux::FinishWrite(size_t expected_size,
                                      const WriteCallback& callback,
                                      ssize_t result) {
   if (result < 0) {
-    VPLOG(1) << "Write failed";
+    HID_PLOG(EVENT) << "Write failed";
     callback.Run(false);
   } else {
     if (static_cast<size_t>(result) != expected_size) {
-      LOG(WARNING) << "Incomplete HID write: " << result
-                   << " != " << expected_size;
+      HID_LOG(EVENT) << "Incomplete HID write: " << result
+                     << " != " << expected_size;
     }
     callback.Run(true);
   }
 }
 
 void HidConnectionLinux::FinishGetFeatureReport(
     uint8_t report_id,
     scoped_refptr<net::IOBuffer> buffer,
     const ReadCallback& callback,
     int result) {
   if (result < 0) {
-    VPLOG(1) << "Failed to get feature report";
+    HID_PLOG(EVENT) << "Failed to get feature report";
     callback.Run(false, NULL, 0);
   } else if (result == 0) {
-    VLOG(1) << "Get feature result too short.";
+    HID_LOG(EVENT) << "Get feature result too short.";
     callback.Run(false, NULL, 0);
   } else if (report_id == 0) {
     // Linux adds a 0 to the beginning of the data received from the device.
     scoped_refptr<net::IOBuffer> copied_buffer(new net::IOBuffer(result - 1));
     memcpy(copied_buffer->data(), buffer->data() + 1, result - 1);
     callback.Run(true, copied_buffer, result - 1);
   } else {
     callback.Run(true, buffer, result);
   }
 }
 
 void HidConnectionLinux::FinishSendFeatureReport(const WriteCallback& callback,
                                                  int result) {
   if (result < 0) {
-    VPLOG(1) << "Failed to send feature report";
+    HID_PLOG(EVENT) << "Failed to send feature report";
     callback.Run(false);
   } else {
     callback.Run(true);
   }
 }
 
 // static
 void HidConnectionLinux::BlockingWrite(
     base::PlatformFile platform_file,
     scoped_refptr<net::IOBuffer> buffer,
@@ skipping 39 matching lines @@
     PendingHidReport report = pending_reports_.front();
 
     pending_reports_.pop();
     if (CompleteRead(report.buffer, report.size, read.callback)) {
       pending_reads_.pop();
     }
   }
 }
 
 }  // namespace device