Add chrome.hid.getUserSelectedDevices API.

extensions/browser/api/hid/hid_apitest.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 "base/bind.h"
 #include "base/run_loop.h"
 #include "base/thread_task_runner_handle.h"
 #include "device/hid/hid_collection_info.h"
 #include "device/hid/hid_connection.h"
 #include "device/hid/hid_device_info.h"
 #include "device/hid/hid_service.h"
 #include "device/hid/hid_usage_and_page.h"
+#include "extensions/browser/api/device_permissions_prompt.h"
+#include "extensions/shell/browser/shell_extensions_api_client.h"
 #include "extensions/shell/test/shell_apitest.h"
 #include "extensions/test/extension_test_message_listener.h"
 #include "net/base/io_buffer.h"
 
 using base::ThreadTaskRunnerHandle;
 using device::HidCollectionInfo;
 using device::HidConnection;
 using device::HidDeviceId;
 using device::HidDeviceInfo;
 using device::HidService;
@@ skipping 127 matching lines @@
     std::vector<uint8> report_descriptor;
     if (report_id) {
       report_descriptor.insert(
           report_descriptor.begin(), kReportDescriptorWithIDs,
           kReportDescriptorWithIDs + sizeof(kReportDescriptorWithIDs));
     } else {
       report_descriptor.insert(report_descriptor.begin(), kReportDescriptor,
                                kReportDescriptor + sizeof(kReportDescriptor));
     }
     HidService::AddDevice(new HidDeviceInfo(device_id, vendor_id, product_id,
-                                            "", "", kHIDBusTypeUSB,
+                                            "Test Device", "A", kHIDBusTypeUSB,
                                             report_descriptor));
   }
 
   void RemoveDevice(const HidDeviceId& device_id) {
     HidService::RemoveDevice(device_id);
   }
 };
 
 }  // namespace device
 
 namespace extensions {
 
+class TestDevicePermissionsPrompt
+    : public DevicePermissionsPrompt,
+      public DevicePermissionsPrompt::Prompt::Observer {
+ public:
+  TestDevicePermissionsPrompt(content::WebContents* web_contents)
+      : DevicePermissionsPrompt(web_contents) {}
+
+  ~TestDevicePermissionsPrompt() override { prompt()->SetObserver(nullptr); }
+
+  void ShowDialog() override { prompt()->SetObserver(this); }
+
+  void OnDevicesChanged() override {
+    for (size_t i = 0; i < prompt()->GetDeviceCount(); ++i) {
+      prompt()->GrantDevicePermission(i);
+      if (!prompt()->multiple()) {
+        break;
+      }
+    }
+    prompt()->Dismissed();
+  }
+};
+
+class TestExtensionsAPIClient : public ShellExtensionsAPIClient {
+ public:
+  TestExtensionsAPIClient() : ShellExtensionsAPIClient() {}
+
+  scoped_ptr<DevicePermissionsPrompt> CreateDevicePermissionsPrompt(
+      content::WebContents* web_contents) const override {
+    return make_scoped_ptr(new TestDevicePermissionsPrompt(web_contents));
+  }
+};
+
 class HidApiTest : public ShellApiTest {
  public:
   void SetUpOnMainThread() override {
     ShellApiTest::SetUpOnMainThread();
     hid_service_ = new device::MockHidService();
     HidService::SetInstanceForTest(hid_service_);
   }
 
  protected:
   device::MockHidService* hid_service_;
@@ skipping 29 matching lines @@
 
   // Device C was not returned by chrome.hid.getDevices, the app will not get
   // a notification.
   hid_service_->RemoveDevice(kTestDeviceIds[2]);
   // Device A was returned, the app will get a notification.
   hid_service_->RemoveDevice(kTestDeviceIds[0]);
   ASSERT_TRUE(result_listener.WaitUntilSatisfied());
   EXPECT_EQ("success", result_listener.message());
 }
 
+IN_PROC_BROWSER_TEST_F(HidApiTest, GetUserSelectedDevices) {
+  ExtensionTestMessageListener open_listener("opened_device", false);
+
+  TestExtensionsAPIClient test_api_client;
+  ASSERT_TRUE(LoadApp("api_test/hid/get_user_selected_devices"));
+  ASSERT_TRUE(open_listener.WaitUntilSatisfied());
+
+  ExtensionTestMessageListener remove_listener("removed", false);
+  hid_service_->RemoveDevice(kTestDeviceIds[0]);
+  ASSERT_TRUE(remove_listener.WaitUntilSatisfied());
+
+  ExtensionTestMessageListener add_listener("added", false);
+  hid_service_->AddDevice(kTestDeviceIds[0], 0x18D1, 0x58F0, true);
+  ASSERT_TRUE(add_listener.WaitUntilSatisfied());
+}
+
 }  // namespace extensions