[Onion Soup] Move WebBluetoothImpl from //content/renderer/bluetooth to Blink's bluetooth module

content/renderer/bluetooth/web_bluetooth_impl.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.
-
-#include "content/renderer/bluetooth/web_bluetooth_impl.h"
-
-#include <memory>
-#include <utility>
-#include <vector>
-
-#include "base/memory/ptr_util.h"
-#include "base/optional.h"
-#include "content/child/mojo/type_converters.h"
-#include "content/child/thread_safe_sender.h"
-#include "content/common/bluetooth/web_bluetooth_device_id.h"
-#include "content/renderer/bluetooth/bluetooth_type_converters.h"
-#include "ipc/ipc_message.h"
-#include "mojo/public/cpp/bindings/array.h"
-#include "services/service_manager/public/cpp/interface_provider.h"
-#include "third_party/WebKit/public/platform/modules/bluetooth/WebBluetoothDevice.h"
-#include "third_party/WebKit/public/platform/modules/bluetooth/WebBluetoothDeviceInit.h"
-#include "third_party/WebKit/public/platform/modules/bluetooth/WebBluetoothRemoteGATTCharacteristic.h"
-#include "third_party/WebKit/public/platform/modules/bluetooth/WebBluetoothRemoteGATTCharacteristicInit.h"
-#include "third_party/WebKit/public/platform/modules/bluetooth/WebBluetoothRemoteGATTService.h"
-#include "third_party/WebKit/public/platform/modules/bluetooth/WebRequestDeviceOptions.h"
-
-namespace content {
-
-namespace {
-
-// Blink can't use non-blink mojo enums like blink::mojom::WebBluetoothResult,
-// so we pass it as an int32 across the boundary.
-int32_t ToInt32(blink::mojom::WebBluetoothResult result) {
-  return static_cast<int32_t>(result);
-}
-
-}  // namespace
-
-WebBluetoothImpl::WebBluetoothImpl(
-    service_manager::InterfaceProvider* remote_interfaces)
-    : remote_interfaces_(remote_interfaces), binding_(this) {}
-
-WebBluetoothImpl::~WebBluetoothImpl() {
-}
-
-void WebBluetoothImpl::requestDevice(
-    const blink::WebRequestDeviceOptions& options,
-    blink::WebBluetoothRequestDeviceCallbacks* callbacks) {
-  GetWebBluetoothService().RequestDevice(
-      blink::mojom::WebBluetoothRequestDeviceOptions::From(options),
-      base::Bind(&WebBluetoothImpl::OnRequestDeviceComplete,
-                 base::Unretained(this),
-                 base::Passed(base::WrapUnique(callbacks))));
-}
-
-void WebBluetoothImpl::connect(
-    const blink::WebString& device_id,
-    blink::WebBluetoothDevice* device,
-    blink::WebBluetoothRemoteGATTServerConnectCallbacks* callbacks) {
-  // TODO(crbug.com/495270): After the Bluetooth Tree is implemented, there will
-  // only be one object per device. But for now we replace the previous object.
-  WebBluetoothDeviceId device_id_obj = WebBluetoothDeviceId(device_id.utf8());
-  connected_devices_[device_id_obj] = device;
-
-  GetWebBluetoothService().RemoteServerConnect(
-      std::move(device_id_obj),
-      base::Bind(&WebBluetoothImpl::OnConnectComplete, base::Unretained(this),
-                 base::Passed(base::WrapUnique(callbacks))));
-}
-
-void WebBluetoothImpl::disconnect(const blink::WebString& device_id) {
-  WebBluetoothDeviceId device_id_obj = WebBluetoothDeviceId(device_id.utf8());
-  connected_devices_.erase(device_id_obj);
-
-  GetWebBluetoothService().RemoteServerDisconnect(std::move(device_id_obj));
-}
-
-void WebBluetoothImpl::getPrimaryServices(
-    const blink::WebString& device_id,
-    int32_t quantity,
-    const blink::WebString& services_uuid,
-    blink::WebBluetoothGetPrimaryServicesCallbacks* callbacks) {
-  DCHECK(blink::mojom::IsKnownEnumValue(
-      static_cast<blink::mojom::WebBluetoothGATTQueryQuantity>(quantity)));
-  GetWebBluetoothService().RemoteServerGetPrimaryServices(
-      WebBluetoothDeviceId(device_id.utf8()),
-      static_cast<blink::mojom::WebBluetoothGATTQueryQuantity>(quantity),
-      services_uuid.isEmpty()
-          ? base::nullopt
-          : base::make_optional(device::BluetoothUUID(services_uuid.utf8())),
-      base::Bind(&WebBluetoothImpl::OnGetPrimaryServicesComplete,
-                 base::Unretained(this), device_id,
-                 base::Passed(base::WrapUnique(callbacks))));
-}
-
-void WebBluetoothImpl::getCharacteristics(
-    const blink::WebString& service_instance_id,
-    int32_t quantity,
-    const blink::WebString& characteristics_uuid,
-    blink::WebBluetoothGetCharacteristicsCallbacks* callbacks) {
-  DCHECK(blink::mojom::IsKnownEnumValue(
-      static_cast<blink::mojom::WebBluetoothGATTQueryQuantity>(quantity)));
-  GetWebBluetoothService().RemoteServiceGetCharacteristics(
-      mojo::String::From(service_instance_id),
-      static_cast<blink::mojom::WebBluetoothGATTQueryQuantity>(quantity),
-      characteristics_uuid.isEmpty()
-          ? base::nullopt
-          : base::make_optional(
-                device::BluetoothUUID(characteristics_uuid.utf8())),
-      base::Bind(&WebBluetoothImpl::OnGetCharacteristicsComplete,
-                 base::Unretained(this), service_instance_id,
-                 base::Passed(base::WrapUnique(callbacks))));
-}
-
-void WebBluetoothImpl::readValue(
-    const blink::WebString& characteristic_instance_id,
-    blink::WebBluetoothReadValueCallbacks* callbacks) {
-  GetWebBluetoothService().RemoteCharacteristicReadValue(
-      mojo::String::From(characteristic_instance_id),
-      base::Bind(&WebBluetoothImpl::OnReadValueComplete, base::Unretained(this),
-                 base::Passed(base::WrapUnique(callbacks))));
-}
-
-void WebBluetoothImpl::writeValue(
-    const blink::WebString& characteristic_instance_id,
-    const blink::WebVector<uint8_t>& value,
-    blink::WebBluetoothWriteValueCallbacks* callbacks) {
-  GetWebBluetoothService().RemoteCharacteristicWriteValue(
-      mojo::String::From(characteristic_instance_id),
-      mojo::Array<uint8_t>::From(value),
-      base::Bind(&WebBluetoothImpl::OnWriteValueComplete,
-                 base::Unretained(this), value,
-                 base::Passed(base::WrapUnique(callbacks))));
-}
-
-void WebBluetoothImpl::startNotifications(
-    const blink::WebString& characteristic_instance_id,
-    blink::WebBluetoothNotificationsCallbacks* callbacks) {
-  GetWebBluetoothService().RemoteCharacteristicStartNotifications(
-      mojo::String::From(characteristic_instance_id),
-      base::Bind(&WebBluetoothImpl::OnStartNotificationsComplete,
-                 base::Unretained(this),
-                 base::Passed(base::WrapUnique(callbacks))));
-}
-
-void WebBluetoothImpl::stopNotifications(
-    const blink::WebString& characteristic_instance_id,
-    blink::WebBluetoothNotificationsCallbacks* callbacks) {
-  GetWebBluetoothService().RemoteCharacteristicStopNotifications(
-      mojo::String::From(characteristic_instance_id),
-      base::Bind(&WebBluetoothImpl::OnStopNotificationsComplete,
-                 base::Unretained(this),
-                 base::Passed(base::WrapUnique(callbacks))));
-}
-
-void WebBluetoothImpl::characteristicObjectRemoved(
-    const blink::WebString& characteristic_instance_id,
-    blink::WebBluetoothRemoteGATTCharacteristic* characteristic) {
-  active_characteristics_.erase(characteristic_instance_id.utf8());
-}
-
-void WebBluetoothImpl::registerCharacteristicObject(
-    const blink::WebString& characteristic_instance_id,
-    blink::WebBluetoothRemoteGATTCharacteristic* characteristic) {
-  // TODO(ortuno): After the Bluetooth Tree is implemented, there will
-  // only be one object per characteristic. But for now we replace
-  // the previous object.
-  // https://crbug.com/495270
-  active_characteristics_[characteristic_instance_id.utf8()] = characteristic;
-}
-
-void WebBluetoothImpl::RemoteCharacteristicValueChanged(
-    const std::string& characteristic_instance_id,
-    const std::vector<uint8_t>& value) {
-  // We post a task so that the event is fired after any pending promises have
-  // resolved.
-  base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE,
-      base::Bind(&WebBluetoothImpl::DispatchCharacteristicValueChanged,
-                 base::Unretained(this), characteristic_instance_id, value));
-}
-
-void WebBluetoothImpl::OnRequestDeviceComplete(
-    std::unique_ptr<blink::WebBluetoothRequestDeviceCallbacks> callbacks,
-    const blink::mojom::WebBluetoothResult result,
-    blink::mojom::WebBluetoothDevicePtr device) {
-  if (result == blink::mojom::WebBluetoothResult::SUCCESS) {
-    callbacks->onSuccess(base::MakeUnique<blink::WebBluetoothDeviceInit>(
-        blink::WebString::fromUTF8(device->id.str()),
-        device->name ? blink::WebString::fromUTF8(device->name.value())
-                     : blink::WebString()));
-  } else {
-    callbacks->onError(ToInt32(result));
-  }
-}
-
-void WebBluetoothImpl::GattServerDisconnected(
-    const WebBluetoothDeviceId& device_id) {
-  auto device_iter = connected_devices_.find(device_id);
-  if (device_iter != connected_devices_.end()) {
-    // Remove device from the map before calling dispatchGattServerDisconnected
-    // to avoid removing a device the gattserverdisconnected event handler might
-    // have re-connected.
-    blink::WebBluetoothDevice* device = device_iter->second;
-    connected_devices_.erase(device_iter);
-    device->dispatchGattServerDisconnected();
-  }
-}
-
-void WebBluetoothImpl::OnConnectComplete(
-    std::unique_ptr<blink::WebBluetoothRemoteGATTServerConnectCallbacks>
-        callbacks,
-    blink::mojom::WebBluetoothResult result) {
-  if (result == blink::mojom::WebBluetoothResult::SUCCESS) {
-    callbacks->onSuccess();
-  } else {
-    callbacks->onError(ToInt32(result));
-  }
-}
-
-void WebBluetoothImpl::OnGetPrimaryServicesComplete(
-    const blink::WebString& device_id,
-    std::unique_ptr<blink::WebBluetoothGetPrimaryServicesCallbacks> callbacks,
-    blink::mojom::WebBluetoothResult result,
-    base::Optional<std::vector<blink::mojom::WebBluetoothRemoteGATTServicePtr>>
-        services) {
-  if (result == blink::mojom::WebBluetoothResult::SUCCESS) {
-    DCHECK(services);
-    // TODO(dcheng): This WebVector should use smart pointers.
-    blink::WebVector<blink::WebBluetoothRemoteGATTService*> promise_services(
-        services->size());
-    for (size_t i = 0; i < services->size(); i++) {
-      promise_services[i] = new blink::WebBluetoothRemoteGATTService(
-          blink::WebString::fromUTF8(services.value()[i]->instance_id),
-          blink::WebString::fromUTF8(services.value()[i]->uuid),
-          true /* isPrimary */, device_id);
-    }
-    callbacks->onSuccess(promise_services);
-  } else {
-    callbacks->onError(ToInt32(result));
-  }
-}
-
-void WebBluetoothImpl::OnGetCharacteristicsComplete(
-    const blink::WebString& service_instance_id,
-    std::unique_ptr<blink::WebBluetoothGetCharacteristicsCallbacks> callbacks,
-    blink::mojom::WebBluetoothResult result,
-    base::Optional<
-        std::vector<blink::mojom::WebBluetoothRemoteGATTCharacteristicPtr>>
-        characteristics) {
-  if (result == blink::mojom::WebBluetoothResult::SUCCESS) {
-    DCHECK(characteristics);
-    // TODO(dcheng): This WebVector should use smart pointers.
-    blink::WebVector<blink::WebBluetoothRemoteGATTCharacteristicInit*>
-        promise_characteristics(characteristics->size());
-    for (size_t i = 0; i < characteristics->size(); i++) {
-      promise_characteristics[i] =
-          new blink::WebBluetoothRemoteGATTCharacteristicInit(
-              service_instance_id, blink::WebString::fromUTF8(
-                                       characteristics.value()[i]->instance_id),
-              blink::WebString::fromUTF8(characteristics.value()[i]->uuid),
-              characteristics.value()[i]->properties);
-    }
-    callbacks->onSuccess(promise_characteristics);
-  } else {
-    callbacks->onError(ToInt32(result));
-  }
-}
-
-void WebBluetoothImpl::OnReadValueComplete(
-    std::unique_ptr<blink::WebBluetoothReadValueCallbacks> callbacks,
-    blink::mojom::WebBluetoothResult result,
-    const base::Optional<std::vector<uint8_t>>& value) {
-  if (result == blink::mojom::WebBluetoothResult::SUCCESS) {
-    DCHECK(value);
-    callbacks->onSuccess(value.value());
-  } else {
-    callbacks->onError(ToInt32(result));
-  }
-}
-
-void WebBluetoothImpl::OnWriteValueComplete(
-    const blink::WebVector<uint8_t>& value,
-    std::unique_ptr<blink::WebBluetoothWriteValueCallbacks> callbacks,
-    blink::mojom::WebBluetoothResult result) {
-  if (result == blink::mojom::WebBluetoothResult::SUCCESS) {
-    callbacks->onSuccess(value);
-  } else {
-    callbacks->onError(ToInt32(result));
-  }
-}
-
-void WebBluetoothImpl::OnStartNotificationsComplete(
-    std::unique_ptr<blink::WebBluetoothNotificationsCallbacks> callbacks,
-    blink::mojom::WebBluetoothResult result) {
-  if (result == blink::mojom::WebBluetoothResult::SUCCESS) {
-    callbacks->onSuccess();
-  } else {
-    callbacks->onError(ToInt32(result));
-  }
-}
-
-void WebBluetoothImpl::OnStopNotificationsComplete(
-    std::unique_ptr<blink::WebBluetoothNotificationsCallbacks> callbacks) {
-  callbacks->onSuccess();
-}
-
-void WebBluetoothImpl::DispatchCharacteristicValueChanged(
-    const std::string& characteristic_instance_id,
-    const std::vector<uint8_t>& value) {
-  auto active_iter = active_characteristics_.find(characteristic_instance_id);
-  if (active_iter != active_characteristics_.end()) {
-    active_iter->second->dispatchCharacteristicValueChanged(value);
-  }
-}
-
-blink::mojom::WebBluetoothService& WebBluetoothImpl::GetWebBluetoothService() {
-  if (!web_bluetooth_service_) {
-    remote_interfaces_->GetInterface(
-        mojo::MakeRequest(&web_bluetooth_service_));
-    // Create an associated interface ptr and pass it to the WebBluetoothService
-    // so that it can send us events without us prompting.
-    blink::mojom::WebBluetoothServiceClientAssociatedPtrInfo ptr_info;
-    binding_.Bind(&ptr_info, web_bluetooth_service_.associated_group());
-    web_bluetooth_service_->SetClient(std::move(ptr_info));
-  }
-  return *web_bluetooth_service_;
-}
-
-}  // namespace content