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

components/device_event_log/device_event_log.h

 // 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.
 
 #ifndef COMPONENTS_DEVICE_EVENT_LOG_DEVICE_EVENT_LOG_H_
 #define COMPONENTS_DEVICE_EVENT_LOG_DEVICE_EVENT_LOG_H_
 
 #include <cstring>
 #include <sstream>
 
 #include "base/basictypes.h"
+#include "base/logging.h"
 #include "base/timer/elapsed_timer.h"
 #include "components/device_event_log/device_event_log_export.h"
 
 // These macros can be used to log device related events.
 // The following values should be used for |level| in these macros:
 //  ERROR Unexpected events, or device level failures. Use sparingly.
 //  USER  Events initiated directly by a user (or Chrome) action.
 //  EVENT Default event type.
 //  DEBUG Debugging details that are usually not interesting.
 // Examples:
 //  NET_LOG(EVENT) << "NetworkState Changed " << name << ": " << state;
 //  POWER_LOG(USER) << "Suspend requested";
 
 #define NET_LOG(level)                             \
   DEVICE_LOG(::device_event_log::LOG_TYPE_NETWORK, \
              ::device_event_log::LOG_LEVEL_##level)
 #define POWER_LOG(level)                         \
   DEVICE_LOG(::device_event_log::LOG_TYPE_POWER, \
              ::device_event_log::LOG_LEVEL_##level)
 #define LOGIN_LOG(level)                         \
   DEVICE_LOG(::device_event_log::LOG_TYPE_LOGIN, \
              ::device_event_log::LOG_LEVEL_##level)
 #define USB_LOG(level)                         \
   DEVICE_LOG(::device_event_log::LOG_TYPE_USB, \
              ::device_event_log::LOG_LEVEL_##level)
+#define HID_LOG(level)                         \
+  DEVICE_LOG(::device_event_log::LOG_TYPE_HID, \
+             ::device_event_log::LOG_LEVEL_##level)
+#define HID_PLOG(level)                         \
+  DEVICE_PLOG(::device_event_log::LOG_TYPE_HID, \
+              ::device_event_log::LOG_LEVEL_##level)
 
-// Generally prefer the above macros unless |type| or  |level| is not constant.
+// Generally prefer the above macros unless |type| or |level| is not constant.
 
 #define DEVICE_LOG(type, level)                                            \
   ::device_event_log::internal::DeviceEventLogInstance(__FILE__, __LINE__, \
                                                        type, level).stream()
+#define DEVICE_PLOG(type, level)                                            \
+  ::device_event_log::internal::DeviceEventSystemErrorLogInstance(          \
+      __FILE__, __LINE__, type, level, ::logging::GetLastSystemErrorCode()) \
+      .stream()
 
 // Declare {Type_LOG_IF_SLOW() at the top of a method to log slow methods
 // where "slow" is defined by kSlowMethodThresholdMs in the .cc file.
 #define SCOPED_NET_LOG_IF_SLOW() \
   SCOPED_DEVICE_LOG_IF_SLOW(::device_event_log::LOG_TYPE_NETWORK)
 
 // Generally prefer the above macros unless |type| is not constant.
 
 #define SCOPED_DEVICE_LOG_IF_SLOW(type)               \
   ::device_event_log::internal::ScopedDeviceLogIfSlow \
       scoped_device_log_if_slow(type, __FILE__, __func__)
 
 namespace device_event_log {
 
 // Used to specify the type of event. NOTE: Be sure to update LogTypeFromString
 // and GetLogTypeString when adding entries to this enum. Also consider
 // updating chrome://device-log (see device_log_ui.cc).
 enum LogType {
   // Shill / network configuration related events.
   LOG_TYPE_NETWORK,
   // Power manager related events.
   LOG_TYPE_POWER,
   // Login related events.
   LOG_TYPE_LOGIN,
   // USB device related events (i.e. device/usb).
   LOG_TYPE_USB,
+  // Human-interface device related events (i.e. device/hid).
+  LOG_TYPE_HID,
   // Used internally
   LOG_TYPE_UNKNOWN
 };
 
 // Used to specify the detail level for logging. In GetAsString, used to
 // specify the maximum detail level (i.e. EVENT will include USER and ERROR).
 // See top-level comment for guidelines for each type.
 enum LogLevel {
   LOG_LEVEL_ERROR = 0,
   LOG_LEVEL_USER = 1,
@@ skipping 70 matching lines @@
  private:
   const char* file_;
   const int line_;
   device_event_log::LogType type_;
   device_event_log::LogLevel level_;
   std::ostringstream stream_;
 
   DISALLOW_COPY_AND_ASSIGN(DeviceEventLogInstance);
 };
 
+// Implementation class for DEVICE_PLOG macros. Provides a stream for creating
+// a log string and adds the event, including system error code, using
+// device_event_log::AddEntry on destruction.
+class DEVICE_EVENT_LOG_EXPORT DeviceEventSystemErrorLogInstance {
+ public:
+  DeviceEventSystemErrorLogInstance(const char* file,
+                                    int line,
+                                    device_event_log::LogType type,
+                                    device_event_log::LogLevel level,
+                                    logging::SystemErrorCode err);
+  ~DeviceEventSystemErrorLogInstance();
+
+  std::ostream& stream() { return log_instance_.stream(); }
+
+ private:
+  logging::SystemErrorCode err_;
+  // Constructor parameters are passed to |log_instance_| which will update the
+  // log when it is destroyed (after a string description of |err_| is appended
+  // to the stream).
+  DeviceEventLogInstance log_instance_;
+
+  DISALLOW_COPY_AND_ASSIGN(DeviceEventSystemErrorLogInstance);
+};
+
 // Implementation class for SCOPED_LOG_IF_SLOW macros. Tests the elapsed time on
 // destruction and adds a Debug or Error log entry if it exceeds the
 // corresponding expected maximum elapsed time.
 class DEVICE_EVENT_LOG_EXPORT ScopedDeviceLogIfSlow {
  public:
   ScopedDeviceLogIfSlow(LogType type,
                         const char* file,
                         const std::string& name);
   ~ScopedDeviceLogIfSlow();
 
  private:
   const char* file_;
   LogType type_;
   std::string name_;
   base::ElapsedTimer timer_;
 };
 
 }  // namespace internal
 
 }  // namespace device_event_log
 
 #endif  // DEVICE_EVENT_LOG_DEVICE_EVENT_LOG_H_