chrome/browser/extensions/api/device_permissions_manager_unittest.cc - chromium/src.git - Git at Google

 // 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/usb/usb_device.h"
 #include "device/usb/usb_device_handle.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::UsbDevice;
 using device::UsbDeviceHandle;
 using device::UsbService;
 using testing::_;
 using testing::DoAll;
 using testing::Return;
 using testing::SetArgPointee;

 int next_id;

 class MockUsbService : public UsbService {
  public:
   MockUsbService() : mock_device_client(this) {}

   MOCK_METHOD1(GetDeviceById, scoped_refptr<UsbDevice>(uint32));
   MOCK_METHOD1(GetDevices, void(std::vector<scoped_refptr<UsbDevice>>*));

   // Public wrapper for the protected NotifyDeviceRemove function.
   void NotifyDeviceRemoved(scoped_refptr<UsbDevice> device) {
     UsbService::NotifyDeviceRemoved(device);
   }

  private:
   class MockDeviceClient : device::DeviceClient {
    public:
     explicit MockDeviceClient(UsbService* usb_service)
         : usb_service_(usb_service) {}

     UsbService* GetUsbService() override { return usb_service_; }

    private:
     UsbService* usb_service_;
   };

   MockDeviceClient mock_device_client;
 };

 class MockUsbDevice : public UsbDevice {
  public:
   explicit MockUsbDevice(const std::string& serial_number)
       : UsbDevice(0, 0, next_id++) {
     if (serial_number.empty()) {
       EXPECT_CALL(*this, GetSerialNumber(_)).WillRepeatedly(Return(false));
     } else {
       EXPECT_CALL(*this, GetSerialNumber(_))
           .WillRepeatedly(
               DoAll(SetArgPointee<0>(base::ASCIIToUTF16(serial_number)),
                     Return(true)));
     }

     EXPECT_CALL(*this, GetProduct(_))
         .WillRepeatedly(
             DoAll(SetArgPointee<0>(base::ASCIIToUTF16("Test Product")),
                   Return(true)));
     EXPECT_CALL(*this, GetManufacturer(_))
         .WillRepeatedly(
             DoAll(SetArgPointee<0>(base::ASCIIToUTF16("Test Manufacturer")),
                   Return(true)));
   }

   MOCK_METHOD2(RequestUsbAccess, void(int, const base::Callback<void(bool)>&));
   MOCK_METHOD0(Open, scoped_refptr<UsbDeviceHandle>());
   MOCK_METHOD1(Close, bool(scoped_refptr<UsbDeviceHandle>));
   MOCK_METHOD0(GetConfiguration, const device::UsbConfigDescriptor*());
   MOCK_METHOD1(GetManufacturer, bool(base::string16*));
   MOCK_METHOD1(GetProduct, bool(base::string16*));
   MOCK_METHOD1(GetSerialNumber, bool(base::string16*));

  private:
   virtual ~MockUsbDevice() {}
 };

 void AllowUsbDevice(DevicePermissionsManager* manager,
                     const Extension* extension,
                     scoped_refptr<UsbDevice> device) {
   // If the device cannot provide any of these strings they will simply by
   // empty.
   base::string16 product;
   device->GetProduct(&product);
   base::string16 manufacturer;
   device->GetManufacturer(&manufacturer);
   base::string16 serial_number;
   device->GetSerialNumber(&serial_number);

   manager->AllowUsbDevice(
       extension->id(), device, product, manufacturer, serial_number);
 }

 scoped_refptr<DevicePermissionEntry> FindEntry(
     DevicePermissions* device_permissions,
     scoped_refptr<UsbDevice> device) {
   base::string16 serial_number;
   device->GetSerialNumber(&serial_number);

   return device_permissions->FindEntry(device, serial_number);
 }

 }  // namespace

 class DevicePermissionsManagerTest : public testing::Test {
  protected:
   void SetUp() override {
     testing::Test::SetUp();
     env_.GetExtensionPrefs();  // Force creation before adding extensions.
     extension_ = env_.MakeExtension(*base::test::ParseJson(
                                         "{"
                                         "  \"app\": {"
                                         "    \"background\": {"
                                         "      \"scripts\": [\"background.js\"]"
                                         "    }"
                                         "  },"
                                         "  \"permissions\": ["
                                         "    \"usb\""
                                         "  ]"
                                         "}"));
     device0_ = new MockUsbDevice("ABCDE");
     device1_ = new MockUsbDevice("");
     device2_ = new MockUsbDevice("12345");
     device3_ = new MockUsbDevice("");
     usb_service_ = new MockUsbService();
     UsbService::SetInstanceForTest(usb_service_);
   }

   extensions::TestExtensionEnvironment env_;
   const extensions::Extension* extension_;
   MockUsbService* usb_service_;
   scoped_refptr<MockUsbDevice> device0_;
   scoped_refptr<MockUsbDevice> device1_;
   scoped_refptr<MockUsbDevice> device2_;
   scoped_refptr<MockUsbDevice> device3_;
 };

 TEST_F(DevicePermissionsManagerTest, AllowAndClearDevices) {
   DevicePermissionsManager* manager =
       DevicePermissionsManager::Get(env_.profile());
   AllowUsbDevice(manager, extension_, device0_);
   AllowUsbDevice(manager, extension_, device1_);

   scoped_ptr<DevicePermissions> device_permissions =
       manager->GetForExtension(extension_->id());
   scoped_refptr<DevicePermissionEntry> device0_entry =
       FindEntry(device_permissions.get(), device0_);
   ASSERT_TRUE(device0_entry.get());
   scoped_refptr<DevicePermissionEntry> device1_entry =
       FindEntry(device_permissions.get(), device1_);
   ASSERT_TRUE(device1_entry.get());
   ASSERT_FALSE(FindEntry(device_permissions.get(), device2_).get());
   ASSERT_FALSE(FindEntry(device_permissions.get(), device3_).get());
   ASSERT_EQ(2U, device_permissions->entries().size());

   ASSERT_EQ(base::ASCIIToUTF16(
                 "Test Product from Test Manufacturer (serial number ABCDE)"),
             device0_entry->GetPermissionMessageString());
   ASSERT_EQ(base::ASCIIToUTF16("Test Product from Test Manufacturer"),
             device1_entry->GetPermissionMessageString());

   manager->Clear(extension_->id());

   device_permissions = manager->GetForExtension(extension_->id());
   ASSERT_FALSE(FindEntry(device_permissions.get(), device0_).get());
   ASSERT_FALSE(FindEntry(device_permissions.get(), device1_).get());
   ASSERT_FALSE(FindEntry(device_permissions.get(), device2_).get());
   ASSERT_FALSE(FindEntry(device_permissions.get(), device3_).get());
   ASSERT_EQ(0U, device_permissions->entries().size());

   // After clearing device it should be possible to grant permission again.
   AllowUsbDevice(manager, extension_, device0_);
   AllowUsbDevice(manager, extension_, device1_);

   device_permissions = manager->GetForExtension(extension_->id());
   ASSERT_TRUE(FindEntry(device_permissions.get(), device0_).get());
   ASSERT_TRUE(FindEntry(device_permissions.get(), device1_).get());
   ASSERT_FALSE(FindEntry(device_permissions.get(), device2_).get());
   ASSERT_FALSE(FindEntry(device_permissions.get(), device3_).get());
 }

 TEST_F(DevicePermissionsManagerTest, SuspendExtension) {
   DevicePermissionsManager* manager =
       DevicePermissionsManager::Get(env_.profile());
   AllowUsbDevice(manager, extension_, device0_);
   AllowUsbDevice(manager, extension_, device1_);

   scoped_ptr<DevicePermissions> device_permissions =
       manager->GetForExtension(extension_->id());
   ASSERT_TRUE(FindEntry(device_permissions.get(), device0_).get());
   ASSERT_TRUE(FindEntry(device_permissions.get(), device1_).get());
   ASSERT_FALSE(FindEntry(device_permissions.get(), device2_).get());
   ASSERT_FALSE(FindEntry(device_permissions.get(), device3_).get());

   manager->OnBackgroundHostClose(extension_->id());

   device_permissions = manager->GetForExtension(extension_->id());
   // Device 0 is still registered because its serial number has been stored in
   // ExtensionPrefs, it is "persistent".
   ASSERT_TRUE(FindEntry(device_permissions.get(), device0_).get());
   // Device 1 does not have uniquely identifying traits and so permission to
   // open it has been dropped when the app's windows have closed and the
   // background page has been suspended.
   ASSERT_FALSE(FindEntry(device_permissions.get(), device1_).get());
   ASSERT_FALSE(FindEntry(device_permissions.get(), device2_).get());
   ASSERT_FALSE(FindEntry(device_permissions.get(), device3_).get());
 }

 // TODO(reillyg): Until crbug.com/427985 is resolved device removal
 // notifications are delivered asynchronously and so this test must be disabled.
 TEST_F(DevicePermissionsManagerTest, DISABLED_DisconnectDevice) {
   DevicePermissionsManager* manager =
       DevicePermissionsManager::Get(env_.profile());
   AllowUsbDevice(manager, extension_, device0_);
   AllowUsbDevice(manager, extension_, device1_);

   scoped_ptr<DevicePermissions> device_permissions =
       manager->GetForExtension(extension_->id());
   ASSERT_TRUE(FindEntry(device_permissions.get(), device0_).get());
   ASSERT_TRUE(FindEntry(device_permissions.get(), device1_).get());
   ASSERT_FALSE(FindEntry(device_permissions.get(), device2_).get());
   ASSERT_FALSE(FindEntry(device_permissions.get(), device3_).get());

   usb_service_->NotifyDeviceRemoved(device0_);
   usb_service_->NotifyDeviceRemoved(device1_);

   device_permissions = manager->GetForExtension(extension_->id());
   // Device 0 will be accessible when it is reconnected because it can be
   // recognized by its serial number.
   ASSERT_TRUE(FindEntry(device_permissions.get(), 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.
   ASSERT_FALSE(FindEntry(device_permissions.get(), device1_).get());
   ASSERT_FALSE(FindEntry(device_permissions.get(), device2_).get());
   ASSERT_FALSE(FindEntry(device_permissions.get(), device3_).get());
 }

 TEST_F(DevicePermissionsManagerTest, RevokeAndRegrantAccess) {
   DevicePermissionsManager* manager =
       DevicePermissionsManager::Get(env_.profile());
   AllowUsbDevice(manager, extension_, device0_);
   AllowUsbDevice(manager, extension_, device1_);

   scoped_ptr<DevicePermissions> device_permissions =
       manager->GetForExtension(extension_->id());
   scoped_refptr<DevicePermissionEntry> device0_entry =
       FindEntry(device_permissions.get(), device0_);
   ASSERT_TRUE(device0_entry.get());
   scoped_refptr<DevicePermissionEntry> device1_entry =
       FindEntry(device_permissions.get(), device1_);
   ASSERT_TRUE(device1_entry.get());

   manager->RemoveEntry(extension_->id(), device0_entry);
   device_permissions = manager->GetForExtension(extension_->id());
   ASSERT_FALSE(FindEntry(device_permissions.get(), device0_).get());
   ASSERT_TRUE(FindEntry(device_permissions.get(), device1_).get());

   AllowUsbDevice(manager, extension_, device0_);
   device_permissions = manager->GetForExtension(extension_->id());
   ASSERT_TRUE(FindEntry(device_permissions.get(), device0_).get());
   ASSERT_TRUE(FindEntry(device_permissions.get(), device1_).get());

   manager->RemoveEntry(extension_->id(), device1_entry);
   device_permissions = manager->GetForExtension(extension_->id());
   ASSERT_TRUE(FindEntry(device_permissions.get(), device0_).get());
   ASSERT_FALSE(FindEntry(device_permissions.get(), device1_).get());

   AllowUsbDevice(manager, extension_, device1_);
   device_permissions = manager->GetForExtension(extension_->id());
   ASSERT_TRUE(FindEntry(device_permissions.get(), device0_).get());
   ASSERT_TRUE(FindEntry(device_permissions.get(), device1_).get());
 }

 TEST_F(DevicePermissionsManagerTest, UpdateLastUsed) {
   DevicePermissionsManager* manager =
       DevicePermissionsManager::Get(env_.profile());
   AllowUsbDevice(manager, extension_, device0_);

   scoped_ptr<DevicePermissions> device_permissions =
       manager->GetForExtension(extension_->id());
   scoped_refptr<DevicePermissionEntry> device0_entry =
       FindEntry(device_permissions.get(), device0_);
   ASSERT_TRUE(device0_entry->last_used().is_null());

   manager->UpdateLastUsed(extension_->id(), device0_entry);
   device_permissions = manager->GetForExtension(extension_->id());
   device0_entry = FindEntry(device_permissions.get(), device0_);
   ASSERT_FALSE(device0_entry->last_used().is_null());
 }

 TEST_F(DevicePermissionsManagerTest, LoadPrefs) {
   scoped_ptr<base::Value> prefs_value = base::test::ParseJson(
       "["
       "  {"
       "    \"product_id\": 0,"
       "    \"serial_number\": \"ABCDE\","
       "    \"type\": \"usb\","
       "    \"vendor_id\": 0"
       "  }"
       "]");
   env_.GetExtensionPrefs()->UpdateExtensionPref(extension_->id(), "devices",
                                                 prefs_value.release());

   DevicePermissionsManager* manager =
       DevicePermissionsManager::Get(env_.profile());
   scoped_ptr<DevicePermissions> device_permissions =
       manager->GetForExtension(extension_->id());
   ASSERT_TRUE(FindEntry(device_permissions.get(), device0_).get());
   ASSERT_FALSE(FindEntry(device_permissions.get(), device1_).get());
   ASSERT_FALSE(FindEntry(device_permissions.get(), device2_).get());
   ASSERT_FALSE(FindEntry(device_permissions.get(), device3_).get());
 }

 }  // namespace extensions
	// 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/usb/usb_device.h"
	#include "device/usb/usb_device_handle.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::UsbDevice;
	using device::UsbDeviceHandle;
	using device::UsbService;
	using testing::_;
	using testing::DoAll;
	using testing::Return;
	using testing::SetArgPointee;

	int next_id;

	class MockUsbService : public UsbService {
	public:
	MockUsbService() : mock_device_client(this) {}

	MOCK_METHOD1(GetDeviceById, scoped_refptr<UsbDevice>(uint32));
	MOCK_METHOD1(GetDevices, void(std::vector<scoped_refptr<UsbDevice>>*));

	// Public wrapper for the protected NotifyDeviceRemove function.
	void NotifyDeviceRemoved(scoped_refptr<UsbDevice> device) {
	UsbService::NotifyDeviceRemoved(device);
	}

	private:
	class MockDeviceClient : device::DeviceClient {
	public:
	explicit MockDeviceClient(UsbService* usb_service)
	: usb_service_(usb_service) {}

	UsbService* GetUsbService() override { return usb_service_; }

	private:
	UsbService* usb_service_;
	};

	MockDeviceClient mock_device_client;
	};

	class MockUsbDevice : public UsbDevice {
	public:
	explicit MockUsbDevice(const std::string& serial_number)
	: UsbDevice(0, 0, next_id++) {
	if (serial_number.empty()) {
	EXPECT_CALL(*this, GetSerialNumber(_)).WillRepeatedly(Return(false));
	} else {
	EXPECT_CALL(*this, GetSerialNumber(_))
	.WillRepeatedly(
	DoAll(SetArgPointee<0>(base::ASCIIToUTF16(serial_number)),
	Return(true)));
	}

	EXPECT_CALL(*this, GetProduct(_))
	.WillRepeatedly(
	DoAll(SetArgPointee<0>(base::ASCIIToUTF16("Test Product")),
	Return(true)));
	EXPECT_CALL(*this, GetManufacturer(_))
	.WillRepeatedly(
	DoAll(SetArgPointee<0>(base::ASCIIToUTF16("Test Manufacturer")),
	Return(true)));
	}

	MOCK_METHOD2(RequestUsbAccess, void(int, const base::Callback<void(bool)>&));
	MOCK_METHOD0(Open, scoped_refptr<UsbDeviceHandle>());
	MOCK_METHOD1(Close, bool(scoped_refptr<UsbDeviceHandle>));
	MOCK_METHOD0(GetConfiguration, const device::UsbConfigDescriptor*());
	MOCK_METHOD1(GetManufacturer, bool(base::string16*));
	MOCK_METHOD1(GetProduct, bool(base::string16*));
	MOCK_METHOD1(GetSerialNumber, bool(base::string16*));

	private:
	virtual ~MockUsbDevice() {}
	};

	void AllowUsbDevice(DevicePermissionsManager* manager,
	const Extension* extension,
	scoped_refptr<UsbDevice> device) {
	// If the device cannot provide any of these strings they will simply by
	// empty.
	base::string16 product;
	device->GetProduct(&product);
	base::string16 manufacturer;
	device->GetManufacturer(&manufacturer);
	base::string16 serial_number;
	device->GetSerialNumber(&serial_number);

	manager->AllowUsbDevice(
	extension->id(), device, product, manufacturer, serial_number);
	}

	scoped_refptr<DevicePermissionEntry> FindEntry(
	DevicePermissions* device_permissions,
	scoped_refptr<UsbDevice> device) {
	base::string16 serial_number;
	device->GetSerialNumber(&serial_number);

	return device_permissions->FindEntry(device, serial_number);
	}

	} // namespace

	class DevicePermissionsManagerTest : public testing::Test {
	protected:
	void SetUp() override {
	testing::Test::SetUp();
	env_.GetExtensionPrefs(); // Force creation before adding extensions.
	extension_ = env_.MakeExtension(*base::test::ParseJson(
	"{"
	" \"app\": {"
	" \"background\": {"
	" \"scripts\": [\"background.js\"]"
	" }"
	" },"
	" \"permissions\": ["
	" \"usb\""
	" ]"
	"}"));
	device0_ = new MockUsbDevice("ABCDE");
	device1_ = new MockUsbDevice("");
	device2_ = new MockUsbDevice("12345");
	device3_ = new MockUsbDevice("");
	usb_service_ = new MockUsbService();
	UsbService::SetInstanceForTest(usb_service_);
	}

	extensions::TestExtensionEnvironment env_;
	const extensions::Extension* extension_;
	MockUsbService* usb_service_;
	scoped_refptr<MockUsbDevice> device0_;
	scoped_refptr<MockUsbDevice> device1_;
	scoped_refptr<MockUsbDevice> device2_;
	scoped_refptr<MockUsbDevice> device3_;
	};

	TEST_F(DevicePermissionsManagerTest, AllowAndClearDevices) {
	DevicePermissionsManager* manager =
	DevicePermissionsManager::Get(env_.profile());
	AllowUsbDevice(manager, extension_, device0_);
	AllowUsbDevice(manager, extension_, device1_);

	scoped_ptr<DevicePermissions> device_permissions =
	manager->GetForExtension(extension_->id());
	scoped_refptr<DevicePermissionEntry> device0_entry =
	FindEntry(device_permissions.get(), device0_);
	ASSERT_TRUE(device0_entry.get());
	scoped_refptr<DevicePermissionEntry> device1_entry =
	FindEntry(device_permissions.get(), device1_);
	ASSERT_TRUE(device1_entry.get());
	ASSERT_FALSE(FindEntry(device_permissions.get(), device2_).get());
	ASSERT_FALSE(FindEntry(device_permissions.get(), device3_).get());
	ASSERT_EQ(2U, device_permissions->entries().size());

	ASSERT_EQ(base::ASCIIToUTF16(
	"Test Product from Test Manufacturer (serial number ABCDE)"),
	device0_entry->GetPermissionMessageString());
	ASSERT_EQ(base::ASCIIToUTF16("Test Product from Test Manufacturer"),
	device1_entry->GetPermissionMessageString());

	manager->Clear(extension_->id());

	device_permissions = manager->GetForExtension(extension_->id());
	ASSERT_FALSE(FindEntry(device_permissions.get(), device0_).get());
	ASSERT_FALSE(FindEntry(device_permissions.get(), device1_).get());
	ASSERT_FALSE(FindEntry(device_permissions.get(), device2_).get());
	ASSERT_FALSE(FindEntry(device_permissions.get(), device3_).get());
	ASSERT_EQ(0U, device_permissions->entries().size());

	// After clearing device it should be possible to grant permission again.
	AllowUsbDevice(manager, extension_, device0_);
	AllowUsbDevice(manager, extension_, device1_);

	device_permissions = manager->GetForExtension(extension_->id());
	ASSERT_TRUE(FindEntry(device_permissions.get(), device0_).get());
	ASSERT_TRUE(FindEntry(device_permissions.get(), device1_).get());
	ASSERT_FALSE(FindEntry(device_permissions.get(), device2_).get());
	ASSERT_FALSE(FindEntry(device_permissions.get(), device3_).get());
	}

	TEST_F(DevicePermissionsManagerTest, SuspendExtension) {
	DevicePermissionsManager* manager =
	DevicePermissionsManager::Get(env_.profile());
	AllowUsbDevice(manager, extension_, device0_);
	AllowUsbDevice(manager, extension_, device1_);

	scoped_ptr<DevicePermissions> device_permissions =
	manager->GetForExtension(extension_->id());
	ASSERT_TRUE(FindEntry(device_permissions.get(), device0_).get());
	ASSERT_TRUE(FindEntry(device_permissions.get(), device1_).get());
	ASSERT_FALSE(FindEntry(device_permissions.get(), device2_).get());
	ASSERT_FALSE(FindEntry(device_permissions.get(), device3_).get());

	manager->OnBackgroundHostClose(extension_->id());

	device_permissions = manager->GetForExtension(extension_->id());
	// Device 0 is still registered because its serial number has been stored in
	// ExtensionPrefs, it is "persistent".
	ASSERT_TRUE(FindEntry(device_permissions.get(), device0_).get());
	// Device 1 does not have uniquely identifying traits and so permission to
	// open it has been dropped when the app's windows have closed and the
	// background page has been suspended.
	ASSERT_FALSE(FindEntry(device_permissions.get(), device1_).get());
	ASSERT_FALSE(FindEntry(device_permissions.get(), device2_).get());
	ASSERT_FALSE(FindEntry(device_permissions.get(), device3_).get());
	}

	// TODO(reillyg): Until crbug.com/427985 is resolved device removal
	// notifications are delivered asynchronously and so this test must be disabled.
	TEST_F(DevicePermissionsManagerTest, DISABLED_DisconnectDevice) {
	DevicePermissionsManager* manager =
	DevicePermissionsManager::Get(env_.profile());
	AllowUsbDevice(manager, extension_, device0_);
	AllowUsbDevice(manager, extension_, device1_);

	scoped_ptr<DevicePermissions> device_permissions =
	manager->GetForExtension(extension_->id());
	ASSERT_TRUE(FindEntry(device_permissions.get(), device0_).get());
	ASSERT_TRUE(FindEntry(device_permissions.get(), device1_).get());
	ASSERT_FALSE(FindEntry(device_permissions.get(), device2_).get());
	ASSERT_FALSE(FindEntry(device_permissions.get(), device3_).get());

	usb_service_->NotifyDeviceRemoved(device0_);
	usb_service_->NotifyDeviceRemoved(device1_);

	device_permissions = manager->GetForExtension(extension_->id());
	// Device 0 will be accessible when it is reconnected because it can be
	// recognized by its serial number.
	ASSERT_TRUE(FindEntry(device_permissions.get(), 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.
	ASSERT_FALSE(FindEntry(device_permissions.get(), device1_).get());
	ASSERT_FALSE(FindEntry(device_permissions.get(), device2_).get());
	ASSERT_FALSE(FindEntry(device_permissions.get(), device3_).get());
	}

	TEST_F(DevicePermissionsManagerTest, RevokeAndRegrantAccess) {
	DevicePermissionsManager* manager =
	DevicePermissionsManager::Get(env_.profile());
	AllowUsbDevice(manager, extension_, device0_);
	AllowUsbDevice(manager, extension_, device1_);

	scoped_ptr<DevicePermissions> device_permissions =
	manager->GetForExtension(extension_->id());
	scoped_refptr<DevicePermissionEntry> device0_entry =
	FindEntry(device_permissions.get(), device0_);
	ASSERT_TRUE(device0_entry.get());
	scoped_refptr<DevicePermissionEntry> device1_entry =
	FindEntry(device_permissions.get(), device1_);
	ASSERT_TRUE(device1_entry.get());

	manager->RemoveEntry(extension_->id(), device0_entry);
	device_permissions = manager->GetForExtension(extension_->id());
	ASSERT_FALSE(FindEntry(device_permissions.get(), device0_).get());
	ASSERT_TRUE(FindEntry(device_permissions.get(), device1_).get());

	AllowUsbDevice(manager, extension_, device0_);
	device_permissions = manager->GetForExtension(extension_->id());
	ASSERT_TRUE(FindEntry(device_permissions.get(), device0_).get());
	ASSERT_TRUE(FindEntry(device_permissions.get(), device1_).get());

	manager->RemoveEntry(extension_->id(), device1_entry);
	device_permissions = manager->GetForExtension(extension_->id());
	ASSERT_TRUE(FindEntry(device_permissions.get(), device0_).get());
	ASSERT_FALSE(FindEntry(device_permissions.get(), device1_).get());

	AllowUsbDevice(manager, extension_, device1_);
	device_permissions = manager->GetForExtension(extension_->id());
	ASSERT_TRUE(FindEntry(device_permissions.get(), device0_).get());
	ASSERT_TRUE(FindEntry(device_permissions.get(), device1_).get());
	}

	TEST_F(DevicePermissionsManagerTest, UpdateLastUsed) {
	DevicePermissionsManager* manager =
	DevicePermissionsManager::Get(env_.profile());
	AllowUsbDevice(manager, extension_, device0_);

	scoped_ptr<DevicePermissions> device_permissions =
	manager->GetForExtension(extension_->id());
	scoped_refptr<DevicePermissionEntry> device0_entry =
	FindEntry(device_permissions.get(), device0_);
	ASSERT_TRUE(device0_entry->last_used().is_null());

	manager->UpdateLastUsed(extension_->id(), device0_entry);
	device_permissions = manager->GetForExtension(extension_->id());
	device0_entry = FindEntry(device_permissions.get(), device0_);
	ASSERT_FALSE(device0_entry->last_used().is_null());
	}

	TEST_F(DevicePermissionsManagerTest, LoadPrefs) {
	scoped_ptr<base::Value> prefs_value = base::test::ParseJson(
	"["
	" {"
	" \"product_id\": 0,"
	" \"serial_number\": \"ABCDE\","
	" \"type\": \"usb\","
	" \"vendor_id\": 0"
	" }"
	"]");
	env_.GetExtensionPrefs()->UpdateExtensionPref(extension_->id(), "devices",
	prefs_value.release());

	DevicePermissionsManager* manager =
	DevicePermissionsManager::Get(env_.profile());
	scoped_ptr<DevicePermissions> device_permissions =
	manager->GetForExtension(extension_->id());
	ASSERT_TRUE(FindEntry(device_permissions.get(), device0_).get());
	ASSERT_FALSE(FindEntry(device_permissions.get(), device1_).get());
	ASSERT_FALSE(FindEntry(device_permissions.get(), device2_).get());
	ASSERT_FALSE(FindEntry(device_permissions.get(), device3_).get());
	}

	} // namespace extensions