Observe UsbService from the FILE thread in DevicePermissionsManager.

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/bind.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 "content/public/browser/browser_thread.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 {
 
 using content::BrowserContext;
+using content::BrowserThread;
 using device::UsbDevice;
+using device::UsbService;
 using extensions::APIPermission;
 using extensions::Extension;
 using extensions::ExtensionHost;
 using extensions::ExtensionPrefs;
 
 namespace {
 
 // Preference keys
 
 // The device that the app has permission to access.
@@ skipping 332 matching lines @@
                                      const std::string& extension_id) {
   ExtensionPrefs* prefs = ExtensionPrefs::Get(context);
   entries_ = GetDevicePermissionEntries(prefs, extension_id);
 }
 
 DevicePermissions::DevicePermissions(const DevicePermissions* original)
     : entries_(original->entries_),
       ephemeral_devices_(original->ephemeral_devices_) {
 }
 
+class DevicePermissionsManager::FileThreadHelper : public UsbService::Observer {
+ public:
+  FileThreadHelper(
+      base::WeakPtr<DevicePermissionsManager> device_permissions_manager)
+      : device_permissions_manager_(device_permissions_manager),
+        observer_(this) {}
+  virtual ~FileThreadHelper() {}
+
+  void Start() {
+    DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+    UsbService* service = device::DeviceClient::Get()->GetUsbService();
+    if (service) {
+      observer_.Add(service);
+    }
+  }
+
+ private:
+  void OnDeviceRemoved(scoped_refptr<UsbDevice> device) override {
+    DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
+        base::Bind(&DevicePermissionsManager::OnDeviceRemoved,
+                   device_permissions_manager_, device));
+  }
+
+  base::WeakPtr<DevicePermissionsManager> device_permissions_manager_;
+  ScopedObserver<UsbService, UsbService::Observer> observer_;
+};
+
 // static
 DevicePermissionsManager* DevicePermissionsManager::Get(
     BrowserContext* context) {
   return DevicePermissionsManagerFactory::GetForBrowserContext(context);
 }
 
 scoped_ptr<DevicePermissions> DevicePermissionsManager::GetForExtension(
     const std::string& extension_id) {
   DCHECK(CalledOnValidThread());
   return make_scoped_ptr(new DevicePermissions(GetOrInsert(extension_id)));
@@ skipping 44 matching lines @@
   } 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;
 
     // 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);
+    if (!helper_) {
+      helper_ = new FileThreadHelper(weak_factory_.GetWeakPtr());
+      // base::Unretained is safe because any task to delete helper_ will be
+      // executed after this call.
+      BrowserThread::PostTask(
+          BrowserThread::FILE, FROM_HERE,
+          base::Bind(&FileThreadHelper::Start, base::Unretained(helper_)));
     }
   }
 }
 
 void DevicePermissionsManager::UpdateLastUsed(
     const std::string& extension_id,
     scoped_refptr<DevicePermissionEntry> entry) {
   DCHECK(CalledOnValidThread());
   entry->set_last_used(base::Time::Now());
   if (entry->IsPersistent()) {
@@ skipping 24 matching lines @@
   if (device_permissions) {
     extension_id_to_device_permissions_.erase(extension_id);
     delete device_permissions;
   }
 }
 
 DevicePermissionsManager::DevicePermissionsManager(
     content::BrowserContext* context)
     : context_(context),
       process_manager_observer_(this),
-      usb_service_observer_(this) {
+      helper_(nullptr),
+      weak_factory_(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;
     delete device_permissions;
   }
+  if (helper_) {
+    BrowserThread::DeleteSoon(BrowserThread::FILE, FROM_HERE, helper_);
+    helper_ = nullptr;
+  }
 }
 
 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 21 matching lines @@
     // suspended all ephemeral device permissions are cleared.
     for (const auto& map_entry : device_permissions->ephemeral_devices_) {
       device_permissions->entries_.erase(map_entry.second);
     }
     device_permissions->ephemeral_devices_.clear();
   }
 }
 
 void DevicePermissionsManager::OnDeviceRemoved(
     scoped_refptr<UsbDevice> device) {
+  DCHECK(CalledOnValidThread());
   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);
     if (device_entry != device_permissions->ephemeral_devices_.end()) {
       device_permissions->entries_.erase(device_entry->second);
       device_permissions->ephemeral_devices_.erase(device);
     }
@@ skipping 30 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