bluetooth: Move requestDevice to mojo

content/browser/bluetooth/web_bluetooth_service_impl.cc

 // Copyright 2016 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_id_to_device_address_,
+// WebBluetoothServiceImpl map [service_id_to_device_address_,
 // characteristic_id_to_service_id_, 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/web_bluetooth_service_impl.h"
 
 #include <algorithm>
 
+#include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
+#include "content/browser/bluetooth/bluetooth_adapter_factory_wrapper.h"
 #include "content/browser/bluetooth/bluetooth_blacklist.h"
-#include "content/browser/bluetooth/bluetooth_dispatcher_host.h"
+#include "content/browser/bluetooth/bluetooth_device_provider.h"
+#include "content/browser/bluetooth/bluetooth_metrics.h"
 #include "content/browser/bluetooth/frame_connected_bluetooth_devices.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
+#include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_handle.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/web_contents.h"
 #include "device/bluetooth/bluetooth_remote_gatt_characteristic.h"
 
 namespace content {
 
 namespace {
 
 blink::mojom::WebBluetoothError TranslateConnectErrorAndRecord(
@@ skipping 132 matching lines @@
 WebBluetoothServiceImpl::WebBluetoothServiceImpl(
     RenderFrameHost* render_frame_host,
     blink::mojom::WebBluetoothServiceRequest request)
     : WebContentsObserver(WebContents::FromRenderFrameHost(render_frame_host)),
       connected_devices_(new FrameConnectedBluetoothDevices(render_frame_host)),
       render_frame_host_(render_frame_host),
       binding_(this, std::move(request)),
       weak_ptr_factory_(this) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   CHECK(web_contents());
-
-  GetBluetoothDispatcherHost()->AddAdapterObserver(this);
 }
 
 WebBluetoothServiceImpl::~WebBluetoothServiceImpl() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  GetBluetoothDispatcherHost()->RemoveAdapterObserver(this);
+  GetBluetoothAdapterFactoryWrapper()->ReleaseAdapter(this);
 }
 
 void WebBluetoothServiceImpl::SetClientConnectionErrorHandler(
     base::Closure closure) {
   binding_.set_connection_error_handler(closure);
 }
 
 void WebBluetoothServiceImpl::DidFinishNavigation(
     NavigationHandle* navigation_handle) {
   if (navigation_handle->HasCommitted() &&
       navigation_handle->GetRenderFrameHost() == render_frame_host_ &&
       !navigation_handle->IsSamePage()) {
     ClearState();
   }
 }
 
-void WebBluetoothServiceImpl::AdapterPresentChanged(
+void WebBluetoothServiceImpl::AdapterPoweredChanged(
     device::BluetoothAdapter* adapter,
-    bool present) {
-  if (!present) {
-    ClearState();

[Jeffrey Yasskin, 2016/05/13 04:41:59]

Is removing this going to bring https://crbug.com/604318 back?

[ortuno, 2016/05/13 20:11:18]

Noup! That bug happened because the adapter in BluetoothDispatcherHost was
destroyed before notify sessions in WebBluetoothServiceImpl were destroyed. Now
that we destroy the adapter after we stop notify session in ClearState(), we
shouldn't see that error. Now that I think about it we do destroy the adapter
before we stop notify session in the destructor. Fixed that.

+    bool powered) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  if (device_provider_.get()) {
+    device_provider_->AdapterPoweredChanged(powered);
   }
 }
 
+void WebBluetoothServiceImpl::DeviceAdded(device::BluetoothAdapter* adapter,
+                                          device::BluetoothDevice* device) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  if (device_provider_.get()) {
+    VLOG(1) << "Adding device to device provider: " << device->GetAddress();
+    device_provider_->AddFilteredDevice(*device);
+  }
+}
+
 void WebBluetoothServiceImpl::DeviceChanged(device::BluetoothAdapter* adapter,
                                             device::BluetoothDevice* device) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!device->IsGattConnected() || !device->IsConnected()) {
     std::string device_id =
         connected_devices_->CloseConnectionToDeviceWithAddress(
             device->GetAddress());
     if (!device_id.empty()) {
       // TODO(ortuno): Send event to client.
       // http://crbug.com/581855
@@ skipping 54 matching lines @@
         characteristic_instance_id, mojo::Array<uint8_t>(std::move(value)));
   }
 }
 
 void WebBluetoothServiceImpl::SetClient(
     blink::mojom::WebBluetoothServiceClientAssociatedPtrInfo client) {
   DCHECK(!client_.get());
   client_.Bind(std::move(client));
 }
 
+void WebBluetoothServiceImpl::RequestDevice(
+    blink::mojom::WebBluetoothRequestDeviceOptionsPtr options,
+    const RequestDeviceCallback& callback) {
+  RecordWebBluetoothFunctionCall(UMAWebBluetoothFunction::REQUEST_DEVICE);
+  RecordRequestDeviceOptions(options);
+
+  if (!GetBluetoothAdapterFactoryWrapper()->GetAdapter(this)) {
+    if (GetBluetoothAdapterFactoryWrapper()->IsBluetoothAdapterAvailable()) {
+      GetBluetoothAdapterFactoryWrapper()->AcquireAdapter(
+          this, base::Bind(&WebBluetoothServiceImpl::RequestDeviceImpl,
+                           weak_ptr_factory_.GetWeakPtr(),
+                           base::Passed(std::move(options)), callback));
+      return;
+    }
+    RecordRequestDeviceOutcome(UMARequestDeviceOutcome::NO_BLUETOOTH_ADAPTER);
+    callback.Run(blink::mojom::WebBluetoothError::NO_BLUETOOTH_ADAPTER,
+                 nullptr /* device */);
+    return;
+  }
+  RequestDeviceImpl(std::move(options), callback);
+}
+
 void WebBluetoothServiceImpl::RemoteServerConnect(
     const mojo::String& device_id,
     const RemoteServerConnectCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   RecordWebBluetoothFunctionCall(UMAWebBluetoothFunction::CONNECT_GATT);
 
-  const CacheQueryResult query_result =
-      GetBluetoothDispatcherHost()->QueryCacheForDevice(GetOrigin(), device_id);
+  const CacheQueryResult query_result = QueryCacheForDevice(device_id);
 
   if (query_result.outcome != CacheQueryOutcome::SUCCESS) {
     RecordConnectGATTOutcome(query_result.outcome);
     callback.Run(query_result.GetWebError());
     return;
   }
 
   if (connected_devices_->IsConnectedToDeviceWithId(device_id)) {
     VLOG(1) << "Already connected.";
     callback.Run(blink::mojom::WebBluetoothError::SUCCESS);
@@ skipping 32 matching lines @@
 }
 
 void WebBluetoothServiceImpl::RemoteServerGetPrimaryService(
     const mojo::String& device_id,
     const mojo::String& service_uuid,
     const RemoteServerGetPrimaryServiceCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   RecordWebBluetoothFunctionCall(UMAWebBluetoothFunction::GET_PRIMARY_SERVICE);
   RecordGetPrimaryServiceService(device::BluetoothUUID(service_uuid));
 
-  if (!GetBluetoothDispatcherHost()
-           ->allowed_devices_map_.IsOriginAllowedToAccessService(
-               GetOrigin(), device_id, service_uuid)) {
+  if (!allowed_devices_map_.IsOriginAllowedToAccessService(
+          GetOrigin(), device_id, service_uuid)) {
     callback.Run(blink::mojom::WebBluetoothError::NOT_ALLOWED_TO_ACCESS_SERVICE,
                  nullptr /* service */);
     return;
   }
 
-  const CacheQueryResult query_result =
-      GetBluetoothDispatcherHost()->QueryCacheForDevice(GetOrigin(), device_id);
+  const CacheQueryResult query_result = QueryCacheForDevice(device_id);
 
   if (query_result.outcome == CacheQueryOutcome::BAD_RENDERER) {
     binding_.Close();
     return;
   }
 
   if (query_result.outcome != CacheQueryOutcome::SUCCESS) {
     RecordGetPrimaryServiceOutcome(query_result.outcome);
     callback.Run(query_result.GetWebError(), nullptr /* service */);
     return;
@@ skipping 248 matching lines @@
     // If the frame hasn't subscribed to notifications before we just
     // run the callback.
     callback.Run();
     return;
   }
   notify_session_iter->second->Stop(base::Bind(
       &WebBluetoothServiceImpl::OnStopNotifySessionComplete,
       weak_ptr_factory_.GetWeakPtr(), characteristic_instance_id, callback));
 }
 
+void WebBluetoothServiceImpl::RequestDeviceImpl(
+    blink::mojom::WebBluetoothRequestDeviceOptionsPtr options,
+    const RequestDeviceCallback& callback) {
+  // requestDevice() can only be called when processing a user-gesture and
+  // any user gesture outside of a chooser should close the chooser so we should
+  // never get a request with an open chooser.
+  CHECK(!device_provider_.get());
+
+  device_provider_.reset(new BluetoothDeviceProvider(
+      render_frame_host_, GetBluetoothAdapterFactoryWrapper()->GetAdapter(this),
+      GetBluetoothAdapterFactoryWrapper()->GetScanDuration()));
+
+  device_provider_->GetDevice(
+      options->Clone(), base::Bind(&WebBluetoothServiceImpl::OnGetDeviceSuccess,
+                                   weak_ptr_factory_.GetWeakPtr(),
+                                   base::Passed(options->Clone()), callback),

[Jeffrey Yasskin, 2016/05/13 04:41:59]

Instead of cloning the options, would it make sense to have GetDevice() pass
them on to the success callback?

[ortuno, 2016/05/13 20:11:18]

Done.

+      base::Bind(&WebBluetoothServiceImpl::OnGetDeviceFailed,
+                 weak_ptr_factory_.GetWeakPtr(), callback));
+}
+
 void WebBluetoothServiceImpl::RemoteServerGetPrimaryServiceImpl(
     const std::string& service_uuid,
     const RemoteServerGetPrimaryServiceCallback& callback,
     device::BluetoothDevice* device) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(device->IsGattServicesDiscoveryComplete());
 
   std::vector<device::BluetoothRemoteGattService*> services =
       GetPrimaryServicesByUUID(device, service_uuid);
 
@@ skipping 15 matching lines @@
 
   RecordGetPrimaryServiceOutcome(UMAGetPrimaryServiceOutcome::SUCCESS);
   blink::mojom::WebBluetoothRemoteGATTServicePtr service_ptr =
       blink::mojom::WebBluetoothRemoteGATTService::New();
   service_ptr->instance_id = services[0]->GetIdentifier();
   service_ptr->uuid = services[0]->GetUUID().canonical_value();
   callback.Run(blink::mojom::WebBluetoothError::SUCCESS,
                std::move(service_ptr));
 }
 
+void WebBluetoothServiceImpl::OnGetDeviceSuccess(
+    blink::mojom::WebBluetoothRequestDeviceOptionsPtr options,
+    const RequestDeviceCallback& callback,
+    const std::string& device_address) {
+  blink::mojom::WebBluetoothDevicePtr device_ptr =

[Jeffrey Yasskin, 2016/05/13 04:41:59]

I'd probably create this just before it's used for the first time, so it's
clearer that it doesn't accumulate data through the whole function.

[ortuno, 2016/05/13 20:11:18]

Done.

+      blink::mojom::WebBluetoothDevice::New();
+
+  const device::BluetoothDevice* const device =
+      GetBluetoothAdapterFactoryWrapper()->GetAdapter(this)->GetDevice(

[Jeffrey Yasskin, 2016/05/13 04:41:59]

Consider wrapping the "GetBluetoothAdapterFactoryWrapper()->GetAdapter(this)"
into a "GetAdapter()" member function.

[ortuno, 2016/05/13 20:11:18]

Done.

+          device_address);
+  if (device == nullptr) {
+    VLOG(1) << "Device " << device_address << " no longer in adapter";
+    RecordRequestDeviceOutcome(UMARequestDeviceOutcome::CHOSEN_DEVICE_VANISHED);
+    callback.Run(blink::mojom::WebBluetoothError::CHOSEN_DEVICE_VANISHED,
+                 nullptr /* device */);
+    device_provider_.reset();

[Jeffrey Yasskin, 2016/05/13 04:41:59]

Can you reset this at the beginning of the function so we can't accidentally
return without destroying it?

[ortuno, 2016/05/13 20:11:18]

Done.

+    return;
+  }
+
+  const std::string device_id_for_origin =
+      allowed_devices_map_.AddDevice(GetOrigin(), device_address, options);
+
+  VLOG(1) << "Device: " << device->GetName();
+  VLOG(1) << "UUIDs: ";
+
+  mojo::Array<mojo::String> filtered_uuids;
+  for (const device::BluetoothUUID& uuid : device->GetUUIDs()) {
+    if (allowed_devices_map_.IsOriginAllowedToAccessService(
+            GetOrigin(), device_id_for_origin, uuid.canonical_value())) {
+      VLOG(1) << "\t Allowed: " << uuid.canonical_value();
+      filtered_uuids.push_back(uuid.canonical_value());
+    } else {
+      VLOG(1) << "\t Not Allowed: " << uuid.canonical_value();
+    }
+  }
+
+  device_ptr->id = device_id_for_origin;
+  device_ptr->name = base::UTF16ToUTF8(device->GetName());
+  device_ptr->uuids = std::move(filtered_uuids);
+
+  RecordRequestDeviceOutcome(UMARequestDeviceOutcome::SUCCESS);
+  callback.Run(blink::mojom::WebBluetoothError::SUCCESS, std::move(device_ptr));
+  device_provider_.reset();
+}
+
+void WebBluetoothServiceImpl::OnGetDeviceFailed(
+    const RequestDeviceCallback& callback,
+    blink::mojom::WebBluetoothError error) {
+  // Errors are recorded by the BluetoothDeviceProvider that called this

[Jeffrey Yasskin, 2016/05/13 04:41:59]

Or just "by *device_provider_."?

[ortuno, 2016/05/13 20:11:18]

Done.

+  // function.
+  callback.Run(error, nullptr /* device */);
+  device_provider_.reset();
+}
+
 void WebBluetoothServiceImpl::OnCreateGATTConnectionSuccess(
     const std::string& device_id,
     base::TimeTicks start_time,
     const RemoteServerConnectCallback& callback,
     std::unique_ptr<device::BluetoothGattConnection> connection) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   RecordConnectGATTTimeSuccess(base::TimeTicks::Now() - start_time);
   RecordConnectGATTOutcome(UMAConnectGATTOutcome::SUCCESS);
 
   connected_devices_->Insert(device_id, std::move(connection));
@@ skipping 65 matching lines @@
       error_code, UMAGATTOperation::START_NOTIFICATIONS));
 }
 
 void WebBluetoothServiceImpl::OnStopNotifySessionComplete(
     const std::string& characteristic_instance_id,
     const RemoteCharacteristicStopNotificationsCallback& callback) {
   characteristic_id_to_notify_session_.erase(characteristic_instance_id);
   callback.Run();
 }
 
+CacheQueryResult WebBluetoothServiceImpl::QueryCacheForDevice(
+    const std::string& device_id) {
+  const std::string& device_address =
+      allowed_devices_map_.GetDeviceAddress(GetOrigin(), device_id);
+  if (device_address.empty()) {
+    CrashRendererAndClosePipe(bad_message::BDH_DEVICE_NOT_ALLOWED_FOR_ORIGIN);
+    return CacheQueryResult(CacheQueryOutcome::BAD_RENDERER);
+  }
+
+  CacheQueryResult result;
+  result.device =
+      GetBluetoothAdapterFactoryWrapper()->GetAdapter(this)->GetDevice(
+          device_address);
+
+  // When a device can't be found in the BluetoothAdapter, that generally
+  // indicates that it's gone out of range. We reject with a NetworkError in
+  // that case.
+  if (result.device == nullptr) {
+    result.outcome = CacheQueryOutcome::NO_DEVICE;
+  }
+  return result;
+}
+
 CacheQueryResult WebBluetoothServiceImpl::QueryCacheForService(
     const std::string& service_instance_id) {
   auto device_iter = service_id_to_device_address_.find(service_instance_id);
 
   // Kill the render, see "ID Not in Map Note" above.
   if (device_iter == service_id_to_device_address_.end()) {
     CrashRendererAndClosePipe(bad_message::BDH_INVALID_SERVICE_ID);
     return CacheQueryResult(CacheQueryOutcome::BAD_RENDERER);
   }
 
   const std::string& device_id =
-      GetBluetoothDispatcherHost()->allowed_devices_map_.GetDeviceId(
-          GetOrigin(), device_iter->second);
+      allowed_devices_map_.GetDeviceId(GetOrigin(), device_iter->second);
   // Kill the renderer if origin is not allowed to access the device.
   if (device_id.empty()) {
     CrashRendererAndClosePipe(bad_message::BDH_DEVICE_NOT_ALLOWED_FOR_ORIGIN);
     return CacheQueryResult(CacheQueryOutcome::BAD_RENDERER);
   }
 
-  CacheQueryResult result =
-      GetBluetoothDispatcherHost()->QueryCacheForDevice(GetOrigin(), device_id);
-
-  // TODO(ortuno): Remove once QueryCacheForDevice closes binding_.
-  // http://crbug.com/508771
-  if (result.outcome == CacheQueryOutcome::BAD_RENDERER) {
-    binding_.Close();
-  }
-
+  CacheQueryResult result = QueryCacheForDevice(device_id);
   if (result.outcome != CacheQueryOutcome::SUCCESS) {
     return result;
   }
 
   result.service = result.device->GetGattService(service_instance_id);
   if (result.service == nullptr) {
     result.outcome = CacheQueryOutcome::NO_SERVICE;
-  } else if (!GetBluetoothDispatcherHost()
-                  ->allowed_devices_map_.IsOriginAllowedToAccessService(
-                      GetOrigin(), device_id,
-                      result.service->GetUUID().canonical_value())) {
+  } else if (!allowed_devices_map_.IsOriginAllowedToAccessService(
+                 GetOrigin(), device_id,
+                 result.service->GetUUID().canonical_value())) {
     CrashRendererAndClosePipe(bad_message::BDH_SERVICE_NOT_ALLOWED_FOR_ORIGIN);
     return CacheQueryResult(CacheQueryOutcome::BAD_RENDERER);
   }
   return result;
 }
 
 CacheQueryResult WebBluetoothServiceImpl::QueryCacheForCharacteristic(
     const std::string& characteristic_instance_id) {
   auto characteristic_iter =
       characteristic_id_to_service_id_.find(characteristic_instance_id);
@@ skipping 17 matching lines @@
     result.outcome = CacheQueryOutcome::NO_CHARACTERISTIC;
   }
 
   return result;
 }
 
 RenderProcessHost* WebBluetoothServiceImpl::GetRenderProcessHost() {
   return render_frame_host_->GetProcess();
 }
 
-BluetoothDispatcherHost* WebBluetoothServiceImpl::GetBluetoothDispatcherHost() {
+BluetoothAdapterFactoryWrapper*
+WebBluetoothServiceImpl::GetBluetoothAdapterFactoryWrapper() {
   RenderProcessHostImpl* render_process_host_impl =
       static_cast<RenderProcessHostImpl*>(GetRenderProcessHost());
-  return render_process_host_impl->GetBluetoothDispatcherHost();
+  return render_process_host_impl->GetBluetoothAdapterFactoryWrapper();
 }
 
 void WebBluetoothServiceImpl::CrashRendererAndClosePipe(
     bad_message::BadMessageReason reason) {
   bad_message::ReceivedBadMessage(GetRenderProcessHost(), reason);
   binding_.Close();
 }
 
 url::Origin WebBluetoothServiceImpl::GetOrigin() {
   return render_frame_host_->GetLastCommittedOrigin();
 }
 
 void WebBluetoothServiceImpl::ClearState() {
   characteristic_id_to_notify_session_.clear();
   pending_primary_services_requests_.clear();
   characteristic_id_to_service_id_.clear();
   service_id_to_device_address_.clear();
   connected_devices_.reset(
       new FrameConnectedBluetoothDevices(render_frame_host_));
+  allowed_devices_map_ = BluetoothAllowedDevicesMap();
+  device_provider_.reset();
+  GetBluetoothAdapterFactoryWrapper()->ReleaseAdapter(this);
 }
 
 }  // namespace content