Extract //device/usb mocks so that they can be shared.

chrome/browser/extensions/api/device_permissions_manager_unittest.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/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/values_test_util.h"
 #include "chrome/browser/extensions/test_extension_environment.h"
 #include "chrome/test/base/testing_profile.h"
 #include "device/core/device_client.h"
 #include "device/hid/hid_device_info.h"
-#include "device/usb/usb_device.h"
-#include "device/usb/usb_device_handle.h"
+#include "device/usb/mock_usb_device.h"
+#include "device/usb/mock_usb_service.h"
 #include "extensions/browser/api/device_permissions_manager.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/common/extension.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace extensions {
 
 namespace {
 
 using device::HidDeviceId;
 using device::HidDeviceInfo;
 using device::HidService;
+using device::MockUsbDevice;
+using device::MockUsbService;
 using device::UsbDevice;
 using device::UsbDeviceHandle;
 using device::UsbService;
 using testing::_;
 using testing::DoAll;
 using testing::Return;
 using testing::SetArgPointee;
 
 #if defined(OS_MACOSX)
 const uint64_t kTestDeviceIds[] = {1, 2, 3, 4};
 #else
 const char* kTestDeviceIds[] = {"A", "B", "C", "D"};
 #endif
 
-int next_id;
-
 class MockDeviceClient : device::DeviceClient {
  public:
   MockDeviceClient() {}
 
   // device::DeviceClient implementation:
   UsbService* GetUsbService() override {
     DCHECK(usb_service_);
     return usb_service_;
   }
 
   HidService* GetHidService() override {
     DCHECK(hid_service_);
     return hid_service_;
   }
 
   void set_usb_service(UsbService* service) { usb_service_ = service; }
   void set_hid_service(HidService* service) { hid_service_ = service; }
 
  private:
   UsbService* usb_service_ = nullptr;
   HidService* hid_service_ = nullptr;
 };
 
-class MockUsbService : public UsbService {
- public:
-  MockUsbService() {}
-
-  MOCK_METHOD1(GetDeviceById, scoped_refptr<UsbDevice>(uint32));
-  MOCK_METHOD1(GetDevices, void(const GetDevicesCallback& callback));
-
-  // Public wrapper for the protected NotifyDeviceRemove function.
-  void NotifyDeviceRemoved(scoped_refptr<UsbDevice> device) {
-    UsbService::NotifyDeviceRemoved(device);
-  }
-};
-
-class MockUsbDevice : public UsbDevice {
- public:
-  explicit MockUsbDevice(const std::string& serial_number)
-      : UsbDevice(0,
-                  0,
-                  next_id++,
-                  base::ASCIIToUTF16("Test Manufacturer"),
-                  base::ASCIIToUTF16("Test Product"),
-                  base::ASCIIToUTF16(serial_number)) {}
-
-  MOCK_METHOD1(Open, void(const OpenCallback&));
-  MOCK_METHOD1(Close, bool(scoped_refptr<UsbDeviceHandle>));
-  MOCK_METHOD0(GetConfiguration, const device::UsbConfigDescriptor*());
-
- private:
-  virtual ~MockUsbDevice() {}
-};
-
 class MockHidService : public HidService {
  public:
   MockHidService() {}
   ~MockHidService() override {}
 
   // Public wrappers around protected functions needed for tests.
   void AddDevice(scoped_refptr<HidDeviceInfo> info) {
     HidService::AddDevice(info);
   }
 
@@ skipping 20 matching lines @@
     extension_ =
         env_->MakeExtension(*base::test::ParseJson(
                                 "{"
                                 "  \"app\": {"
                                 "    \"background\": {"
                                 "      \"scripts\": [\"background.js\"]"
                                 "    }"
                                 "  },"
                                 "  \"permissions\": [ \"hid\", \"usb\" ]"
                                 "}"));
-    device0_ = new MockUsbDevice("ABCDE");
-    device1_ = new MockUsbDevice("");
-    device2_ = new MockUsbDevice("12345");
-    device3_ = new MockUsbDevice("");
+    device0_ =
+        new MockUsbDevice(0, 0, "Test Manufacturer", "Test Product", "ABCDE");
+    device1_ = new MockUsbDevice(0, 0, "Test Manufacturer", "Test Product", "");
+    device2_ =
+        new MockUsbDevice(0, 0, "Test Manufacturer", "Test Product", "12345");
+    device3_ = new MockUsbDevice(0, 0, "Test Manufacturer", "Test Product", "");
     device4_ =
         new HidDeviceInfo(kTestDeviceIds[0], 0, 0, "Test HID Device", "abcde",
                           device::kHIDBusTypeUSB, std::vector<uint8>());
     hid_service_.AddDevice(device4_);
     device5_ = new HidDeviceInfo(kTestDeviceIds[1], 0, 0, "Test HID Device", "",
                                  device::kHIDBusTypeUSB, std::vector<uint8>());
     hid_service_.AddDevice(device5_);
     device6_ =
         new HidDeviceInfo(kTestDeviceIds[2], 0, 0, "Test HID Device", "67890",
                           device::kHIDBusTypeUSB, std::vector<uint8>());
@@ skipping 141 matching lines @@
       manager->GetForExtension(extension_->id());
   EXPECT_TRUE(device_permissions->FindUsbDeviceEntry(device0_).get());
   EXPECT_TRUE(device_permissions->FindUsbDeviceEntry(device1_).get());
   EXPECT_FALSE(device_permissions->FindUsbDeviceEntry(device2_).get());
   EXPECT_FALSE(device_permissions->FindUsbDeviceEntry(device3_).get());
   EXPECT_TRUE(device_permissions->FindHidDeviceEntry(device4_).get());
   EXPECT_TRUE(device_permissions->FindHidDeviceEntry(device5_).get());
   EXPECT_FALSE(device_permissions->FindHidDeviceEntry(device6_).get());
   EXPECT_FALSE(device_permissions->FindHidDeviceEntry(device7_).get());
 
-  usb_service_.NotifyDeviceRemoved(device0_);
-  usb_service_.NotifyDeviceRemoved(device1_);
+  usb_service_.RemoveDevice(device0_);
+  usb_service_.RemoveDevice(device1_);
   hid_service_.RemoveDevice(device4_->device_id());
   hid_service_.RemoveDevice(device5_->device_id());
 
   // Device 0 will be accessible when it is reconnected because it can be
   // recognized by its serial number.
   EXPECT_TRUE(device_permissions->FindUsbDeviceEntry(device0_).get());
   // Device 1 does not have a serial number and cannot be distinguished from
   // any other device of the same model so the app must request permission again
   // when it is reconnected.
   EXPECT_FALSE(device_permissions->FindUsbDeviceEntry(device1_).get());
@@ skipping 190 matching lines @@
   EXPECT_EQ(base::ASCIIToUTF16("Widget"),
             DevicePermissionsManager::GetPermissionMessage(
                 0x0001, 0x0000, manufacturer, product, empty, false));
 
   EXPECT_EQ(base::ASCIIToUTF16("Widget (serial number A)"),
             DevicePermissionsManager::GetPermissionMessage(
                 0x0001, 0x0000, manufacturer, product, serial_number, false));
 }
 
 }  // namespace extensions