Add a service to track devices selected by the user.

apps/saved_devices_service.h

+// 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.
+
+#ifndef APPS_SAVED_DEVICES_SERVICE_H_
+#define APPS_SAVED_DEVICES_SERVICE_H_
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+
+#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/stl_util.h"
+#include "base/strings/string16.h"
+#include "base/threading/thread_checker.h"
+#include "components/keyed_service/core/keyed_service.h"
+#include "content/public/browser/notification_observer.h"
+#include "content/public/browser/notification_registrar.h"
+#include "device/usb/usb_device.h"
+
+class Profile;
+
+namespace base {
+class Value;
+}
+
+namespace extensions {
+class Extension;
+}
+
+namespace apps {
+
+// Represents a device that a user has given an app permission to access. It
+// will be persisted to disk (in the Preferences file) and so should remain
+// serializable.
+struct SavedDeviceEntry {
+  SavedDeviceEntry(uint16_t vendor_id,
+                   uint16_t product_id,
+                   const base::string16& serial_number);
+
+  base::Value* ToValue() const;
+
+  // The vendor ID of this device.
+  uint16_t vendor_id;
+
+  // The product ID of this device.
+  uint16_t product_id;
+
+  // The serial number (possibly alphanumeric) of this device.
+  base::string16 serial_number;
+};
+
+// Tracks the devices that apps have retained access to both while running and
+// when suspended.
+class SavedDevicesService : public KeyedService,
+                            public content::NotificationObserver {
+ public:
+  // Tracks the devices that a particular extension has retained access to.
+  // Unlike SavedDevicesService the functions of this class can be called from
+  // the FILE thread.
+  class SavedDevices : device::UsbDevice::Observer {
+   public:
+    bool IsRegistered(scoped_refptr<device::UsbDevice> device) const;
+    void RegisterDevice(scoped_refptr<device::UsbDevice> device,
+                        /* optional */ base::string16* serial_number);
+
+   private:
+    friend class SavedDevicesService;
+
+    SavedDevices(Profile* profile, const std::string& extension_id);
+    virtual ~SavedDevices();
+
+    // device::UsbDevice::Observer
+    virtual void OnDisconnect(scoped_refptr<device::UsbDevice> device) OVERRIDE;
+
+    Profile* profile_;
+    const std::string extension_id_;
+
+    // Devices with serial numbers are written to the prefs file.
+    std::vector<SavedDeviceEntry> persistent_devices_;
+    // Other devices are ephemeral devices and cleared when the extension host
+    // is destroyed.
+    std::set<scoped_refptr<device::UsbDevice> > ephemeral_devices_;
+
+    DISALLOW_COPY_AND_ASSIGN(SavedDevices);
+  };
+
+  explicit SavedDevicesService(Profile* profile);
+  virtual ~SavedDevicesService();
+
+  static SavedDevicesService* Get(Profile* profile);
+
+  // Returns the SavedDevices for |extension_id|, creating it if necessary.
+  SavedDevices* GetOrInsert(const std::string& extension_id);
+
+  std::vector<SavedDeviceEntry> GetAllDevices(
+      const std::string& extension_id) const;
+
+  // Clears the SavedDevices for |extension_id|.
+  void Clear(const std::string& extension_id);
+
+ private:
+  // content::NotificationObserver.
+  virtual void Observe(int type,
+                       const content::NotificationSource& source,
+                       const content::NotificationDetails& details) OVERRIDE;
+
+  // Returns the SavedDevices for |extension_id| or NULL if one does not exist.
+  SavedDevices* Get(const std::string& extension_id) const;
+
+  std::map<std::string, SavedDevices*> extension_id_to_saved_devices_;
+  Profile* profile_;
+  content::NotificationRegistrar registrar_;
+  base::ThreadChecker thread_checker_;
+
+  DISALLOW_COPY_AND_ASSIGN(SavedDevicesService);
+};
+
+}  // namespace apps
+
+#endif  // APPS_SAVED_DEVICES_SERVICE_H_