Add a kill switch for all of Web Bluetooth.

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.
@@ skipping 1201 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;
   }
 
-  if (!GetContentClient()->browser()->AllowWebBluetooth(
-          web_contents->GetBrowserContext(), requesting_origin,
-          embedding_origin)) {
-    RecordRequestDeviceOutcome(
-        UMARequestDeviceOutcome::BLUETOOTH_CHOOSER_GLOBALLY_DISABLED);
-    Send(new BluetoothMsg_RequestDeviceError(
-        thread_id, request_id, WebBluetoothError::ChooserDisabled));
-    return;
+  switch (GetContentClient()->browser()->AllowWebBluetooth(
+      web_contents->GetBrowserContext(), requesting_origin, embedding_origin)) {
+    case ContentBrowserClient::AllowWebBluetoothResult::BLOCK_POLICY: {
+      RecordRequestDeviceOutcome(
+          UMARequestDeviceOutcome::BLUETOOTH_CHOOSER_POLICY_DISABLED);
+      Send(new BluetoothMsg_RequestDeviceError(
+          thread_id, request_id,
+          WebBluetoothError::ChooserNotShown_APILocallyDisabled));
+      return;
+    }
+    case ContentBrowserClient::AllowWebBluetoothResult::
+        BLOCK_GLOBALLY_DISABLED: {
+      // Log to the developer console.
+      web_contents->GetMainFrame()->AddMessageToConsole(
+          content::CONSOLE_MESSAGE_LEVEL_LOG,
+          "Bluetooth permission has been blocked.");
+      // Block requests.
+      RecordRequestDeviceOutcome(
+          UMARequestDeviceOutcome::BLUETOOTH_GLOBALLY_DISABLED);
+      Send(new BluetoothMsg_RequestDeviceError(
+          thread_id, request_id,
+          WebBluetoothError::ChooserNotShown_APIGloballyDisabled));
+      return;
+    }
+    case ContentBrowserClient::AllowWebBluetoothResult::ALLOW:
+      break;
   }
 
   // Create storage for the information that backs the chooser, and show the
   // chooser.
   RequestDeviceSession* const session = new RequestDeviceSession(
       thread_id, request_id, frame_routing_id, requesting_origin, filters,
       optional_services_blacklist_filtered);
   int chooser_id = request_device_sessions_.Add(session);
 
   BluetoothChooser::EventHandler chooser_event_handler =
@@ skipping 132 matching lines @@
         WebBluetoothError::ChooserCancelled));
     request_device_sessions_.Remove(chooser_id);
     return;
   }
   if (event == BluetoothChooser::Event::DENIED_PERMISSION) {
     RecordRequestDeviceOutcome(
         UMARequestDeviceOutcome::BLUETOOTH_CHOOSER_DENIED_PERMISSION);
     VLOG(1) << "Bluetooth chooser denied permission";
     Send(new BluetoothMsg_RequestDeviceError(
         session->thread_id, session->request_id,
-        WebBluetoothError::ChooserDeniedPermission));
+        WebBluetoothError::ChooserNotShown_BrowserDeniedPermissionToScan));

[ortuno, 2016/03/30 19:19:46]

I think you might have meant to change the error in line 1274. In this case we
do show the chooser; that's where the user can press the "Update Permission"
option and that will request for the permission.

[Jeffrey Yasskin, 2016/03/30 19:31:24]

Line 1274 is just the chooser event saying that it can't ask for permission to
scan. That event comes down here and closes the chooser with a message to the
website that it can't ask for permission anymore.

It's true that we might have shown the chooser before being denied permission to
ask again, but on future calls we won't show it, since we can't ask, and the
website instead needs to guide users to re-enable the permission.

When we simply don't have permission but can ask, we shouldn't return this
error. Let me know if you see a path where we would.

[ortuno, 2016/03/30 19:41:51]

Ah you're totally right.

     request_device_sessions_.Remove(chooser_id);
     return;
   }
   DCHECK_EQ(static_cast<int>(event),
             static_cast<int>(BluetoothChooser::Event::SELECTED));
 
   // |device_id| is the Device Address that RequestDeviceSession passed to
   // chooser->AddDevice().
   const device::BluetoothDevice* const device = adapter_->GetDevice(device_id);
   if (device == nullptr) {
@@ skipping 271 matching lines @@
 
 bool BluetoothDispatcherHost::CanFrameAccessCharacteristicInstance(
     int frame_routing_id,
     const std::string& characteristic_instance_id) {
   return QueryCacheForCharacteristic(GetOrigin(frame_routing_id),
                                      characteristic_instance_id)
              .outcome != CacheQueryOutcome::BAD_RENDERER;
 }
 
 }  // namespace content