extensions/browser/api/device_permissions_manager.h

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef EXTENSIONS_DEVICE_PERMISSION_MANAGER_H_
   6 #define EXTENSIONS_DEVICE_PERMISSION_MANAGER_H_
   7
   8 #include <map>
   9 #include <set>
  10 #include <vector>
  11
  12 #include "base/gtest_prod_util.h"
  13 #include "base/macros.h"
  14 #include "base/memory/ref_counted.h"
  15 #include "base/memory/scoped_ptr.h"
  16 #include "base/scoped_observer.h"
  17 #include "base/strings/string16.h"
  18 #include "base/threading/thread_checker.h"
  19 #include "components/keyed_service/content/browser_context_keyed_service_factory.h"
  20 #include "components/keyed_service/core/keyed_service.h"
  21 #include "content/public/browser/browser_thread.h"
  22 #include "device/usb/usb_service.h"
  23 #include "extensions/browser/process_manager.h"
  24 #include "extensions/browser/process_manager_observer.h"
  25
  26 template <typename T>
  27 struct DefaultSingletonTraits;
  28
  29 namespace base {
  30 class Value;
  31 }
  32
  33 namespace content {
  34 class BrowserContext;
  35 }
  36
  37 namespace extensions {
  38
  39 // Stores information about a device saved with access granted.
  40 class DevicePermissionEntry
  41     : public base::RefCountedThreadSafe<DevicePermissionEntry> {
  42  public:
  43   DevicePermissionEntry(scoped_refptr<device::UsbDevice> device);
  44   DevicePermissionEntry(uint16_t vendor_id,
  45                         uint16_t product_id,
  46                         const base::string16& serial_number,
  47                         const base::string16& manufacturer_string,
  48                         const base::string16& product_string,
  49                         const base::Time& last_used);
  50
  51   // A persistent device is one that can be recognized when it is reconnected
  52   // and can therefore be remembered persistently by writing information about
  53   // it to ExtensionPrefs. Currently this means it has a serial number string.
  54   bool IsPersistent() const;
  55
  56   // Convert the device to a serializable value, returns a null pointer if the
  57   // entry is not persistent.
  58   scoped_ptr<base::Value> ToValue() const;
  59
  60   base::string16 GetPermissionMessageString() const;
  61
  62   uint16_t vendor_id() const { return vendor_id_; }
  63   uint16_t product_id() const { return product_id_; }
  64   const base::string16& serial_number() const { return serial_number_; }
  65   const base::Time& last_used() const { return last_used_; }
  66
  67   base::string16 GetManufacturer() const;
  68   base::string16 GetProduct() const;
  69
  70  private:
  71   friend class base::RefCountedThreadSafe<DevicePermissionEntry>;
  72   friend class DevicePermissionsManager;
  73
  74   ~DevicePermissionEntry();
  75
  76   void set_last_used(const base::Time& last_used) { last_used_ = last_used; }
  77
  78   // The USB device tracked by this entry, may be null if this entry was
  79   // restored from ExtensionPrefs.
  80   scoped_refptr<device::UsbDevice> device_;
  81   // The vendor ID of this device.
  82   uint16_t vendor_id_;
  83   // The product ID of this device.
  84   uint16_t product_id_;
  85   // The serial number (possibly alphanumeric) of this device.
  86   base::string16 serial_number_;
  87   // The manufacturer string read from the device (optional).
  88   base::string16 manufacturer_string_;
  89   // The product string read from the device (optional).
  90   base::string16 product_string_;
  91   // The last time this device was used by the extension.
  92   base::Time last_used_;
  93 };
  94
  95 // Stores device permissions associated with a particular extension.
  96 class DevicePermissions {
  97  public:
  98   virtual ~DevicePermissions();
  99
 100   // Attempts to find a permission entry matching the given device. The device
 101   // serial number is presented separately so that this function does not need
 102   // to call device->GetSerialNumber() which may not be possible on the
 103   // current thread.
 104   scoped_refptr<DevicePermissionEntry> FindEntry(
 105       scoped_refptr<device::UsbDevice> device) const;
 106
 107   const std::set<scoped_refptr<DevicePermissionEntry>>& entries() const {
 108     return entries_;
 109   }
 110
 111  private:
 112   friend class DevicePermissionsManager;
 113
 114   // Reads permissions out of ExtensionPrefs.
 115   DevicePermissions(content::BrowserContext* context,
 116                     const std::string& extension_id);
 117
 118   std::set<scoped_refptr<DevicePermissionEntry>> entries_;
 119   std::map<scoped_refptr<device::UsbDevice>,
 120            scoped_refptr<DevicePermissionEntry>> ephemeral_devices_;
 121
 122   DISALLOW_COPY_AND_ASSIGN(DevicePermissions);
 123 };
 124
 125 // Manages saved device permissions for all extensions.
 126 class DevicePermissionsManager : public KeyedService,
 127                                  public base::NonThreadSafe,
 128                                  public ProcessManagerObserver,
 129                                  public device::UsbService::Observer {
 130  public:
 131   static DevicePermissionsManager* Get(content::BrowserContext* context);
 132
 133   // The DevicePermissions object for a given extension.
 134   DevicePermissions* GetForExtension(const std::string& extension_id);
 135
 136   // Equivalent to calling GetForExtension and extracting the permission string
 137   // for each entry.
 138   std::vector<base::string16> GetPermissionMessageStrings(
 139       const std::string& extension_id) const;
 140
 141   void AllowUsbDevice(const std::string& extension_id,
 142                       scoped_refptr<device::UsbDevice> device);
 143
 144   // Updates the "last used" timestamp on the given device entry and writes it
 145   // out to ExtensionPrefs.
 146   void UpdateLastUsed(const std::string& extension_id,
 147                       scoped_refptr<DevicePermissionEntry> entry);
 148
 149   // Revokes permission for the extension to access the given device.
 150   void RemoveEntry(const std::string& extension_id,
 151                    scoped_refptr<DevicePermissionEntry> entry);
 152
 153   // Revokes permission for the extension to access all allowed devices.
 154   void Clear(const std::string& extension_id);
 155
 156  private:
 157
 158   friend class DevicePermissionsManagerFactory;
 159   FRIEND_TEST_ALL_PREFIXES(DevicePermissionsManagerTest, SuspendExtension);
 160
 161   DevicePermissionsManager(content::BrowserContext* context);
 162   ~DevicePermissionsManager() override;
 163
 164   DevicePermissions* GetInternal(const std::string& extension_id) const;
 165
 166   // ProcessManagerObserver implementation
 167   void OnBackgroundHostClose(const std::string& extension_id) override;
 168
 169   // UsbService::Observer implementation
 170   void OnDeviceRemovedCleanup(scoped_refptr<device::UsbDevice> device) override;
 171
 172   content::BrowserContext* context_;
 173   std::map<std::string, DevicePermissions*> extension_id_to_device_permissions_;
 174   ScopedObserver<ProcessManager, ProcessManagerObserver>
 175       process_manager_observer_;
 176   ScopedObserver<device::UsbService, device::UsbService::Observer>
 177       usb_service_observer_;
 178
 179   DISALLOW_COPY_AND_ASSIGN(DevicePermissionsManager);
 180 };
 181
 182 class DevicePermissionsManagerFactory
 183     : public BrowserContextKeyedServiceFactory {
 184  public:
 185   static DevicePermissionsManager* GetForBrowserContext(
 186       content::BrowserContext* context);
 187   static DevicePermissionsManagerFactory* GetInstance();
 188
 189  private:
 190   friend struct DefaultSingletonTraits<DevicePermissionsManagerFactory>;
 191
 192   DevicePermissionsManagerFactory();
 193   ~DevicePermissionsManagerFactory() override;
 194
 195   // BrowserContextKeyedServiceFactory implementation
 196   KeyedService* BuildServiceInstanceFor(
 197       content::BrowserContext* context) const override;
 198   content::BrowserContext* GetBrowserContextToUse(
 199       content::BrowserContext* context) const override;
 200
 201   DISALLOW_COPY_AND_ASSIGN(DevicePermissionsManagerFactory);
 202 };
 203
 204 }  // namespace extensions
 205
 206 #endif  // EXTENSIONS_DEVICE_PERMISSION_MANAGER_H_