Clean up HID backend and API.

chrome/common/extensions/api/hid.idl

 // 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.
 
 // Use the <code>chrome.hid</code> API to interact with connected HID devices.
 // This API provides access to HID operations from within the context of an app.
 // Using this API, apps can function as drivers for hardware devices.
 namespace hid {
 
   // Returned by <code>getDevices</code> functions to describes a connected HID
   // device. Use <code>connect</code> to connect to any of the returned devices.
   dictionary HidDeviceInfo {
-    DOMString path;
+    long deviceId;
     long vendorId;
     long productId;
   };
 
   // Returned by <code>connect</code> to represent a communication session with
   // an HID device. Must be closed with a call to <code>disconnect</code>.
   dictionary HidConnectInfo {
     long connectionId;
   };
 
@@ skipping 15 matching lines @@
 
   interface Functions {
     // Enumerate all the connected HID devices specified by the vendorId/
     // productId/interfaceId tuple.
     // |options|: The properties to search for on target devices.
     // |callback|: Invoked with the <code>HidDeviceInfo</code> array on success.
     static void getDevices(GetDevicesOptions options,
                            GetDevicesCallback callback);
 
     // Open a connection to an HID device for communication.
-    // |deviceInfo|: The device to open.
+    // |deviceId|: The ID of the device to open.
     // |callback|: Invoked with an <code>HidConnectInfo</code>.
-    static void connect(HidDeviceInfo deviceInfo,
+    static void connect(long deviceId,
                         ConnectCallback callback);
 
     // Disconnect from a device. Invoking operations on a device after calling
     // this is safe but has no effect.
     // |connectionId|: The connection to close.
     // |callback|: The callback to invoke once the device is closed.
     static void disconnect(long connectionId,
                            optional DisconnectCallback callback);
 
     // Receive an Input report from an HID device.
     //
     // Input reports are returned to the host through the INTERRUPT IN endpoint.
     // |connectionId|: The connection from which to receive a report.
     // |size|: The size of the Input report to receive.
     // |callback|: The callback to invoke with received report.
     static void receive(long connectionId,
                         long size,
                         ReceiveCallback callback);
 
     // Send an Output report to an HID device.
     // <code>send</code> will send the data on the first OUT endpoint, if one
     // exists. If one does not exist, the report will be sent through the
     // Control endpoint.
     //
     // |connectionId|: The connection to which to send a report.
+    // |reportId|: The report ID to use, or <code>0</code> if none.
     // |data|: The report data.
     // |callback|: The callback to invoke once the write is finished.
     static void send(long connectionId,
+                     long reportId,
                      ArrayBuffer data,
                      SendCallback callback);
 
     // Receive a Feature report from the device.
     //
     // |connectionId|: The connection to read Input report from.
+    // |reportId|: The report ID, or zero if none.
     // |size|: The size of the Feature report to receive.
     // |callback|: The callback to invoke once the write is finished.
     static void receiveFeatureReport(long connectionId,
+                                     long reportId,
                                      long size,
                                      ReceiveCallback callback);
 
     // Send a Feature report to the device.
     //
     // Feature reports are sent over the Control endpoint as a Set_Report
     // transfer.
     // |connectionId|: The connection to read Input report from.
+    // |reportId|: The report ID to use, or <code>0</code> if none.
     // |data|: The report data.
     // |callback|: The callback to invoke once the write is finished.
     static void sendFeatureReport(long connectionId,
+                                  long reportId,
                                   ArrayBuffer data,
                                   SendCallback callback);
   };
 };