Store Bluetooth permissions in website settings

content/browser/bluetooth/bluetooth_dispatcher_host.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.
 
 // ID Not In Map Note:
 // A service, characteristic, or descriptor ID not in the corresponding
 // BluetoothDispatcherHost map [service_to_device_, characteristic_to_service_,
 // descriptor_to_characteristic_] implies a hostile renderer because a renderer
 // obtains the corresponding ID from this class and it will be added to the map
 // at that time.
 
 #include "content/browser/bluetooth/bluetooth_dispatcher_host.h"
 
 #include <stddef.h>
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "content/browser/bad_message.h"
 #include "content/browser/bluetooth/bluetooth_metrics.h"
 #include "content/browser/bluetooth/first_device_bluetooth_chooser.h"
 #include "content/browser/frame_host/render_frame_host_impl.h"
 #include "content/common/bluetooth/bluetooth_messages.h"
+#include "content/public/browser/browser_context.h"
+#include "content/public/browser/chooser_permission_manager.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "device/bluetooth/bluetooth_adapter.h"
 #include "device/bluetooth/bluetooth_adapter_factory.h"
 #include "device/bluetooth/bluetooth_device.h"
 #include "device/bluetooth/bluetooth_discovery_session.h"
 #include "device/bluetooth/bluetooth_gatt_characteristic.h"
 #include "device/bluetooth/bluetooth_gatt_service.h"
 
 using blink::WebBluetoothError;
@@ skipping 296 matching lines @@
   // Clear adapter, releasing observer references.
   set_adapter(scoped_refptr<device::BluetoothAdapter>());
 }
 
 // Stores information associated with an in-progress requestDevice call. This
 // will include the state of the active chooser dialog in a future patch.
 struct BluetoothDispatcherHost::RequestDeviceSession {
  public:
   RequestDeviceSession(int thread_id,
                        int request_id,
+                       ChooserPermissionManager* chooser_permission_manager,
                        url::Origin origin,
+                       url::Origin embedding_origin,
                        const std::vector<BluetoothScanFilter>& filters,
                        const std::vector<BluetoothUUID>& optional_services)
       : thread_id(thread_id),
         request_id(request_id),
+        chooser_permission_manager(chooser_permission_manager),
         origin(origin),
+        embedding_origin(embedding_origin),
         filters(filters),
         optional_services(optional_services) {}
 
   void AddFilteredDevice(const device::BluetoothDevice& device) {
     if (chooser && MatchesFilters(device, filters)) {
       chooser->AddDevice(device.GetAddress(), device.GetName());
     }
   }
 
   scoped_ptr<device::BluetoothDiscoveryFilter> ComputeScanFilter() const {
     std::set<BluetoothUUID> services;
     for (const BluetoothScanFilter& filter : filters) {
       services.insert(filter.services.begin(), filter.services.end());
     }
     scoped_ptr<device::BluetoothDiscoveryFilter> discovery_filter(
         new device::BluetoothDiscoveryFilter(
             device::BluetoothDiscoveryFilter::TRANSPORT_DUAL));
     for (const BluetoothUUID& service : services) {
       discovery_filter->AddUUID(service);
     }
     return discovery_filter;
   }
 
   const int thread_id;
   const int request_id;
+  ChooserPermissionManager* chooser_permission_manager;
   const url::Origin origin;
+  const url::Origin embedding_origin;
   const std::vector<BluetoothScanFilter> filters;
   const std::vector<BluetoothUUID> optional_services;
   scoped_ptr<BluetoothChooser> chooser;
   scoped_ptr<device::BluetoothDiscoverySession> discovery_session;
 };
 
 struct BluetoothDispatcherHost::CacheQueryResult {
   CacheQueryResult()
       : device(nullptr),
         service(nullptr),
@@ skipping 266 matching lines @@
     return;
   }
 
   // The renderer should never send empty filters.
   if (HasEmptyOrInvalidFilter(filters)) {
     bad_message::ReceivedBadMessage(this,
                                     bad_message::BDH_EMPTY_OR_INVALID_FILTERS);
     return;
   }
 
+  WebContents* web_contents =
+      WebContents::FromRenderFrameHost(render_frame_host);
+
+  url::Origin embedding_origin;
+  ChooserPermissionManager* chooser_permission_manager = nullptr;
+
+  if (web_contents) {
+    embedding_origin = web_contents->GetMainFrame()->GetLastCommittedOrigin();
+    chooser_permission_manager =
+        web_contents->GetBrowserContext()->GetChooserPermissionManager();
+  }
+
   // Create storage for the information that backs the chooser, and show the
   // chooser.
   RequestDeviceSession* const session = new RequestDeviceSession(
-      thread_id, request_id, render_frame_host->GetLastCommittedOrigin(),
-      filters, optional_services);
+      thread_id, request_id, chooser_permission_manager,
+      render_frame_host->GetLastCommittedOrigin(), embedding_origin, filters,
+      optional_services);
   int chooser_id = request_device_sessions_.Add(session);
 
   BluetoothChooser::EventHandler chooser_event_handler =
       base::Bind(&BluetoothDispatcherHost::OnBluetoothChooserEvent,
                  weak_ptr_on_ui_thread_, chooser_id);
-  if (WebContents* web_contents =
-          WebContents::FromRenderFrameHost(render_frame_host)) {
+  if (web_contents) {
     if (WebContentsDelegate* delegate = web_contents->GetDelegate()) {
       session->chooser = delegate->RunBluetoothChooser(
           web_contents, chooser_event_handler,
           // TODO(ortuno): Replace with GetLastCommittedOrigin.
           // http://crbug.com/577451
           render_frame_host->GetLastCommittedURL().GetOrigin());
     }
   }
   if (!session->chooser) {
     LOG(WARNING)
@@ skipping 503 matching lines @@
         WebBluetoothError::ChosenDeviceVanished));
     request_device_sessions_.Remove(chooser_id);
     return;
   }
 
   VLOG(1) << "Device: " << device->GetName();
   VLOG(1) << "UUIDs: ";
   for (BluetoothUUID uuid : device->GetUUIDs())
     VLOG(1) << "\t" << uuid.canonical_value();
 
+  session->chooser_permission_manager->GrantPermission(
+      session->origin, session->embedding_origin, device_id);
+
   const std::string& device_id_for_origin = allowed_devices_map_.AddDevice(
       session->origin, device->GetAddress(), session->filters,
       session->optional_services);
 
   content::BluetoothDevice device_ipc(
       device_id_for_origin,  // id
       device->GetName(),     // name
       content::BluetoothDevice::ValidatePower(
           device->GetInquiryTxPower()),  // tx_power
       content::BluetoothDevice::ValidatePower(
@@ skipping 252 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   NOTIMPLEMENTED();
 }
 
 void BluetoothDispatcherHost::ShowNeedLocationLink() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   NOTIMPLEMENTED();
 }
 
 }  // namespace content