Refactor WebBluetoothServiceClient in the web_bluetooth.mojom

third_party/WebKit/Source/modules/bluetooth/Bluetooth.cpp

 // 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.
 
 #include "modules/bluetooth/Bluetooth.h"
 
 #include "bindings/core/v8/CallbackPromiseAdapter.h"
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "core/dom/DOMException.h"
@@ skipping 112 matching lines @@
          options.optionalServices()) {
       const String& validatedOptionalService =
           BluetoothUUID::getService(optionalService, exceptionState);
       if (exceptionState.hadException())
         return;
       result->optional_services.push_back(validatedOptionalService);
     }
   }
 }
 
-void Bluetooth::Dispose() {
-  // The pipe to this object must be closed when is marked unreachable to
-  // prevent messages from being dispatched before lazy sweeping.
-  if (m_clientBinding.is_bound())
-    m_clientBinding.Close();
-}
-
 void Bluetooth::RequestDeviceCallback(
     ScriptPromiseResolver* resolver,
     mojom::blink::WebBluetoothResult result,
     mojom::blink::WebBluetoothDevicePtr device) {
   if (!resolver->getExecutionContext() ||
       resolver->getExecutionContext()->isContextDestroyed())
     return;
 
   if (result == mojom::blink::WebBluetoothResult::SUCCESS) {
     BluetoothDevice* bluetoothDevice =
@@ skipping 31 matching lines @@
   if (!m_service) {
     InterfaceProvider* interfaceProvider = nullptr;
     if (context->isDocument()) {
       Document* document = toDocument(context);
       if (document->frame())
         interfaceProvider = document->frame()->interfaceProvider();
     }
 
     if (interfaceProvider)
       interfaceProvider->getInterface(mojo::MakeRequest(&m_service));
-
-    if (m_service) {
-      // Create an associated interface ptr and pass it to the
-      // WebBluetoothService so that it can send us events without us
-      // prompting.
-      mojom::blink::WebBluetoothServiceClientAssociatedPtrInfo ptrInfo;
-      m_clientBinding.Bind(&ptrInfo);
-      m_service->SetClient(std::move(ptrInfo));
-    }
   }
 
   if (!m_service) {
     return ScriptPromise::rejectWithDOMException(
         scriptState, DOMException::create(NotSupportedError));
   }
 
   // In order to convert the arguments from service names and aliases to just
   // UUIDs, do the following substeps:
   auto deviceOptions = mojom::blink::WebBluetoothRequestDeviceOptions::New();
@@ skipping 12 matching lines @@
   ScriptPromise promise = resolver->promise();
 
   m_service->RequestDevice(
       std::move(deviceOptions),
       convertToBaseCallback(WTF::bind(&Bluetooth::RequestDeviceCallback,
                                       wrapPersistent(this),
                                       wrapPersistent(resolver))));
   return promise;
 }
 
-void Bluetooth::AddToConnectedDevicesMap(const String& deviceId,
-                                         BluetoothDevice* device) {
-  m_connectedDevices.insert(deviceId, device);
-}
-
-void Bluetooth::RemoveFromConnectedDevicesMap(const String& deviceId) {
-  m_connectedDevices.erase(deviceId);
-}
-
-void Bluetooth::RegisterCharacteristicObject(
-    const String& characteristicInstanceId,
-    BluetoothRemoteGATTCharacteristic* characteristic) {
-  m_activeCharacteristics.insert(characteristicInstanceId, characteristic);
-}
-
-void Bluetooth::CharacteristicObjectRemoved(
-    const String& characteristicInstanceId) {
-  m_activeCharacteristics.erase(characteristicInstanceId);
-}
-
 DEFINE_TRACE(Bluetooth) {
   visitor->trace(m_deviceInstanceMap);
-  visitor->trace(m_activeCharacteristics);
-  visitor->trace(m_connectedDevices);
 }
 
-Bluetooth::Bluetooth() : m_clientBinding(this) {}
-
-void Bluetooth::RemoteCharacteristicValueChanged(
-    const WTF::String& characteristicInstanceId,
-    const WTF::Vector<uint8_t>& value) {
-  BluetoothRemoteGATTCharacteristic* characteristic =
-      m_activeCharacteristics.at(characteristicInstanceId);
-  if (characteristic)
-    characteristic->DispatchCharacteristicValueChanged(value);
-}
-
-void Bluetooth::GattServerDisconnected(const WTF::String& deviceId) {
-  BluetoothDevice* device = m_connectedDevices.at(deviceId);
-  if (device) {
-    // Remove device from the map before calling dispatchGattServerDisconnected
-    // to avoid removing a device the gattserverdisconnected event handler might
-    // have re-connected.
-    m_connectedDevices.erase(deviceId);
-    device->DispatchGattServerDisconnected();
-  }
-}
+Bluetooth::Bluetooth() {}
 
 BluetoothDevice* Bluetooth::GetBluetoothDeviceRepresentingDevice(
     mojom::blink::WebBluetoothDevicePtr devicePtr,
     ScriptPromiseResolver* resolver) {
   WTF::String id = devicePtr->id;
   BluetoothDevice* device = m_deviceInstanceMap.at(id);
   if (!device) {
     device = BluetoothDevice::take(resolver, std::move(devicePtr), this);
     auto result = m_deviceInstanceMap.insert(id, device);
     DCHECK(result.isNewEntry);
   }
   return device;
 }
 
 }  // namespace blink