Clean up HID backend and API.

The Mac backend no longer creates its own thread and instead simply enforces single-threaded usage on any thread which supports I/O. Ref management has also been sanitized.

The Linux backend now implements feature report support.

The backend interface no longer expects implicit report IDs in buffers passed to Write or SetFeatureReport. Instead these interfaces (as well as GetFeatureReport) take explicit report ID arguments.

The API interface has been updated to reflect the improved report ID treatment.

Finally, the API also now exposes opaque device identifiers on enumeration, rather than exposing raw system paths or other information that could be potentially sensitive.

BUG=347294

Review URL: https://codereview.chromium.org/161823002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@253853 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 33 insertions, 29 deletions

diff --git a/device/hid/hid_connection_mac.h b/device/hid/hid_connection_mac.h
index 88dfdaa..c307fb6 100644
--- a/device/hid/hid_connection_mac.h
+++ b/device/hid/hid_connection_mac.h
@@ -5,12 +5,21 @@
 #ifndef DEVICE_HID_HID_CONNECTION_MAC_H_
 #define DEVICE_HID_HID_CONNECTION_MAC_H_
 
-#include "base/callback.h"
+#include <CoreFoundation/CoreFoundation.h>
+#include <IOKit/hid/IOHIDManager.h>
+
+#include <queue>
+
+#include "base/mac/foundation_util.h"
 #include "base/memory/ref_counted.h"
-#include "base/tuple.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/threading/thread_checker.h"
 #include "device/hid/hid_connection.h"
 #include "device/hid/hid_device_info.h"
-#include "device/hid/hid_service_mac.h"
+
+namespace base {
+class MessageLoopProxy;
+}
 
 namespace net {
 class IOBuffer;
@@ -20,53 +29,48 @@ namespace device {
 
 class HidConnectionMac : public HidConnection {
  public:
-  HidConnectionMac(HidServiceMac* service,
-                   HidDeviceInfo device_info,
-                   IOHIDDeviceRef device);
+  explicit HidConnectionMac(HidDeviceInfo device_info);
 
-  virtual void Read(scoped_refptr<net::IOBuffer> buffer,
-                    size_t size,
+  virtual void Read(scoped_refptr<net::IOBufferWithSize> buffer,
                     const IOCallback& callback) OVERRIDE;
-  virtual void Write(scoped_refptr<net::IOBuffer> buffer,
-                     size_t size,
+  virtual void Write(uint8_t report_id,
+                     scoped_refptr<net::IOBufferWithSize> buffer,
                      const IOCallback& callback) OVERRIDE;
-  virtual void GetFeatureReport(scoped_refptr<net::IOBuffer> buffer,
-                                size_t size,
+  virtual void GetFeatureReport(uint8_t report_id,
+                                scoped_refptr<net::IOBufferWithSize> buffer,
                                 const IOCallback& callback) OVERRIDE;
-  virtual void SendFeatureReport(scoped_refptr<net::IOBuffer> buffer,
-                                 size_t size,
+  virtual void SendFeatureReport(uint8_t report_id,
+                                 scoped_refptr<net::IOBufferWithSize> buffer,
                                  const IOCallback& callback) OVERRIDE;
 
  private:
   virtual ~HidConnectionMac();
 
-  static void InputReportCallback(void * context,
+  static void InputReportCallback(void* context,
                                   IOReturn result,
-                                  void * sender,
+                                  void* sender,
                                   IOHIDReportType type,
-                                  uint32_t reportID,
-                                  uint8_t * report,
-                                  CFIndex reportLength);
+                                  uint32_t report_id,
+                                  uint8_t* report_bytes,
+                                  CFIndex report_length);
   void ProcessReadQueue();
   void ProcessInputReport(IOHIDReportType type,
-                          scoped_refptr<net::IOBuffer> report,
-                          CFIndex reportLength);
+                          scoped_refptr<net::IOBufferWithSize> buffer);
 
   void WriteReport(IOHIDReportType type,
-                   scoped_refptr<net::IOBuffer> buffer,
-                   size_t size,
+                   uint8_t report_id,
+                   scoped_refptr<net::IOBufferWithSize> buffer,
                    const IOCallback& callback);
 
-  HidServiceMac* service_;
   scoped_refptr<base::MessageLoopProxy> message_loop_;
+
   base::ScopedCFTypeRef<IOHIDDeviceRef> device_;
   scoped_ptr<uint8_t, base::FreeDeleter> inbound_buffer_;
-  bool disconnected_;
 
-  typedef std::pair<scoped_refptr<net::IOBuffer>, size_t> PendingReport;
-  std::queue<PendingReport> input_reports_;
-  typedef Tuple3<scoped_refptr<net::IOBuffer>, size_t, IOCallback> PendingRead;
-  std::queue<PendingRead> read_queue_;
+  std::queue<PendingHidReport> pending_reports_;
+  std::queue<PendingHidRead> pending_reads_;
+
+  base::ThreadChecker thread_checker_;
 
   DISALLOW_COPY_AND_ASSIGN(HidConnectionMac);
 };