Add browser tests for USB device add/remove events.

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"
@@ skipping 105 matching lines @@
 
   return device_permissions->FindEntry(device, serial_number);
 }
 
 }  // namespace
 
 class DevicePermissionsManagerTest : public testing::Test {
  protected:
   void SetUp() override {
     testing::Test::SetUp();
-    env_.reset(new TestExtensionEnvironment());
-    env_->GetExtensionPrefs();  // Force creation before adding extensions.
-    extension_ =
-        env_->MakeExtension(*base::test::ParseJson(
-                                "{"
-                                "  \"app\": {"
-                                "    \"background\": {"
-                                "      \"scripts\": [\"background.js\"]"
-                                "    }"
-                                "  },"
-                                "  \"permissions\": ["
-                                "    \"usb\""
-                                "  ]"
-                                "}"));
+    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_);
   }
 
-  void TearDown() override {
-    env_.reset(nullptr);
-    UsbService::SetInstanceForTest(nullptr);
-  }
-
-  scoped_ptr<extensions::TestExtensionEnvironment> env_;
+  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());
+      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_);
@@ skipping 23 matching lines @@
 
   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());
+      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());
 }
 
 TEST_F(DevicePermissionsManagerTest, DisconnectDevice) {
   DevicePermissionsManager* manager =
-      DevicePermissionsManager::Get(env_->profile());
+      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());
+      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_);
@@ skipping 15 matching lines @@
   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());
+      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());
+  env_.GetExtensionPrefs()->UpdateExtensionPref(extension_->id(), "devices",
+                                                prefs_value.release());
 
   DevicePermissionsManager* manager =
-      DevicePermissionsManager::Get(env_->profile());
+      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