Store USB device permissions in website settings.

chrome/browser/usb/usb_chooser_permission_context.h

Index: chrome/browser/usb/usb_chooser_permission_context.h
diff --git a/chrome/browser/usb/usb_chooser_permission_context.h b/chrome/browser/usb/usb_chooser_permission_context.h
new file mode 100644
index 0000000000000000000000000000000000000000..d583cf0303baa2e629acd00dc37bbe83f59598af
--- /dev/null
+++ b/chrome/browser/usb/usb_chooser_permission_context.h
@@ -0,0 +1,48 @@
+// Copyright 2015 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 CHROME_BROWSER_USB_USB_CHOOSER_PERMISSION_CONTEXT_H_
+#define CHROME_BROWSER_USB_USB_CHOOSER_PERMISSION_CONTEXT_H_
+
+#include <map>
+#include <set>
+#include <string>
+
+#include "base/scoped_observer.h"
+#include "chrome/browser/permissions/chooser_permission_context_base.h"
+#include "device/usb/usb_service.h"
+
+class UsbChooserPermissionContext : public ChooserPermissionContextBase,

[raymes, 2015/10/14 02:07:04]

I'm not sure inheritance is actually the right choice here, composition would be
better. It's not particularly useful for this thing to "be a" ChooserContextBase
(because all of them will have different APIs) instead it just "uses"
ChooserContextBase. In other words, this thing should contain a
ChooserContextBase (which I guess would have a different name). You could pass
IsValidObject into ChooserContextBase as a base::Callback or else have a
delegate interface which you pass in. 

[Reilly Grant (use Gerrit), 2015/10/22 00:57:03]

The idea of ChooserContextBase, like PermissionContextBase, is that the UI code
should be able to operate on one without knowing the details of what particular
kind of choosen it objects it stores.

[raymes, 2015/10/29 06:14:41]

I don't think it's much like PermissionContextBase. The analogy would be that we
expose GrantObjectPermission/RevokeObjectPermission/etc in ChooserContext and
each subclass may provide specific implementations. But we have something
different here. Instead the subclass is providing a specific API
GrantDevicePermission/RevokeDevicePermission/etc and those specific APIs use the
superclass functions. 

Why not hoist out the logic for the specific API and make it a wrapper around
ChooserContext? Inheritance doesn't buy much here.

Also notice that PermissionContext isn't meant to contain any UI logic
(unfortunately it does contain some to show a permission bubble but the desire
is to separate this out). But the logic for displaying different strings for
permissions and so on isn't in PermissionContext, but in other UI-specific
classes (see e.g. PermissionBubbleRequestImpl). We wouldn't want to add a new
virtual method to PermissionContext which was GetDisplayString. I would just
leave GetStringToDisplayForObject out of this CL for now so we can land this
more quickly and discuss that separately.

[raymes, 2015/10/29 06:31:26]

With that said, if there were other (non-UI specifc) virtual methods that were
going to be added, I could see this design being reasonable, and I don't want to
hold this up too long :)

[Reilly Grant (use Gerrit), 2015/10/29 20:59:59]

In working on the UI I've added more (non-UI) virtual methods.

+                                    public device::UsbService::Observer {
+ public:
+  explicit UsbChooserPermissionContext(Profile* profile);
+  ~UsbChooserPermissionContext() override;
+
+  void GrantDevicePermission(const GURL& requesting_origin,
+                             const GURL& embedding_origin,
+                             const std::string& guid);

[raymes, 2015/10/14 02:07:04]

Could you please document what the GUID is?

[Reilly Grant (use Gerrit), 2015/10/22 00:57:03]

Done.

+  void RevokeDevicePermission(const GURL& requesting_origin,
+                              const GURL& embedding_origin,
+                              const std::string& guid);
+  bool HasDevicePermission(const GURL& requesting_origin,
+                           const GURL& embedding_origin,
+                           const std::string& guid);
+
+ private:
+  // ChooserPermissionContextBase implementation.
+  bool IsValidObject(const base::DictionaryValue& object) override;
+  std::string GetStringToDisplayForObject(
+      const base::DictionaryValue& object) override;
+
+  // device::UsbService::Observer implementation.
+  void OnDeviceRemoved(scoped_refptr<device::UsbDevice> device) override;
+
+  std::map<GURL, std::set<std::string>> ephemeral_devices_;
+  device::UsbService* usb_service_;
+  ScopedObserver<device::UsbService, device::UsbService::Observer> observer_;
+
+  DISALLOW_COPY_AND_ASSIGN(UsbChooserPermissionContext);
+};
+
+#endif  // CHROME_BROWSER_USB_USB_CHOOSER_PERMISSION_CONTEXT_H_