Refactor WebBluetoothServiceClient in the web_bluetooth.mojom

third_party/WebKit/Source/modules/bluetooth/BluetoothRemoteGATTServer.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/BluetoothRemoteGATTServer.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 10 matching lines @@
 
 namespace {
 
 const char kGATTServerNotConnected[] =
     "GATT Server is disconnected. Cannot retrieve services. (Re)connect first "
     "with `device.gatt.connect`.";
 
 }  // namespace
 
 BluetoothRemoteGATTServer::BluetoothRemoteGATTServer(BluetoothDevice* device)
-    : m_device(device), m_connected(false) {}
+    : m_clientBinding(this), m_device(device), m_connected(false) {}
 
 BluetoothRemoteGATTServer* BluetoothRemoteGATTServer::create(
     BluetoothDevice* device) {
   return new BluetoothRemoteGATTServer(device);
 }
 
+void BluetoothRemoteGATTServer::GattServerDisconnected() {
+  m_device->dispatchGattServerDisconnected();
+}
+
 void BluetoothRemoteGATTServer::AddToActiveAlgorithms(
     ScriptPromiseResolver* resolver) {
   auto result = m_activeAlgorithms.insert(resolver);
   CHECK(result.isNewEntry);
 }
 
 bool BluetoothRemoteGATTServer::RemoveFromActiveAlgorithms(
     ScriptPromiseResolver* resolver) {
   if (!m_activeAlgorithms.contains(resolver)) {
     return false;
   }
   m_activeAlgorithms.erase(resolver);
   return true;
 }
 
+void BluetoothRemoteGATTServer::dispose() {

[ortuno, 2017/02/24 03:28:52]

Similar to BluetoothRemoteGATTCharacteristic, we want the device to disconnect
as soon as you navigate away. dispose only gets called when the object gets
garbage collected which could happen many seconds after we've navigated away.
For that reason we should also implement contextDestroyed.

[juncai, 2017/03/01 02:04:12]

Done.

+  // 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();
+}
+
 DEFINE_TRACE(BluetoothRemoteGATTServer) {
   visitor->trace(m_activeAlgorithms);
   visitor->trace(m_device);
 }
 
 void BluetoothRemoteGATTServer::ConnectCallback(
     ScriptPromiseResolver* resolver,
-    mojom::blink::WebBluetoothResult result) {
+    mojom::blink::WebBluetoothResult result,
+    mojom::blink::WebBluetoothServerClientAssociatedRequest request) {
   if (!resolver->getExecutionContext() ||
       resolver->getExecutionContext()->isContextDestroyed())
     return;
 
+  m_clientBinding.Bind(std::move(request));

[ortuno, 2017/02/24 03:28:52]

Hmm seems we are missing tests. We need a test to make sure that the following
works:

device.gatt.connect().then(gatt => gatt.connect());


Right now that would result in the second callback getting called with a null
request. And the client would no longer receive a disconnection event. I would
first write the test and then implement the fix that way you know that the test
is working correctly.

[juncai, 2017/03/01 02:04:12]

Done.

+
   if (result == mojom::blink::WebBluetoothResult::SUCCESS) {
-    m_device->bluetooth()->addToConnectedDevicesMap(device()->id(), device());
     setConnected(true);
     resolver->resolve(this);
   } else {
     resolver->reject(BluetoothError::take(resolver, result));
   }
 }
 
 ScriptPromise BluetoothRemoteGATTServer::connect(ScriptState* scriptState) {
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
   ScriptPromise promise = resolver->promise();
 
   mojom::blink::WebBluetoothService* service = m_device->bluetooth()->service();
   service->RemoteServerConnect(
       device()->id(), convertToBaseCallback(WTF::bind(
                           &BluetoothRemoteGATTServer::ConnectCallback,
                           wrapPersistent(this), wrapPersistent(resolver))));
 
   return promise;
 }
 
 void BluetoothRemoteGATTServer::disconnect(ScriptState* scriptState) {
   if (!m_connected)
     return;
   device()->cleanupDisconnectedDeviceAndFireEvent();
-  m_device->bluetooth()->removeFromConnectedDevicesMap(device()->id());
   mojom::blink::WebBluetoothService* service = m_device->bluetooth()->service();
   service->RemoteServerDisconnect(device()->id());
 }
 
 // Callback that allows us to resolve the promise with a single service or
 // with a vector owning the services.
 void BluetoothRemoteGATTServer::GetPrimaryServicesCallback(
     mojom::blink::WebBluetoothGATTQueryQuantity quantity,
     ScriptPromiseResolver* resolver,
     mojom::blink::WebBluetoothResult result,
@@ skipping 83 matching lines @@
   mojom::blink::WebBluetoothService* service = m_device->bluetooth()->service();
   service->RemoteServerGetPrimaryServices(
       device()->id(), quantity, servicesUUID,
       convertToBaseCallback(
           WTF::bind(&BluetoothRemoteGATTServer::GetPrimaryServicesCallback,
                     wrapPersistent(this), quantity, wrapPersistent(resolver))));
   return promise;
 }
 
 }  // namespace blink