Move device/usb classes from the FILE thread to UI thread.

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"
@@ skipping 215 matching lines @@
     result.insert(new DevicePermissionEntry(vendor_id, product_id,
                                             serial_number, manufacturer_string,
                                             product_string, last_used));
   }
   return result;
 }
 
 }  // namespace
 
 DevicePermissionEntry::DevicePermissionEntry(
-    scoped_refptr<device::UsbDevice> device,
-    const base::string16& serial_number,
-    const base::string16& manufacturer_string,
-    const base::string16& product_string)
+    scoped_refptr<device::UsbDevice> device)
     : device_(device),
       vendor_id_(device->vendor_id()),
       product_id_(device->product_id()),
-      serial_number_(serial_number),
-      manufacturer_string_(manufacturer_string),
-      product_string_(product_string) {
+      serial_number_(device->serial_number()),
+      manufacturer_string_(device->manufacturer_string()),
+      product_string_(device->product_string()) {
 }
 
 DevicePermissionEntry::DevicePermissionEntry(
     uint16_t vendor_id,
     uint16_t product_id,
     const base::string16& serial_number,
     const base::string16& manufacturer_string,
     const base::string16& product_string,
     const base::Time& last_used)
     : vendor_id_(vendor_id),
@@ skipping 78 matching lines @@
     }
   } else {
     return product_string_;
   }
 }
 
 DevicePermissions::~DevicePermissions() {
 }
 
 scoped_refptr<DevicePermissionEntry> DevicePermissions::FindEntry(
-    scoped_refptr<device::UsbDevice> device,
-    const base::string16& serial_number) const {
+    scoped_refptr<device::UsbDevice> device) const {
   const auto& ephemeral_device_entry = ephemeral_devices_.find(device);
   if (ephemeral_device_entry != ephemeral_devices_.end()) {
     return ephemeral_device_entry->second;
   }
 
-  if (serial_number.empty()) {
+  if (device->serial_number().empty()) {
     return nullptr;
   }
 
   for (const auto& entry : entries_) {
     if (!entry->IsPersistent()) {
       continue;
     }
     if (entry->vendor_id() != device->vendor_id()) {
       continue;
     }
     if (entry->product_id() != device->product_id()) {
       continue;
     }
-    if (entry->serial_number() != serial_number) {
+    if (entry->serial_number() != device->serial_number()) {
       continue;
     }
     return entry;
   }
   return nullptr;
 }
 
 DevicePermissions::DevicePermissions(BrowserContext* context,
                                      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 OnDeviceRemovedCleanup(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(
+DevicePermissions* DevicePermissionsManager::GetForExtension(
     const std::string& extension_id) {
   DCHECK(CalledOnValidThread());
-  return make_scoped_ptr(new DevicePermissions(GetOrInsert(extension_id)));
+  DevicePermissions* device_permissions = Get(extension_id);
+  if (!device_permissions) {
+    device_permissions = new DevicePermissions(context_, extension_id);
+    extension_id_to_device_permissions_[extension_id] = device_permissions;
+  }
+
+  return device_permissions;
 }
 
 std::vector<base::string16>
 DevicePermissionsManager::GetPermissionMessageStrings(
     const std::string& extension_id) const {
   DCHECK(CalledOnValidThread());
   std::vector<base::string16> messages;
   const DevicePermissions* device_permissions = Get(extension_id);
   if (device_permissions) {
     for (const scoped_refptr<DevicePermissionEntry>& entry :
          device_permissions->entries()) {
       messages.push_back(entry->GetPermissionMessageString());
     }
   }
   return messages;
 }
 
 void DevicePermissionsManager::AllowUsbDevice(
     const std::string& extension_id,
-    scoped_refptr<device::UsbDevice> device,
-    const base::string16& product_string,
-    const base::string16& manufacturer_string,
-    const base::string16& serial_number) {
+    scoped_refptr<device::UsbDevice> device) {
   DCHECK(CalledOnValidThread());
-  DevicePermissions* device_permissions = GetOrInsert(extension_id);
+  DevicePermissions* device_permissions = GetForExtension(extension_id);
 
-  scoped_refptr<DevicePermissionEntry> device_entry(new DevicePermissionEntry(
-      device, serial_number, manufacturer_string, product_string));
+  scoped_refptr<DevicePermissionEntry> device_entry(
+      new DevicePermissionEntry(device));
 
   if (device_entry->IsPersistent()) {
     for (const auto& entry : device_permissions->entries()) {
       if (entry->vendor_id() != device_entry->vendor_id()) {
         continue;
       }
       if (entry->product_id() != device_entry->product_id()) {
         continue;
       }
       if (entry->serial_number() == device_entry->serial_number()) {
         return;
       }
     }
 
     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;
 
     // 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).
-    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_)));
+    UsbService* usb_service = device::DeviceClient::Get()->GetUsbService();
+    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()) {
@@ 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),
-      helper_(nullptr),
-      weak_factory_(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;
     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;
   }
 
   return NULL;
 }
 
-DevicePermissions* DevicePermissionsManager::GetOrInsert(
-    const std::string& extension_id) {
-  DevicePermissions* device_permissions = Get(extension_id);
-  if (!device_permissions) {
-    device_permissions = new DevicePermissions(context_, extension_id);
-    extension_id_to_device_permissions_[extension_id] = device_permissions;
-  }
-
-  return device_permissions;
-}
-
 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_) {
       device_permissions->entries_.erase(map_entry.second);
     }
     device_permissions->ephemeral_devices_.clear();
   }
 }
 
-void DevicePermissionsManager::OnDeviceRemoved(
+void DevicePermissionsManager::OnDeviceRemovedCleanup(
     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);
@@ skipping 32 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