extensions/browser/api/hid/hid_apitest.cc - chromium/src - Git at Google

 // Copyright 2014 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include <stddef.h>
 #include <stdint.h>

 #include <iterator>
 #include <memory>

 #include "base/functional/bind.h"
 #include "base/functional/callback_helpers.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/chromeos_buildflags.h"
 #include "extensions/browser/api/device_permissions_prompt.h"
 #include "extensions/browser/api/hid/hid_device_manager.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 "services/device/public/cpp/hid/hid_report_descriptor.h"
 #include "services/device/public/cpp/test/fake_hid_manager.h"
 #include "services/device/public/mojom/hid.mojom.h"

 #if BUILDFLAG(IS_CHROMEOS)
 #include "chromeos/dbus/permission_broker/fake_permission_broker_client.h"  // nogncheck
 #endif  // BUILDFLAG(IS_CHROMEOS)

 namespace extensions {

 namespace {

 using ::device::FakeHidManager;
 using ::device::HidReportDescriptor;

 const char* const kTestDeviceGuids[] = {"A", "B", "C", "D", "E"};
 const char* const kTestPhysicalDeviceIds[] = {"1", "2", "3", "4", "5"};

 // These report descriptors define two devices with 8-byte input, output and
 // feature reports. The first implements usage page 0xFF00 and has a single
 // report without and ID. The second implements usage page 0xFF01 and has a
 // single report with ID 1.
 const uint8_t kReportDescriptor[] = {
     0x06, 0x00, 0xFF,  // Usage Page (Vendor Defined 0xFF00)
     0x08,              // Usage
     0xA1, 0x01,        // Collection (Application)
     0x15, 0x00,        //   Logical Minimum (0)
     0x26, 0xFF, 0x00,  //   Logical Maximum (255)
     0x75, 0x08,        //   Report Size (8)
     0x95, 0x08,        //   Report Count (8)
     0x08,              //   Usage
     0x81, 0x02,        //   Input (Data,Var,Abs,No Wrap,Linear,Preferred State,
                        //   No Null Position)
     0x08,              //   Usage
     0x91, 0x02,        //   Output (Data,Var,Abs,No Wrap,Linear,Preferred State,
                        //   No Null Position,Non-volatile)
     0x08,              //   Usage
     0xB1, 0x02,        //   Feature (Data,Var,Abs,No Wrap,Linear,Preferred
                        //   State,No Null Position,Non-volatile)
     0xC0,              // End Collection
 };
 const uint8_t kReportDescriptorWithIDs[] = {
     0x06, 0x01, 0xFF,  // Usage Page (Vendor Defined 0xFF01)
     0x08,              // Usage
     0xA1, 0x01,        // Collection (Application)
     0x15, 0x00,        //   Logical Minimum (0)
     0x26, 0xFF, 0x00,  //   Logical Maximum (255)
     0x85, 0x01,        //   Report ID (1)
     0x75, 0x08,        //   Report Size (8)
     0x95, 0x08,        //   Report Count (8)
     0x08,              //   Usage
     0x81, 0x02,        //   Input (Data,Var,Abs,No Wrap,Linear,Preferred State,
                        //   No Null Position)
     0x08,              //   Usage
     0x91, 0x02,        //   Output (Data,Var,Abs,No Wrap,Linear,Preferred State,
                        //   No Null Position,Non-volatile)
     0x08,              //   Usage
     0xB1, 0x02,        //   Feature (Data,Var,Abs,No Wrap,Linear,Preferred
                        //   State,No Null Position,Non-volatile)
     0xC0,              // End Collection
 };

 // Device IDs for the device granted permission by the manifest.
 constexpr uint16_t kTestVendorId = 0x18D1;
 constexpr uint16_t kTestProductId = 0x58F0;

 }  // namespace

 class TestDevicePermissionsPrompt
     : public DevicePermissionsPrompt,
       public DevicePermissionsPrompt::Prompt::Observer {
  public:
   explicit TestDevicePermissionsPrompt(content::WebContents* web_contents)
       : DevicePermissionsPrompt(web_contents) {}

   ~TestDevicePermissionsPrompt() override { prompt()->SetObserver(nullptr); }

   void ShowDialog() override { prompt()->SetObserver(this); }

   void OnDevicesInitialized() override {
     if (prompt()->multiple()) {
       for (size_t i = 0; i < prompt()->GetDeviceCount(); ++i) {
         prompt()->GrantDevicePermission(i);
       }
       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) == u"A") {
           prompt()->GrantDevicePermission(i);
           prompt()->Dismissed();
           return;
         }
       }
     }
   }

   void OnDeviceAdded(size_t index, const std::u16string& device_name) override {
   }

   void OnDeviceRemoved(size_t index,
                        const std::u16string& device_name) override {}
 };

 class TestExtensionsAPIClient : public ShellExtensionsAPIClient {
  public:
   TestExtensionsAPIClient() : ShellExtensionsAPIClient() {}

   std::unique_ptr<DevicePermissionsPrompt> CreateDevicePermissionsPrompt(
       content::WebContents* web_contents) const override {
     return std::make_unique<TestDevicePermissionsPrompt>(web_contents);
   }
 };

 class HidApiTest : public ShellApiTest {
  public:
   HidApiTest() {
 #if BUILDFLAG(IS_CHROMEOS)
     // Required for DevicePermissionsPrompt:
     chromeos::PermissionBrokerClient::InitializeFake();
 #endif
     // Because Device Service also runs in this process (browser process), we
     // can set our binder to intercept requests for HidManager interface to it.
     fake_hid_manager_ = std::make_unique<FakeHidManager>();
     auto binder = base::BindRepeating(
         &FakeHidManager::Bind, base::Unretained(fake_hid_manager_.get()));
     HidDeviceManager::OverrideHidManagerBinderForTesting(binder);
     DevicePermissionsPrompt::OverrideHidManagerBinderForTesting(binder);
   }

   ~HidApiTest() override {
     HidDeviceManager::OverrideHidManagerBinderForTesting(base::NullCallback());
 #if BUILDFLAG(IS_CHROMEOS)
     chromeos::PermissionBrokerClient::Shutdown();
 #endif
   }

   void SetUpOnMainThread() override {
     ShellApiTest::SetUpOnMainThread();

     AddDevice(kTestDeviceGuids[0], kTestPhysicalDeviceIds[0], kTestVendorId,
               kTestProductId, false, "A");
     AddDevice(kTestDeviceGuids[1], kTestPhysicalDeviceIds[1], kTestVendorId,
               kTestProductId, true, "B");
     AddDevice(kTestDeviceGuids[2], kTestPhysicalDeviceIds[2], kTestVendorId,
               kTestProductId + 1, false, "C");
   }

   void AddDevice(const std::string& device_guid,
                  const std::string& physical_device_id,
                  int vendor_id,
                  int product_id,
                  bool report_id,
                  std::string serial_number) {
     std::vector<uint8_t> report_descriptor;
     if (report_id) {
       report_descriptor.insert(report_descriptor.begin(),
                                std::begin(kReportDescriptorWithIDs),
                                std::end(kReportDescriptorWithIDs));
     } else {
       report_descriptor.insert(report_descriptor.begin(),
                                std::begin(kReportDescriptor),
                                std::end(kReportDescriptor));
     }

     std::vector<device::mojom::HidCollectionInfoPtr> collections;
     bool has_report_id;
     size_t max_input_report_size;
     size_t max_output_report_size;
     size_t max_feature_report_size;

     HidReportDescriptor descriptor_parser(report_descriptor);
     descriptor_parser.GetDetails(
         &collections, &has_report_id, &max_input_report_size,
         &max_output_report_size, &max_feature_report_size);

     auto device = device::mojom::HidDeviceInfo::New(
         device_guid, physical_device_id, vendor_id, product_id, "Test Device",
         serial_number, device::mojom::HidBusType::kHIDBusTypeUSB,
         report_descriptor, std::move(collections), has_report_id,
         max_input_report_size, max_output_report_size, max_feature_report_size,
         /*device_path=*/"",
         /*protected_input_report_ids=*/std::vector<uint8_t>{},
         /*protected_output_report_ids=*/std::vector<uint8_t>{},
         /*protected_feature_report_ids=*/std::vector<uint8_t>{});

     fake_hid_manager_->AddDevice(std::move(device));
   }

   FakeHidManager* GetFakeHidManager() { return fake_hid_manager_.get(); }

  protected:
   std::unique_ptr<FakeHidManager> fake_hid_manager_;
 };

 IN_PROC_BROWSER_TEST_F(HidApiTest, HidApp) {
   ASSERT_TRUE(RunAppTest("api_test/hid/api")) << message_;
 }

 IN_PROC_BROWSER_TEST_F(HidApiTest, OnDeviceAdded) {
   ExtensionTestMessageListener load_listener("loaded");
   ExtensionTestMessageListener result_listener("success");
   result_listener.set_failure_message("failure");

   ASSERT_TRUE(LoadApp("api_test/hid/add_event"));
   ASSERT_TRUE(load_listener.WaitUntilSatisfied());

   // Add a blocked device first so that the test will fail if a notification is
   // received.
   AddDevice(kTestDeviceGuids[3], kTestPhysicalDeviceIds[3], kTestVendorId,
             kTestProductId + 1, false, "A");
   AddDevice(kTestDeviceGuids[4], kTestPhysicalDeviceIds[4], kTestVendorId,
             kTestProductId, false, "A");
   ASSERT_TRUE(result_listener.WaitUntilSatisfied());
   EXPECT_EQ("success", result_listener.message());
 }

 IN_PROC_BROWSER_TEST_F(HidApiTest, OnDeviceRemoved) {
   ExtensionTestMessageListener load_listener("loaded");
   ExtensionTestMessageListener result_listener("success");
   result_listener.set_failure_message("failure");

   ASSERT_TRUE(LoadApp("api_test/hid/remove_event"));
   ASSERT_TRUE(load_listener.WaitUntilSatisfied());

   // Device C was not returned by chrome.hid.getDevices, the app will not get
   // a notification.
   GetFakeHidManager()->RemoveDevice(kTestDeviceGuids[2]);
   // Device A was returned, the app will get a notification.
   GetFakeHidManager()->RemoveDevice(kTestDeviceGuids[0]);
   ASSERT_TRUE(result_listener.WaitUntilSatisfied());
   EXPECT_EQ("success", result_listener.message());
 }

 namespace {

 device::mojom::HidDeviceInfoPtr CreateDeviceWithOneCollection(
     const std::string& guid) {
   auto device_info = device::mojom::HidDeviceInfo::New();
   device_info->guid = guid;
   device_info->vendor_id = kTestVendorId;
   device_info->product_id = kTestProductId;
   auto collection = device::mojom::HidCollectionInfo::New();
   collection->usage =
       device::mojom::HidUsageAndPage::New(1, device::mojom::kPageVendor);
   auto report = device::mojom::HidReportDescription::New();
   collection->input_reports.push_back(std::move(report));
   device_info->collections.push_back(std::move(collection));
   return device_info;
 }

 device::mojom::HidDeviceInfoPtr CreateDeviceWithTwoCollections(
     const std::string guid) {
   auto device_info = CreateDeviceWithOneCollection(guid);
   auto collection = device::mojom::HidCollectionInfo::New();
   collection->usage =
       device::mojom::HidUsageAndPage::New(2, device::mojom::kPageVendor);
   collection->output_reports.push_back(
       device::mojom::HidReportDescription::New());
   device_info->collections.push_back(std::move(collection));
   return device_info;
 }

 }  // namespace

 IN_PROC_BROWSER_TEST_F(HidApiTest, DeviceAddedChangedRemoved) {
   constexpr char kTestGuid[] = "guid";

   ExtensionTestMessageListener load_listener("loaded");
   ExtensionTestMessageListener add_listener("added", ReplyBehavior::kWillReply);
   ExtensionTestMessageListener change_listener("changed");
   ExtensionTestMessageListener result_listener("success");
   result_listener.set_failure_message("failure");

   ASSERT_TRUE(LoadApp("api_test/hid/add_change_remove"));
   ASSERT_TRUE(load_listener.WaitUntilSatisfied());

   // Add a device with one collection.
   GetFakeHidManager()->AddDevice(CreateDeviceWithOneCollection(kTestGuid));
   ASSERT_TRUE(add_listener.WaitUntilSatisfied());

   // Update the device info to add a second collection. No event is generated,
   // so we will reply to the |add_listener| to signal to the test that the
   // change is complete.
   GetFakeHidManager()->ChangeDevice(CreateDeviceWithTwoCollections(kTestGuid));
   add_listener.Reply("device info updated");
   ASSERT_TRUE(change_listener.WaitUntilSatisfied());

   // Remove the device.
   GetFakeHidManager()->RemoveDevice(kTestGuid);
   ASSERT_TRUE(result_listener.WaitUntilSatisfied());
   EXPECT_EQ("success", result_listener.message());
 }

 }  // namespace extensions
	// Copyright 2014 The Chromium Authors
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include <stddef.h>
	#include <stdint.h>

	#include <iterator>
	#include <memory>

	#include "base/functional/bind.h"
	#include "base/functional/callback_helpers.h"
	#include "base/run_loop.h"
	#include "base/strings/utf_string_conversions.h"
	#include "build/chromeos_buildflags.h"
	#include "extensions/browser/api/device_permissions_prompt.h"
	#include "extensions/browser/api/hid/hid_device_manager.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 "services/device/public/cpp/hid/hid_report_descriptor.h"
	#include "services/device/public/cpp/test/fake_hid_manager.h"
	#include "services/device/public/mojom/hid.mojom.h"

	#if BUILDFLAG(IS_CHROMEOS)
	#include "chromeos/dbus/permission_broker/fake_permission_broker_client.h" // nogncheck
	#endif // BUILDFLAG(IS_CHROMEOS)

	namespace extensions {

	namespace {

	using ::device::FakeHidManager;
	using ::device::HidReportDescriptor;

	const char* const kTestDeviceGuids[] = {"A", "B", "C", "D", "E"};
	const char* const kTestPhysicalDeviceIds[] = {"1", "2", "3", "4", "5"};

	// These report descriptors define two devices with 8-byte input, output and
	// feature reports. The first implements usage page 0xFF00 and has a single
	// report without and ID. The second implements usage page 0xFF01 and has a
	// single report with ID 1.
	const uint8_t kReportDescriptor[] = {
	0x06, 0x00, 0xFF, // Usage Page (Vendor Defined 0xFF00)
	0x08, // Usage
	0xA1, 0x01, // Collection (Application)
	0x15, 0x00, // Logical Minimum (0)
	0x26, 0xFF, 0x00, // Logical Maximum (255)
	0x75, 0x08, // Report Size (8)
	0x95, 0x08, // Report Count (8)
	0x08, // Usage
	0x81, 0x02, // Input (Data,Var,Abs,No Wrap,Linear,Preferred State,
	// No Null Position)
	0x08, // Usage
	0x91, 0x02, // Output (Data,Var,Abs,No Wrap,Linear,Preferred State,
	// No Null Position,Non-volatile)
	0x08, // Usage
	0xB1, 0x02, // Feature (Data,Var,Abs,No Wrap,Linear,Preferred
	// State,No Null Position,Non-volatile)
	0xC0, // End Collection
	};
	const uint8_t kReportDescriptorWithIDs[] = {
	0x06, 0x01, 0xFF, // Usage Page (Vendor Defined 0xFF01)
	0x08, // Usage
	0xA1, 0x01, // Collection (Application)
	0x15, 0x00, // Logical Minimum (0)
	0x26, 0xFF, 0x00, // Logical Maximum (255)
	0x85, 0x01, // Report ID (1)
	0x75, 0x08, // Report Size (8)
	0x95, 0x08, // Report Count (8)
	0x08, // Usage
	0x81, 0x02, // Input (Data,Var,Abs,No Wrap,Linear,Preferred State,
	// No Null Position)
	0x08, // Usage
	0x91, 0x02, // Output (Data,Var,Abs,No Wrap,Linear,Preferred State,
	// No Null Position,Non-volatile)
	0x08, // Usage
	0xB1, 0x02, // Feature (Data,Var,Abs,No Wrap,Linear,Preferred
	// State,No Null Position,Non-volatile)
	0xC0, // End Collection
	};

	// Device IDs for the device granted permission by the manifest.
	constexpr uint16_t kTestVendorId = 0x18D1;
	constexpr uint16_t kTestProductId = 0x58F0;

	} // namespace

	class TestDevicePermissionsPrompt
	: public DevicePermissionsPrompt,
	public DevicePermissionsPrompt::Prompt::Observer {
	public:
	explicit TestDevicePermissionsPrompt(content::WebContents* web_contents)
	: DevicePermissionsPrompt(web_contents) {}

	~TestDevicePermissionsPrompt() override { prompt()->SetObserver(nullptr); }

	void ShowDialog() override { prompt()->SetObserver(this); }

	void OnDevicesInitialized() override {
	if (prompt()->multiple()) {
	for (size_t i = 0; i < prompt()->GetDeviceCount(); ++i) {
	prompt()->GrantDevicePermission(i);
	}
	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) == u"A") {
	prompt()->GrantDevicePermission(i);
	prompt()->Dismissed();
	return;
	}
	}
	}
	}

	void OnDeviceAdded(size_t index, const std::u16string& device_name) override {
	}

	void OnDeviceRemoved(size_t index,
	const std::u16string& device_name) override {}
	};

	class TestExtensionsAPIClient : public ShellExtensionsAPIClient {
	public:
	TestExtensionsAPIClient() : ShellExtensionsAPIClient() {}

	std::unique_ptr<DevicePermissionsPrompt> CreateDevicePermissionsPrompt(
	content::WebContents* web_contents) const override {
	return std::make_unique<TestDevicePermissionsPrompt>(web_contents);
	}
	};

	class HidApiTest : public ShellApiTest {
	public:
	HidApiTest() {
	#if BUILDFLAG(IS_CHROMEOS)
	// Required for DevicePermissionsPrompt:
	chromeos::PermissionBrokerClient::InitializeFake();
	#endif
	// Because Device Service also runs in this process (browser process), we
	// can set our binder to intercept requests for HidManager interface to it.
	fake_hid_manager_ = std::make_unique<FakeHidManager>();
	auto binder = base::BindRepeating(
	&FakeHidManager::Bind, base::Unretained(fake_hid_manager_.get()));
	HidDeviceManager::OverrideHidManagerBinderForTesting(binder);
	DevicePermissionsPrompt::OverrideHidManagerBinderForTesting(binder);
	}

	~HidApiTest() override {
	HidDeviceManager::OverrideHidManagerBinderForTesting(base::NullCallback());
	#if BUILDFLAG(IS_CHROMEOS)
	chromeos::PermissionBrokerClient::Shutdown();
	#endif
	}

	void SetUpOnMainThread() override {
	ShellApiTest::SetUpOnMainThread();

	AddDevice(kTestDeviceGuids[0], kTestPhysicalDeviceIds[0], kTestVendorId,
	kTestProductId, false, "A");
	AddDevice(kTestDeviceGuids[1], kTestPhysicalDeviceIds[1], kTestVendorId,
	kTestProductId, true, "B");
	AddDevice(kTestDeviceGuids[2], kTestPhysicalDeviceIds[2], kTestVendorId,
	kTestProductId + 1, false, "C");
	}

	void AddDevice(const std::string& device_guid,
	const std::string& physical_device_id,
	int vendor_id,
	int product_id,
	bool report_id,
	std::string serial_number) {
	std::vector<uint8_t> report_descriptor;
	if (report_id) {
	report_descriptor.insert(report_descriptor.begin(),
	std::begin(kReportDescriptorWithIDs),
	std::end(kReportDescriptorWithIDs));
	} else {
	report_descriptor.insert(report_descriptor.begin(),
	std::begin(kReportDescriptor),
	std::end(kReportDescriptor));
	}

	std::vector<device::mojom::HidCollectionInfoPtr> collections;
	bool has_report_id;
	size_t max_input_report_size;
	size_t max_output_report_size;
	size_t max_feature_report_size;

	HidReportDescriptor descriptor_parser(report_descriptor);
	descriptor_parser.GetDetails(
	&collections, &has_report_id, &max_input_report_size,
	&max_output_report_size, &max_feature_report_size);

	auto device = device::mojom::HidDeviceInfo::New(
	device_guid, physical_device_id, vendor_id, product_id, "Test Device",
	serial_number, device::mojom::HidBusType::kHIDBusTypeUSB,
	report_descriptor, std::move(collections), has_report_id,
	max_input_report_size, max_output_report_size, max_feature_report_size,
	/device_path=/"",
	/protected_input_report_ids=/std::vector<uint8_t>{},
	/protected_output_report_ids=/std::vector<uint8_t>{},
	/protected_feature_report_ids=/std::vector<uint8_t>{});

	fake_hid_manager_->AddDevice(std::move(device));
	}

	FakeHidManager* GetFakeHidManager() { return fake_hid_manager_.get(); }

	protected:
	std::unique_ptr<FakeHidManager> fake_hid_manager_;
	};

	IN_PROC_BROWSER_TEST_F(HidApiTest, HidApp) {
	ASSERT_TRUE(RunAppTest("api_test/hid/api")) << message_;
	}

	IN_PROC_BROWSER_TEST_F(HidApiTest, OnDeviceAdded) {
	ExtensionTestMessageListener load_listener("loaded");
	ExtensionTestMessageListener result_listener("success");
	result_listener.set_failure_message("failure");

	ASSERT_TRUE(LoadApp("api_test/hid/add_event"));
	ASSERT_TRUE(load_listener.WaitUntilSatisfied());

	// Add a blocked device first so that the test will fail if a notification is
	// received.
	AddDevice(kTestDeviceGuids[3], kTestPhysicalDeviceIds[3], kTestVendorId,
	kTestProductId + 1, false, "A");
	AddDevice(kTestDeviceGuids[4], kTestPhysicalDeviceIds[4], kTestVendorId,
	kTestProductId, false, "A");
	ASSERT_TRUE(result_listener.WaitUntilSatisfied());
	EXPECT_EQ("success", result_listener.message());
	}

	IN_PROC_BROWSER_TEST_F(HidApiTest, OnDeviceRemoved) {
	ExtensionTestMessageListener load_listener("loaded");
	ExtensionTestMessageListener result_listener("success");
	result_listener.set_failure_message("failure");

	ASSERT_TRUE(LoadApp("api_test/hid/remove_event"));
	ASSERT_TRUE(load_listener.WaitUntilSatisfied());

	// Device C was not returned by chrome.hid.getDevices, the app will not get
	// a notification.
	GetFakeHidManager()->RemoveDevice(kTestDeviceGuids[2]);
	// Device A was returned, the app will get a notification.
	GetFakeHidManager()->RemoveDevice(kTestDeviceGuids[0]);
	ASSERT_TRUE(result_listener.WaitUntilSatisfied());
	EXPECT_EQ("success", result_listener.message());
	}

	namespace {

	device::mojom::HidDeviceInfoPtr CreateDeviceWithOneCollection(
	const std::string& guid) {
	auto device_info = device::mojom::HidDeviceInfo::New();
	device_info->guid = guid;
	device_info->vendor_id = kTestVendorId;
	device_info->product_id = kTestProductId;
	auto collection = device::mojom::HidCollectionInfo::New();
	collection->usage =
	device::mojom::HidUsageAndPage::New(1, device::mojom::kPageVendor);
	auto report = device::mojom::HidReportDescription::New();
	collection->input_reports.push_back(std::move(report));
	device_info->collections.push_back(std::move(collection));
	return device_info;
	}

	device::mojom::HidDeviceInfoPtr CreateDeviceWithTwoCollections(
	const std::string guid) {
	auto device_info = CreateDeviceWithOneCollection(guid);
	auto collection = device::mojom::HidCollectionInfo::New();
	collection->usage =
	device::mojom::HidUsageAndPage::New(2, device::mojom::kPageVendor);
	collection->output_reports.push_back(
	device::mojom::HidReportDescription::New());
	device_info->collections.push_back(std::move(collection));
	return device_info;
	}

	} // namespace

	IN_PROC_BROWSER_TEST_F(HidApiTest, DeviceAddedChangedRemoved) {
	constexpr char kTestGuid[] = "guid";

	ExtensionTestMessageListener load_listener("loaded");
	ExtensionTestMessageListener add_listener("added", ReplyBehavior::kWillReply);
	ExtensionTestMessageListener change_listener("changed");
	ExtensionTestMessageListener result_listener("success");
	result_listener.set_failure_message("failure");

	ASSERT_TRUE(LoadApp("api_test/hid/add_change_remove"));
	ASSERT_TRUE(load_listener.WaitUntilSatisfied());

	// Add a device with one collection.
	GetFakeHidManager()->AddDevice(CreateDeviceWithOneCollection(kTestGuid));
	ASSERT_TRUE(add_listener.WaitUntilSatisfied());

	// Update the device info to add a second collection. No event is generated,
	// so we will reply to the \|add_listener\| to signal to the test that the
	// change is complete.
	GetFakeHidManager()->ChangeDevice(CreateDeviceWithTwoCollections(kTestGuid));
	add_listener.Reply("device info updated");
	ASSERT_TRUE(change_listener.WaitUntilSatisfied());

	// Remove the device.
	GetFakeHidManager()->RemoveDevice(kTestGuid);
	ASSERT_TRUE(result_listener.WaitUntilSatisfied());
	EXPECT_EQ("success", result_listener.message());
	}

	} // namespace extensions