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

device/hid/hid_service_win.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/hid/hid_service_win.h"
 
 #define INITGUID
 
 #include <dbt.h>
 #include <setupapi.h>
 #include <winioctl.h>
 
 #include "base/bind.h"
 #include "base/files/file.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_util.h"
 #include "base/strings/sys_string_conversions.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_connection_win.h"
 #include "device/hid/hid_device_info.h"
 #include "net/base/io_buffer.h"
 
 // Setup API is required to enumerate HID devices.
 #pragma comment(lib, "setupapi.lib")
 #pragma comment(lib, "hid.lib")
 
 namespace device {
 
@@ skipping 26 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   const auto& map_entry = devices().find(device_id);
   if (map_entry == devices().end()) {
     task_runner_->PostTask(FROM_HERE, base::Bind(callback, nullptr));
     return;
   }
   scoped_refptr<HidDeviceInfo> device_info = map_entry->second;
 
   base::win::ScopedHandle file(OpenDevice(device_info->device_id()));
   if (!file.IsValid()) {
-    PLOG(ERROR) << "Failed to open device";
+    HID_PLOG(EVENT) << "Failed to open device";
     task_runner_->PostTask(FROM_HERE, base::Bind(callback, nullptr));
     return;
   }
 
   task_runner_->PostTask(
       FROM_HERE,
       base::Bind(callback, new HidConnectionWin(device_info, file.Pass())));
 }
 
 HidServiceWin::~HidServiceWin() {
@@ skipping 101 matching lines @@
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     const std::string& device_path) {
   base::win::ScopedHandle device_handle(OpenDevice(device_path));
   if (!device_handle.IsValid()) {
     return;
   }
 
   HIDD_ATTRIBUTES attrib = {0};
   attrib.Size = sizeof(HIDD_ATTRIBUTES);
   if (!HidD_GetAttributes(device_handle.Get(), &attrib)) {
-    VLOG(1) << "Failed to get device attributes.";
+    HID_LOG(EVENT) << "Failed to get device attributes.";
     return;
   }
 
   PHIDP_PREPARSED_DATA preparsed_data = nullptr;
   if (!HidD_GetPreparsedData(device_handle.Get(), &preparsed_data) ||
       !preparsed_data) {
-    VLOG(1) << "Failed to get device data.";
+    HID_LOG(EVENT) << "Failed to get device data.";
     return;
   }
 
   HIDP_CAPS capabilities = {0};
   if (HidP_GetCaps(preparsed_data, &capabilities) != HIDP_STATUS_SUCCESS) {
-    VLOG(1) << "Failed to get device capabilities.";
+    HID_LOG(EVENT) << "Failed to get device capabilities.";
     HidD_FreePreparsedData(preparsed_data);
     return;
   }
 
   // Whether or not the device includes report IDs in its reports the size
   // of the report ID is included in the value provided by Windows. This
   // appears contrary to the MSDN documentation.
   size_t max_input_report_size = 0;
   size_t max_output_report_size = 0;
   size_t max_feature_report_size = 0;
@@ skipping 84 matching lines @@
                   FILE_FLAG_OVERLAPPED, NULL));
   if (!file.IsValid() &&
       GetLastError() == base::File::FILE_ERROR_ACCESS_DENIED) {
     file.Set(CreateFileA(device_path.c_str(), GENERIC_READ, FILE_SHARE_READ,
                          NULL, OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL));
   }
   return file.Pass();
 }
 
 }  // namespace device