Add an Observer interface to UsbService for device add/remove.

extensions/browser/api/device_permissions_manager.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 "extensions/browser/api/device_permissions_manager.h"
 
 #include "base/memory/singleton.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "components/keyed_service/content/browser_context_dependency_manager.h"
+#include "device/core/device_client.h"
+#include "device/usb/usb_device.h"
 #include "device/usb/usb_ids.h"
 #include "extensions/browser/extension_host.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extensions_browser_client.h"
 #include "extensions/browser/process_manager.h"
 #include "extensions/browser/process_manager_factory.h"
 #include "extensions/strings/grit/extensions_strings.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace extensions {
@@ skipping 408 matching lines @@
     }
 
     device_permissions->entries_.insert(device_entry);
     SaveDevicePermissionEntry(context_, extension_id, device_entry);
   } else if (!ContainsKey(device_permissions->ephemeral_devices_, device)) {
     // Non-persistent devices cannot be reliably identified when they are
     // reconnected so such devices are only remembered until disconnect.
     // Register an observer here so that this set doesn't grow undefinitely.
     device_permissions->entries_.insert(device_entry);
     device_permissions->ephemeral_devices_[device] = device_entry;
-    device->AddObserver(this);
+
+    // Only start observing when an ephemeral device has been added so that
+    // UsbService is not automatically initialized on profile creation (which it
+    // would be if this call were in the constructor).
+    device::UsbService* usb_service =
+        device::DeviceClient::Get()->GetUsbService();
+    DCHECK(usb_service);
+    if (!usb_service_observer_.IsObserving(usb_service)) {
+      usb_service_observer_.Add(usb_service);
+    }
   }
 }
 
 void DevicePermissionsManager::UpdateLastUsed(
     const std::string& extension_id,
     scoped_refptr<DevicePermissionEntry> entry) {
   DCHECK(CalledOnValidThread());
   entry->set_last_used(base::Time::Now());
   if (entry->IsPersistent()) {
     UpdateDevicePermissionEntry(context_, extension_id, entry);
   }
 }
 
 void DevicePermissionsManager::RemoveEntry(
     const std::string& extension_id,
     scoped_refptr<DevicePermissionEntry> entry) {
   DCHECK(CalledOnValidThread());
   DevicePermissions* device_permissions = Get(extension_id);
   DCHECK(device_permissions);
   DCHECK(ContainsKey(device_permissions->entries_, entry));
   device_permissions->entries_.erase(entry);
   if (entry->IsPersistent()) {
     RemoveDevicePermissionEntry(context_, extension_id, entry);
   } else {
     device_permissions->ephemeral_devices_.erase(entry->device_);
-    entry->device_->RemoveObserver(this);
   }
 }
 
 void DevicePermissionsManager::Clear(const std::string& extension_id) {
   DCHECK(CalledOnValidThread());
 
   ClearDevicePermissionEntries(ExtensionPrefs::Get(context_), extension_id);
   DevicePermissions* device_permissions = Get(extension_id);
   if (device_permissions) {
-    for (const auto& device_entry : device_permissions->ephemeral_devices_) {
-      device_entry.first->RemoveObserver(this);
-    }
     extension_id_to_device_permissions_.erase(extension_id);
     delete device_permissions;
   }
 }
 
 DevicePermissionsManager::DevicePermissionsManager(
     content::BrowserContext* context)
-    : context_(context), process_manager_observer_(this) {
+    : context_(context),
+      process_manager_observer_(this),
+      usb_service_observer_(this) {
   process_manager_observer_.Add(ProcessManager::Get(context));
 }
 
 DevicePermissionsManager::~DevicePermissionsManager() {
   for (const auto& map_entry : extension_id_to_device_permissions_) {
     DevicePermissions* device_permissions = map_entry.second;
-    for (const auto& device_entry : device_permissions->ephemeral_devices_) {
-      device_entry.first->RemoveObserver(this);
-    }
     delete device_permissions;
   }
 }
 
 DevicePermissions* DevicePermissionsManager::Get(
     const std::string& extension_id) const {
   std::map<std::string, DevicePermissions*>::const_iterator it =
       extension_id_to_device_permissions_.find(extension_id);
   if (it != extension_id_to_device_permissions_.end()) {
     return it->second;
@@ skipping 15 matching lines @@
 
 void DevicePermissionsManager::OnBackgroundHostClose(
     const std::string& extension_id) {
   DCHECK(CalledOnValidThread());
 
   DevicePermissions* device_permissions = Get(extension_id);
   if (device_permissions) {
     // When all of the app's windows are closed and the background page is
     // suspended all ephemeral device permissions are cleared.
     for (const auto& map_entry : device_permissions->ephemeral_devices_) {
-      map_entry.first->RemoveObserver(this);
       device_permissions->entries_.erase(map_entry.second);
     }
     device_permissions->ephemeral_devices_.clear();
   }
 }
 
-void DevicePermissionsManager::OnDisconnect(scoped_refptr<UsbDevice> device) {
+void DevicePermissionsManager::OnDeviceRemoved(
+    scoped_refptr<UsbDevice> device) {
   for (const auto& map_entry : extension_id_to_device_permissions_) {
     // An ephemeral device cannot be identified if it is reconnected and so
     // permission to access it is cleared on disconnect.
     DevicePermissions* device_permissions = map_entry.second;
     const auto& device_entry =
         device_permissions->ephemeral_devices_.find(device);
-    DCHECK(device_entry != device_permissions->ephemeral_devices_.end());
-    device_permissions->entries_.erase(device_entry->second);
-    device_permissions->ephemeral_devices_.erase(device);
-    device->RemoveObserver(this);
+    if (device_entry != device_permissions->ephemeral_devices_.end()) {
+      device_permissions->entries_.erase(device_entry->second);
+      device_permissions->ephemeral_devices_.erase(device);
+    }
   }
 }
 
 // static
 DevicePermissionsManager* DevicePermissionsManagerFactory::GetForBrowserContext(
     content::BrowserContext* context) {
   return static_cast<DevicePermissionsManager*>(
       GetInstance()->GetServiceForBrowserContext(context, true));
 }
 
@@ skipping 20 matching lines @@
 
 BrowserContext* DevicePermissionsManagerFactory::GetBrowserContextToUse(
     BrowserContext* context) const {
   // Return the original (possibly off-the-record) browser context so that a
   // separate instance of the DevicePermissionsManager is used in incognito
   // mode. The parent class's implemenation returns NULL.
   return context;
 }
 
 }  // namespace extensions