Map the HidPlatformDeviceId to HidDeviceId.

Before mojofication on Hid, we have to add typemapping for HidDeviceId first.
HidDeviceId is defined as uint64_t on MacOS while as string on other
platforms.

In this CL, we rename the original HidDeviceId to HidPlatformDeviceId, and
define the new HidDeviceId type as uint64_t. we map the PlatformHidDeviceId
to HidDeviceId. 

All clients of HidService should hold the new HidDeviceId instead of the
PlatformHidDeviceId.

BUG=728223

Change-Id: I3585c9eb0eacb02571258314c14e063adce653fc
Reviewed-on: https://chromium-review.googlesource.com/570201Reviewed-by: Reilly Grant <reillyg@chromium.org>
Commit-Queue: Ke He <ke.he@intel.com>
Cr-Commit-Position: refs/heads/master@{#488837}

chrome/browser/extensions/api/device_permissions_manager_unittest.cc

@@ -184,8 +184,8 @@ TEST_F(DevicePermissionsManagerTest, DisconnectDevice) {
 
   device_client_.usb_service()->RemoveDevice(device0_);
   device_client_.usb_service()->RemoveDevice(device1_);
-  device_client_.hid_service()->RemoveDevice(device4_->device_id());
-  device_client_.hid_service()->RemoveDevice(device5_->device_id());
+  device_client_.hid_service()->RemoveDevice(device4_->platform_device_id());
+  device_client_.hid_service()->RemoveDevice(device5_->platform_device_id());
 
   // Device 0 will be accessible when it is reconnected because it can be
   // recognized by its serial number.

device/hid/hid_connection_unittest.cc

@@ -34,8 +34,8 @@ using net::IOBufferWithSize;
 // serial number is available. Example usage:
 //
 //   DeviceCatcher device_catcher("ABC123");
-//   HidDeviceId device_id = device_catcher.WaitForDevice();
-//   /* Call HidService::Connect(device_id) to open the device. */
+//   std::string device_guid = device_catcher.WaitForDevice();
+//   /* Call HidService::Connect(device_guid) to open the device. */
 //
 class DeviceCatcher : HidService::Observer {
  public:
@@ -46,10 +46,10 @@ class DeviceCatcher : HidService::Observer {
                                        base::Unretained(this)));
   }
 
-  const HidDeviceId& WaitForDevice() {
+  const std::string& WaitForDevice() {
     run_loop_.Run();
     observer_.RemoveAll();
-    return device_id_;
+    return device_guid_;
   }
 
  private:
@@ -57,7 +57,7 @@ class DeviceCatcher : HidService::Observer {
       const std::vector<scoped_refptr<HidDeviceInfo>>& devices) {
     for (const scoped_refptr<HidDeviceInfo>& device_info : devices) {
       if (device_info->serial_number() == serial_number_) {
-        device_id_ = device_info->device_id();
+        device_guid_ = device_info->device_guid();
         run_loop_.Quit();
         break;
       }
@@ -66,7 +66,7 @@ class DeviceCatcher : HidService::Observer {
 
   void OnDeviceAdded(scoped_refptr<HidDeviceInfo> device_info) override {
     if (device_info->serial_number() == serial_number_) {
-      device_id_ = device_info->device_id();
+      device_guid_ = device_info->device_guid();
       run_loop_.Quit();
     }
   }
@@ -74,7 +74,7 @@ class DeviceCatcher : HidService::Observer {
   std::string serial_number_;
   ScopedObserver<device::HidService, device::HidService::Observer> observer_;
   base::RunLoop run_loop_;
-  HidDeviceId device_id_;
+  std::string device_guid_;
 };
 
 class TestConnectCallback {
@@ -168,8 +168,8 @@ class HidConnectionTest : public testing::Test {
 
     DeviceCatcher device_catcher(service_,
                                  test_gadget_->GetDevice()->serial_number());
-    device_id_ = device_catcher.WaitForDevice();
-    ASSERT_NE(device_id_, kInvalidHidDeviceId);
+    device_guid_ = device_catcher.WaitForDevice();
+    ASSERT_FALSE(device_guid_.empty());
   }
 
   base::test::ScopedTaskEnvironment scoped_task_environment_;
@@ -177,14 +177,14 @@ class HidConnectionTest : public testing::Test {
   TestDeviceClient device_client_;
   HidService* service_;
   std::unique_ptr<UsbTestGadget> test_gadget_;
-  HidDeviceId device_id_;
+  std::string device_guid_;
 };
 
 TEST_F(HidConnectionTest, ReadWrite) {
   if (!UsbTestGadget::IsTestEnabled()) return;
 
   TestConnectCallback connect_callback;
-  service_->Connect(device_id_, connect_callback.callback());
+  service_->Connect(device_guid_, connect_callback.callback());
   scoped_refptr<HidConnection> conn = connect_callback.WaitForConnection();
   ASSERT_TRUE(conn.get());
 

device/hid/hid_device_info.cc

@@ -2,24 +2,23 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "build/build_config.h"
 #include "device/hid/hid_device_info.h"
+
+#include "base/guid.h"
+#include "build/build_config.h"
 #include "device/hid/hid_report_descriptor.h"
 
 namespace device {
 
-#if !defined(OS_MACOSX)
-const char kInvalidHidDeviceId[] = "";
-#endif
-
-HidDeviceInfo::HidDeviceInfo(const HidDeviceId& device_id,
+HidDeviceInfo::HidDeviceInfo(const HidPlatformDeviceId& platform_device_id,
                              uint16_t vendor_id,
                              uint16_t product_id,
                              const std::string& product_name,
                              const std::string& serial_number,
                              HidBusType bus_type,
                              const std::vector<uint8_t> report_descriptor)
-    : device_id_(device_id),
+    : guid_(base::GenerateGUID()),
+      platform_device_id_(platform_device_id),
       vendor_id_(vendor_id),
       product_id_(product_id),
       product_name_(product_name),
@@ -32,7 +31,7 @@ HidDeviceInfo::HidDeviceInfo(const HidDeviceId& device_id,
       &max_output_report_size_, &max_feature_report_size_);
 }
 
-HidDeviceInfo::HidDeviceInfo(const HidDeviceId& device_id,
+HidDeviceInfo::HidDeviceInfo(const HidPlatformDeviceId& platform_device_id,
                              uint16_t vendor_id,
                              uint16_t product_id,
                              const std::string& product_name,
@@ -42,7 +41,8 @@ HidDeviceInfo::HidDeviceInfo(const HidDeviceId& device_id,
                              size_t max_input_report_size,
                              size_t max_output_report_size,
                              size_t max_feature_report_size)
-    : device_id_(device_id),
+    : guid_(base::GenerateGUID()),
+      platform_device_id_(platform_device_id),
       vendor_id_(vendor_id),
       product_id_(product_id),
       product_name_(product_name),

device/hid/hid_device_info.h

@@ -24,16 +24,14 @@ enum HidBusType {
 };
 
 #if defined(OS_MACOSX)
-typedef uint64_t HidDeviceId;
-const uint64_t kInvalidHidDeviceId = -1;
+typedef uint64_t HidPlatformDeviceId;
 #else
-typedef std::string HidDeviceId;
-extern const char kInvalidHidDeviceId[];
+typedef std::string HidPlatformDeviceId;
 #endif
 
 class HidDeviceInfo : public base::RefCountedThreadSafe<HidDeviceInfo> {
  public:
-  HidDeviceInfo(const HidDeviceId& device_id,
+  HidDeviceInfo(const HidPlatformDeviceId& platform_device_id,
                 uint16_t vendor_id,
                 uint16_t product_id,
                 const std::string& product_name,
@@ -41,7 +39,7 @@ class HidDeviceInfo : public base::RefCountedThreadSafe<HidDeviceInfo> {
                 HidBusType bus_type,
                 const std::vector<uint8_t> report_descriptor);
 
-  HidDeviceInfo(const HidDeviceId& device_id,
+  HidDeviceInfo(const HidPlatformDeviceId& platform_device_id,
                 uint16_t vendor_id,
                 uint16_t product_id,
                 const std::string& product_name,
@@ -53,7 +51,10 @@ class HidDeviceInfo : public base::RefCountedThreadSafe<HidDeviceInfo> {
                 size_t max_feature_report_size);
 
   // Device identification.
-  const HidDeviceId& device_id() const { return device_id_; }
+  const std::string& device_guid() const { return guid_; }
+  const HidPlatformDeviceId& platform_device_id() const {
+    return platform_device_id_;
+  }
   uint16_t vendor_id() const { return vendor_id_; }
   uint16_t product_id() const { return product_id_; }
   const std::string& product_name() const { return product_name_; }
@@ -80,8 +81,9 @@ class HidDeviceInfo : public base::RefCountedThreadSafe<HidDeviceInfo> {
  private:
   friend class base::RefCountedThreadSafe<HidDeviceInfo>;
 
-  // Device identification.
-  HidDeviceId device_id_;
+  // Device identification for client.
+  std::string guid_;
+  HidPlatformDeviceId platform_device_id_;
   uint16_t vendor_id_;
   uint16_t product_id_;
   std::string product_name_;

device/hid/hid_device_info_linux.cc

@@ -7,7 +7,7 @@
 namespace device {
 
 HidDeviceInfoLinux::HidDeviceInfoLinux(
-    const HidDeviceId& device_id,
+    const HidPlatformDeviceId& platform_device_id,
     const std::string& device_node,
     uint16_t vendor_id,
     uint16_t product_id,
@@ -15,7 +15,7 @@ HidDeviceInfoLinux::HidDeviceInfoLinux(
     const std::string& serial_number,
     HidBusType bus_type,
     const std::vector<uint8_t> report_descriptor)
-    : HidDeviceInfo(device_id,
+    : HidDeviceInfo(platform_device_id,
                     vendor_id,
                     product_id,
                     product_name,

device/hid/hid_device_info_linux.h

@@ -13,7 +13,7 @@ namespace device {
 
 class HidDeviceInfoLinux : public HidDeviceInfo {
  public:
-  HidDeviceInfoLinux(const HidDeviceId& device_id,
+  HidDeviceInfoLinux(const HidPlatformDeviceId& platform_device_id,
                      const std::string& device_node,
                      uint16_t vendor_id,
                      uint16_t product_id,

device/hid/hid_service.cc

@@ -73,11 +73,10 @@ void HidService::RemoveObserver(HidService::Observer* observer) {
   observer_list_.RemoveObserver(observer);
 }
 
-// Fills in the device info struct of the given device_id.
 scoped_refptr<HidDeviceInfo> HidService::GetDeviceInfo(
-    const HidDeviceId& device_id) const {
+    const std::string& device_guid) const {
   DCHECK(thread_checker_.CalledOnValidThread());
-  DeviceMap::const_iterator it = devices_.find(device_id);
+  DeviceMap::const_iterator it = devices_.find(device_guid);
   if (it == devices_.end()) {
     return nullptr;
   }
@@ -92,8 +91,11 @@ HidService::~HidService() {
 
 void HidService::AddDevice(scoped_refptr<HidDeviceInfo> device_info) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (!base::ContainsKey(devices_, device_info->device_id())) {
-    devices_[device_info->device_id()] = device_info;
+
+  std::string device_guid =
+      FindDeviceIdByPlatformDeviceId(device_info->platform_device_id());
+  if (device_guid.empty()) {
+    devices_[device_info->device_guid()] = device_info;
 
     HID_LOG(USER) << "HID device "
                   << (enumeration_ready_ ? "added" : "detected")
@@ -101,7 +103,7 @@ void HidService::AddDevice(scoped_refptr<HidDeviceInfo> device_info) {
                   << ", productId=" << device_info->product_id() << ", name='"
                   << device_info->product_name() << "', serial='"
                   << device_info->serial_number() << "', deviceId='"
-                  << device_info->device_id() << "'";
+                  << device_info->platform_device_id() << "'";
 
     if (enumeration_ready_) {
       for (auto& observer : observer_list_)
@@ -110,18 +112,21 @@ void HidService::AddDevice(scoped_refptr<HidDeviceInfo> device_info) {
   }
 }
 
-void HidService::RemoveDevice(const HidDeviceId& device_id) {
+void HidService::RemoveDevice(const HidPlatformDeviceId& platform_device_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  DeviceMap::iterator it = devices_.find(device_id);
-  if (it != devices_.end()) {
-    HID_LOG(USER) << "HID device removed: deviceId='" << device_id << "'";
 
-    scoped_refptr<HidDeviceInfo> device = it->second;
+  std::string device_guid = FindDeviceIdByPlatformDeviceId(platform_device_id);
+  if (!device_guid.empty()) {
+    HID_LOG(USER) << "HID device removed: deviceId='" << platform_device_id
+                  << "'";
+    DCHECK(base::ContainsKey(devices_, device_guid));
+
+    scoped_refptr<HidDeviceInfo> device = devices_[device_guid];
     if (enumeration_ready_) {
       for (auto& observer : observer_list_)
         observer.OnDeviceRemoved(device);
     }
-    devices_.erase(it);
+    devices_.erase(device_guid);
     if (enumeration_ready_) {
       for (auto& observer : observer_list_)
         observer.OnDeviceRemovedCleanup(device);
@@ -145,4 +150,14 @@ void HidService::FirstEnumerationComplete() {
   }
 }
 
+std::string HidService::FindDeviceIdByPlatformDeviceId(
+    const HidPlatformDeviceId& platform_device_id) {
+  for (const auto& map_entry : devices_) {
+    if (map_entry.second->platform_device_id() == platform_device_id) {
+      return map_entry.first;
+    }
+  }
+  return std::string();
+}
+
 }  // namespace device

device/hid/hid_service.h

@@ -63,25 +63,23 @@ class HidService {
   void AddObserver(Observer* observer);
   void RemoveObserver(Observer* observer);
 
-  // Fills in a DeviceInfo struct with info for the given device_id.
-  // Returns |nullptr| if |device_id| is invalid.
   scoped_refptr<HidDeviceInfo> GetDeviceInfo(
-      const HidDeviceId& device_id) const;
+      const std::string& device_guid) const;
 
   // Opens a connection to a device. The callback will be run with null on
   // failure.
-  virtual void Connect(const HidDeviceId& device_id,
+  virtual void Connect(const std::string& device_guid,
                        const ConnectCallback& callback) = 0;
 
  protected:
   friend class HidConnectionTest;
 
-  typedef std::map<HidDeviceId, scoped_refptr<HidDeviceInfo>> DeviceMap;
+  typedef std::map<std::string, scoped_refptr<HidDeviceInfo>> DeviceMap;
 
   HidService();
 
   void AddDevice(scoped_refptr<HidDeviceInfo> info);
-  void RemoveDevice(const HidDeviceId& device_id);
+  void RemoveDevice(const HidPlatformDeviceId& platform_device_id);
   void FirstEnumerationComplete();
 
   const DeviceMap& devices() const { return devices_; }
@@ -89,7 +87,11 @@ class HidService {
   base::ThreadChecker thread_checker_;
 
  private:
+  std::string FindDeviceIdByPlatformDeviceId(
+      const HidPlatformDeviceId& platform_device_id);
+
   DeviceMap devices_;
+
   bool enumeration_ready_ = false;
   std::vector<GetDevicesCallback> pending_enumerations_;
   base::ObserverList<Observer, true> observer_list_;

device/hid/hid_service_linux.cc

@@ -99,7 +99,7 @@ class HidServiceLinux::BlockingTaskHelper : public UdevWatcher::Observer {
     const char* device_path = udev_device_get_syspath(device.get());
     if (!device_path)
       return;
-    HidDeviceId device_id = device_path;
+    HidPlatformDeviceId platform_device_id = device_path;
 
     const char* subsystem = udev_device_get_subsystem(device.get());
     if (!subsystem || strcmp(subsystem, kHidrawSubsystem) != 0)
@@ -156,7 +156,7 @@ class HidServiceLinux::BlockingTaskHelper : public UdevWatcher::Observer {
       return;
 
     scoped_refptr<HidDeviceInfo> device_info(new HidDeviceInfoLinux(
-        device_id, device_node, vendor_id, product_id, product_name,
+        platform_device_id, device_node, vendor_id, product_id, product_name,
         serial_number,
         kHIDBusTypeUSB,  // TODO(reillyg): Detect Bluetooth. crbug.com/443335
         std::vector<uint8_t>(report_descriptor_str.begin(),
@@ -200,11 +200,11 @@ HidServiceLinux::~HidServiceLinux() {
   blocking_task_runner_->DeleteSoon(FROM_HERE, helper_.release());
 }
 
-void HidServiceLinux::Connect(const HidDeviceId& device_id,
+void HidServiceLinux::Connect(const std::string& device_guid,
                               const ConnectCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  const auto& map_entry = devices().find(device_id);
+  const auto& map_entry = devices().find(device_guid);
   if (map_entry == devices().end()) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, nullptr));

device/hid/hid_service_linux.h

@@ -23,7 +23,7 @@ class HidServiceLinux : public HidService {
   ~HidServiceLinux() override;
 
   // HidService:
-  void Connect(const HidDeviceId& device_id,
+  void Connect(const std::string& device_id,
                const ConnectCallback& callback) override;
 
  private:

device/hid/hid_service_mac.cc

@@ -127,11 +127,11 @@ HidServiceMac::HidServiceMac() : weak_factory_(this) {
 
 HidServiceMac::~HidServiceMac() {}
 
-void HidServiceMac::Connect(const HidDeviceId& device_id,
+void HidServiceMac::Connect(const std::string& device_guid,
                             const ConnectCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  const auto& map_entry = devices().find(device_id);
+  const auto& map_entry = devices().find(device_guid);
   if (map_entry == devices().end()) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, nullptr));
@@ -149,10 +149,10 @@ void HidServiceMac::Connect(const HidDeviceId& device_id,
 base::ScopedCFTypeRef<IOHIDDeviceRef> HidServiceMac::OpenOnBlockingThread(
     scoped_refptr<HidDeviceInfo> device_info) {
   base::ScopedCFTypeRef<CFDictionaryRef> matching_dict(
-      IORegistryEntryIDMatching(device_info->device_id()));
+      IORegistryEntryIDMatching(device_info->platform_device_id()));
   if (!matching_dict.get()) {
     HID_LOG(EVENT) << "Failed to create matching dictionary for ID: "
-                   << device_info->device_id();
+                   << device_info->platform_device_id();
     return base::ScopedCFTypeRef<IOHIDDeviceRef>();
   }
 
@@ -162,7 +162,7 @@ base::ScopedCFTypeRef<IOHIDDeviceRef> HidServiceMac::OpenOnBlockingThread(
       kIOMasterPortDefault, matching_dict.release()));
   if (!service.get()) {
     HID_LOG(EVENT) << "IOService not found for ID: "
-                   << device_info->device_id();
+                   << device_info->platform_device_id();
     return base::ScopedCFTypeRef<IOHIDDeviceRef>();
   }
 

device/hid/hid_service_mac.h

@@ -26,7 +26,7 @@ class HidServiceMac : public HidService {
   HidServiceMac();
   ~HidServiceMac() override;
 
-  void Connect(const HidDeviceId& device_id,
+  void Connect(const std::string& device_id,
                const ConnectCallback& connect) override;
 
  private:

device/hid/hid_service_win.cc

@@ -49,17 +49,17 @@ HidServiceWin::HidServiceWin()
 
 HidServiceWin::~HidServiceWin() {}
 
-void HidServiceWin::Connect(const HidDeviceId& device_id,
+void HidServiceWin::Connect(const std::string& device_guid,
                             const ConnectCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  const auto& map_entry = devices().find(device_id);
+  const auto& map_entry = devices().find(device_guid);
   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()));
+  base::win::ScopedHandle file(OpenDevice(device_info->platform_device_id()));
   if (!file.IsValid()) {
     HID_PLOG(EVENT) << "Failed to open device";
     task_runner_->PostTask(FROM_HERE, base::Bind(callback, nullptr));

device/hid/hid_service_win.h

@@ -34,7 +34,7 @@ class HidServiceWin : public HidService, public DeviceMonitorWin::Observer {
   HidServiceWin();
   ~HidServiceWin() override;
 
-  void Connect(const HidDeviceId& device_id,
+  void Connect(const std::string& device_id,
                const ConnectCallback& callback) override;
 
  private:

device/hid/mock_hid_service.cc

@@ -14,15 +14,16 @@ void MockHidService::AddDevice(scoped_refptr<HidDeviceInfo> info) {
   HidService::AddDevice(info);
 }
 
-void MockHidService::RemoveDevice(const HidDeviceId& device_id) {
-  HidService::RemoveDevice(device_id);
+void MockHidService::RemoveDevice(
+    const HidPlatformDeviceId& platform_device_id) {
+  HidService::RemoveDevice(platform_device_id);
 }
 
 void MockHidService::FirstEnumerationComplete() {
   HidService::FirstEnumerationComplete();
 }
 
-const std::map<HidDeviceId, scoped_refptr<HidDeviceInfo>>&
+const std::map<std::string, scoped_refptr<HidDeviceInfo>>&
 MockHidService::devices() const {
   return HidService::devices();
 }

device/hid/mock_hid_service.h

@@ -19,12 +19,12 @@ class MockHidService : public HidService {
 
   // Public wrappers around protected functions needed for tests.
   void AddDevice(scoped_refptr<HidDeviceInfo> info);
-  void RemoveDevice(const HidDeviceId& device_id);
+  void RemoveDevice(const HidPlatformDeviceId& platform_device_id);
   void FirstEnumerationComplete();
-  const std::map<HidDeviceId, scoped_refptr<HidDeviceInfo>>& devices() const;
+  const std::map<std::string, scoped_refptr<HidDeviceInfo>>& devices() const;
 
   MOCK_METHOD2(Connect,
-               void(const HidDeviceId& device_id,
+               void(const std::string& device_guid,
                     const ConnectCallback& callback));
 };
 

device/u2f/u2f_hid_device.cc

@@ -85,7 +85,7 @@ void U2fHidDevice::Transition(std::unique_ptr<U2fApduCommand> command,
 void U2fHidDevice::Connect(const HidService::ConnectCallback& callback) {
   HidService* hid_service = DeviceClient::Get()->GetHidService();
 
-  hid_service->Connect(device_info_->device_id(), callback);
+  hid_service->Connect(device_info_->device_guid(), callback);
 }
 
 void U2fHidDevice::OnConnect(std::unique_ptr<U2fApduCommand> command,
@@ -332,7 +332,7 @@ void U2fHidDevice::OnTimeout(const DeviceCallback& callback) {
 
 std::string U2fHidDevice::GetId() {
   std::ostringstream id("hid:", std::ios::ate);
-  id << device_info_->device_id();
+  id << device_info_->device_guid();
   return id.str();
 }
 

extensions/browser/api/hid/hid_api.cc

@@ -181,7 +181,7 @@ ExtensionFunction::ResponseAction HidConnectFunction::Run() {
   CHECK(hid_service);
 
   hid_service->Connect(
-      device_info->device_id(),
+      device_info->device_guid(),
       base::Bind(&HidConnectFunction::OnConnectComplete, this));
   return RespondLater();
 }

extensions/browser/api/hid/hid_apitest.cc

@@ -8,6 +8,7 @@
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
+#include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "device/base/mock_device_client.h"
@@ -24,8 +25,8 @@
 
 using base::ThreadTaskRunnerHandle;
 using device::HidCollectionInfo;
-using device::HidDeviceId;
 using device::HidDeviceInfo;
+using device::HidPlatformDeviceId;
 using device::HidUsageAndPage;
 using device::MockDeviceClient;
 using net::IOBuffer;
@@ -144,13 +145,21 @@ class TestDevicePermissionsPrompt
 
  private:
   void OnDevicesChanged() {
+    if (prompt()->multiple()) {
       for (size_t i = 0; i < prompt()->GetDeviceCount(); ++i) {
         prompt()->GrantDevicePermission(i);
-      if (!prompt()->multiple()) {
-        break;
-      }
       }
       prompt()->Dismissed();
+    } else {
+      for (size_t i = 0; i < prompt()->GetDeviceCount(); ++i) {
+        // Always choose the device whose serial number is "A".
+        if (prompt()->GetDeviceSerialNumber(i) == base::UTF8ToUTF16("A")) {
+          prompt()->GrantDevicePermission(i);
+          prompt()->Dismissed();
+          return;
+        }
+      }
+    }
   }
 };
 
@@ -179,10 +188,10 @@ class HidApiTest : public ShellApiTest {
         base::Bind(&HidApiTest::LazyFirstEnumeration, base::Unretained(this)));
   }
 
-  void Connect(const HidDeviceId& device_id,
+  void Connect(const std::string& device_guid,
                const device::HidService::ConnectCallback& callback) {
     const auto& devices = device_client_->hid_service()->devices();
-    const auto& device_entry = devices.find(device_id);
+    const auto& device_entry = devices.find(device_guid);
     scoped_refptr<MockHidConnection> connection;
     if (device_entry != devices.end()) {
       connection = new MockHidConnection(device_entry->second);
@@ -193,16 +202,17 @@ class HidApiTest : public ShellApiTest {
   }
 
   void LazyFirstEnumeration() {
-    AddDevice(kTestDeviceIds[0], 0x18D1, 0x58F0, false);
-    AddDevice(kTestDeviceIds[1], 0x18D1, 0x58F0, true);
-    AddDevice(kTestDeviceIds[2], 0x18D1, 0x58F1, false);
+    AddDevice(kTestDeviceIds[0], 0x18D1, 0x58F0, false, "A");
+    AddDevice(kTestDeviceIds[1], 0x18D1, 0x58F0, true, "B");
+    AddDevice(kTestDeviceIds[2], 0x18D1, 0x58F1, false, "C");
     device_client_->hid_service()->FirstEnumerationComplete();
   }
 
-  void AddDevice(const HidDeviceId& device_id,
+  void AddDevice(const HidPlatformDeviceId& platform_device_id,
                  int vendor_id,
                  int product_id,
-                 bool report_id) {
+                 bool report_id,
+                 std::string serial_number) {
     std::vector<uint8_t> report_descriptor;
     if (report_id) {
       report_descriptor.insert(
@@ -212,8 +222,8 @@ class HidApiTest : public ShellApiTest {
       report_descriptor.insert(report_descriptor.begin(), kReportDescriptor,
                                kReportDescriptor + sizeof(kReportDescriptor));
     }
-    device_client_->hid_service()->AddDevice(
-        new HidDeviceInfo(device_id, vendor_id, product_id, "Test Device", "A",
+    device_client_->hid_service()->AddDevice(new HidDeviceInfo(
+        platform_device_id, vendor_id, product_id, "Test Device", serial_number,
         device::kHIDBusTypeUSB, report_descriptor));
   }
 
@@ -235,8 +245,8 @@ IN_PROC_BROWSER_TEST_F(HidApiTest, OnDeviceAdded) {
 
   // Add a blocked device first so that the test will fail if a notification is
   // received.
-  AddDevice(kTestDeviceIds[3], 0x18D1, 0x58F1, false);
-  AddDevice(kTestDeviceIds[4], 0x18D1, 0x58F0, false);
+  AddDevice(kTestDeviceIds[3], 0x18D1, 0x58F1, false, "A");
+  AddDevice(kTestDeviceIds[4], 0x18D1, 0x58F0, false, "A");
   ASSERT_TRUE(result_listener.WaitUntilSatisfied());
   EXPECT_EQ("success", result_listener.message());
 }
@@ -270,7 +280,7 @@ IN_PROC_BROWSER_TEST_F(HidApiTest, GetUserSelectedDevices) {
   ASSERT_TRUE(remove_listener.WaitUntilSatisfied());
 
   ExtensionTestMessageListener add_listener("added", false);
-  AddDevice(kTestDeviceIds[0], 0x18D1, 0x58F0, true);
+  AddDevice(kTestDeviceIds[0], 0x18D1, 0x58F0, true, "A");
   ASSERT_TRUE(add_listener.WaitUntilSatisfied());
 }
 

extensions/browser/api/hid/hid_device_manager.cc

@@ -25,7 +25,6 @@
 namespace hid = extensions::api::hid;
 
 using device::HidDeviceFilter;
-using device::HidDeviceId;
 using device::HidDeviceInfo;
 using device::HidService;
 
@@ -140,7 +139,7 @@ std::unique_ptr<base::ListValue> HidDeviceManager::GetApiDevicesFromList(
   DCHECK(thread_checker_.CalledOnValidThread());
   std::unique_ptr<base::ListValue> device_list(new base::ListValue());
   for (const auto& device : devices) {
-    const auto device_entry = resource_ids_.find(device->device_id());
+    const auto device_entry = resource_ids_.find(device->device_guid());
     DCHECK(device_entry != resource_ids_.end());
 
     hid::HidDeviceInfo device_info;
@@ -217,9 +216,9 @@ void HidDeviceManager::OnDeviceAdded(scoped_refptr<HidDeviceInfo> device_info) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_LT(next_resource_id_, std::numeric_limits<int>::max());
   int new_id = next_resource_id_++;
-  DCHECK(!base::ContainsKey(resource_ids_, device_info->device_id()));
-  resource_ids_[device_info->device_id()] = new_id;
-  device_ids_[new_id] = device_info->device_id();
+  DCHECK(!base::ContainsKey(resource_ids_, device_info->device_guid()));
+  resource_ids_[device_info->device_guid()] = new_id;
+  device_ids_[new_id] = device_info->device_guid();
 
   // Don't generate events during the initial enumeration.
   if (enumeration_ready_ && event_router_) {
@@ -239,7 +238,7 @@ void HidDeviceManager::OnDeviceAdded(scoped_refptr<HidDeviceInfo> device_info) {
 void HidDeviceManager::OnDeviceRemoved(
     scoped_refptr<HidDeviceInfo> device_info) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  const auto& resource_entry = resource_ids_.find(device_info->device_id());
+  const auto& resource_entry = resource_ids_.find(device_info->device_guid());
   DCHECK(resource_entry != resource_ids_.end());
   int resource_id = resource_entry->second;
   const auto& device_entry = device_ids_.find(resource_id);
@@ -282,10 +281,10 @@ std::unique_ptr<base::ListValue> HidDeviceManager::CreateApiDeviceList(
   std::unique_ptr<base::ListValue> api_devices(new base::ListValue());
   for (const ResourceIdToDeviceIdMap::value_type& map_entry : device_ids_) {
     int resource_id = map_entry.first;
-    const HidDeviceId& device_id = map_entry.second;
+    const std::string& device_guid = map_entry.second;
 
     scoped_refptr<HidDeviceInfo> device_info =
-        hid_service->GetDeviceInfo(device_id);
+        hid_service->GetDeviceInfo(device_guid);
     if (!device_info) {
       continue;
     }

extensions/browser/api/hid/hid_device_manager.h

@@ -72,8 +72,8 @@ class HidDeviceManager : public BrowserContextKeyedAPI,
  private:
   friend class BrowserContextKeyedAPIFactory<HidDeviceManager>;
 
-  typedef std::map<int, device::HidDeviceId> ResourceIdToDeviceIdMap;
-  typedef std::map<device::HidDeviceId, int> DeviceIdToResourceIdMap;
+  typedef std::map<int, std::string> ResourceIdToDeviceIdMap;
+  typedef std::map<std::string, int> DeviceIdToResourceIdMap;
 
   struct GetApiDevicesParams;
 

extensions/test/data/api_test/hid/get_user_selected_devices/background.js

@@ -12,6 +12,7 @@ chrome.test.runWithUserGesture(function() {
       chrome.test.assertNoLastError();
       chrome.test.assertEq(1, devices.length);
       device_from_user = devices[0];
+      chrome.test.assertEq(device_from_user.serialNumber, "A");
       chrome.hid.connect(device_from_user.deviceId, function(connection) {
         chrome.test.assertNoLastError();
         chrome.hid.disconnect(connection.connectionId);