chrome/browser/extensions/api/device_permissions_manager_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/run_loop.h"
   6 #include "base/strings/utf_string_conversions.h"
   7 #include "base/test/values_test_util.h"
   8 #include "chrome/browser/extensions/test_extension_environment.h"
   9 #include "chrome/test/base/testing_profile.h"
  10 #include "device/usb/usb_device.h"
  11 #include "device/usb/usb_device_handle.h"
  12 #include "extensions/browser/api/device_permissions_manager.h"
  13 #include "extensions/browser/extension_prefs.h"
  14 #include "extensions/common/extension.h"
  15 #include "testing/gmock/include/gmock/gmock.h"
  16 #include "testing/gtest/include/gtest/gtest.h"
  17
  18 namespace extensions {
  19
  20 namespace {
  21
  22 using device::UsbDevice;
  23 using device::UsbDeviceHandle;
  24 using testing::Return;
  25
  26 class MockUsbDevice : public UsbDevice {
  27  public:
  28   MockUsbDevice(const std::string& serial_number, uint32 unique_id)
  29       : UsbDevice(0, 0, unique_id), serial_number_(serial_number) {}
  30
  31   MOCK_METHOD0(Open, scoped_refptr<UsbDeviceHandle>());
  32   MOCK_METHOD1(Close, bool(scoped_refptr<UsbDeviceHandle>));
  33 #if defined(OS_CHROMEOS)
  34   MOCK_METHOD2(RequestUsbAccess, void(int, const base::Callback<void(bool)>&));
  35 #endif
  36   MOCK_METHOD0(GetConfiguration, const device::UsbConfigDescriptor&());
  37   MOCK_METHOD1(GetManufacturer, bool(base::string16*));
  38   MOCK_METHOD1(GetProduct, bool(base::string16*));
  39
  40   virtual bool GetSerialNumber(base::string16* serial_number) override {
  41     if (serial_number_.empty()) {
  42       return false;
  43     }
  44
  45     *serial_number = base::UTF8ToUTF16(serial_number_);
  46     return true;
  47   }
  48
  49   void NotifyDisconnect() { UsbDevice::NotifyDisconnect(); }
  50
  51  private:
  52   virtual ~MockUsbDevice() {}
  53
  54   const std::string serial_number_;
  55 };
  56
  57 }  // namespace
  58
  59 class DevicePermissionsManagerTest : public testing::Test {
  60  protected:
  61   virtual void SetUp() override {
  62     testing::Test::SetUp();
  63     env_.GetExtensionPrefs();  // Force creation before adding extensions.
  64     extension_ = env_.MakeExtension(*base::test::ParseJson(
  65                                         "{"
  66                                         "  \"app\": {"
  67                                         "    \"background\": {"
  68                                         "      \"scripts\": [\"background.js\"]"
  69                                         "    }"
  70                                         "  },"
  71                                         "  \"permissions\": ["
  72                                         "    \"usb\""
  73                                         "  ]"
  74                                         "}"));
  75     device0 = new MockUsbDevice("ABCDE", 0);
  76     device1 = new MockUsbDevice("", 1);
  77     device2 = new MockUsbDevice("12345", 2);
  78     device3 = new MockUsbDevice("", 3);
  79   }
  80
  81   extensions::TestExtensionEnvironment env_;
  82   const extensions::Extension* extension_;
  83   scoped_refptr<MockUsbDevice> device0;
  84   scoped_refptr<MockUsbDevice> device1;
  85   scoped_refptr<MockUsbDevice> device2;
  86   scoped_refptr<MockUsbDevice> device3;
  87 };
  88
  89 TEST_F(DevicePermissionsManagerTest, RegisterDevices) {
  90   DevicePermissionsManager* manager =
  91       DevicePermissionsManager::Get(env_.profile());
  92   manager->AllowUsbDevice(
  93       extension_->id(), device0, base::ASCIIToUTF16("ABCDE"));
  94   manager->AllowUsbDevice(extension_->id(), device1, base::string16());
  95
  96   scoped_ptr<DevicePermissions> device_permissions =
  97       manager->GetForExtension(extension_->id());
  98   ASSERT_TRUE(device_permissions->CheckUsbDevice(device0));
  99   ASSERT_TRUE(device_permissions->CheckUsbDevice(device1));
 100   ASSERT_FALSE(device_permissions->CheckUsbDevice(device2));
 101   ASSERT_FALSE(device_permissions->CheckUsbDevice(device3));
 102
 103   std::vector<base::string16> device_messages =
 104       manager->GetPermissionMessageStrings(extension_->id());
 105   ASSERT_EQ(1U, device_messages.size());
 106   ASSERT_NE(device_messages[0].find(base::ASCIIToUTF16("ABCDE")),
 107             base::string16::npos);
 108
 109   device1->NotifyDisconnect();
 110
 111   device_permissions = manager->GetForExtension(extension_->id());
 112   ASSERT_TRUE(device_permissions->CheckUsbDevice(device0));
 113   ASSERT_FALSE(device_permissions->CheckUsbDevice(device1));
 114   ASSERT_FALSE(device_permissions->CheckUsbDevice(device2));
 115   ASSERT_FALSE(device_permissions->CheckUsbDevice(device3));
 116
 117   manager->Clear(extension_->id());
 118
 119   device_permissions = manager->GetForExtension(extension_->id());
 120   ASSERT_FALSE(device_permissions->CheckUsbDevice(device0));
 121   device_messages = manager->GetPermissionMessageStrings(extension_->id());
 122   ASSERT_EQ(0U, device_messages.size());
 123 }
 124
 125 TEST_F(DevicePermissionsManagerTest, LoadPrefs) {
 126   scoped_ptr<base::Value> prefs_value = base::test::ParseJson(
 127       "["
 128       "  {"
 129       "    \"product_id\": 0,"
 130       "    \"serial_number\": \"ABCDE\","
 131       "    \"type\": \"usb\","
 132       "    \"vendor_id\": 0"
 133       "  }"
 134       "]");
 135   env_.GetExtensionPrefs()->UpdateExtensionPref(
 136       extension_->id(), "devices", prefs_value.release());
 137
 138   DevicePermissionsManager* manager =
 139       DevicePermissionsManager::Get(env_.profile());
 140   scoped_ptr<DevicePermissions> device_permissions =
 141       manager->GetForExtension(extension_->id());
 142   ASSERT_TRUE(device_permissions->CheckUsbDevice(device0));
 143   ASSERT_FALSE(device_permissions->CheckUsbDevice(device1));
 144   ASSERT_FALSE(device_permissions->CheckUsbDevice(device2));
 145   ASSERT_FALSE(device_permissions->CheckUsbDevice(device3));
 146 }
 147
 148 }  // namespace extensions