Remove RemoteServerDisconnect() from web_bluetooth.mojom

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 WebBluetoothServiceImpl map [service_id_to_device_address_,
 // characteristic_id_to_service_id_, descriptor_id_to_characteristic_id_]
 // 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 337 matching lines @@
       web_bluetooth_server_client;
   web_bluetooth_server_client.Bind(std::move(client));
   query_result.device->CreateGattConnection(
       base::Bind(&WebBluetoothServiceImpl::OnCreateGATTConnectionSuccess,
                  weak_ptr_factory_.GetWeakPtr(), device_id, start_time,
                  base::Passed(&web_bluetooth_server_client), callback),
       base::Bind(&WebBluetoothServiceImpl::OnCreateGATTConnectionFailed,
                  weak_ptr_factory_.GetWeakPtr(), start_time, callback));
 }
 
-void WebBluetoothServiceImpl::RemoteServerDisconnect(
-    const WebBluetoothDeviceId& device_id) {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  RecordWebBluetoothFunctionCall(
-      UMAWebBluetoothFunction::REMOTE_GATT_SERVER_DISCONNECT);
-
-  if (connected_devices_->IsConnectedToDeviceWithId(device_id)) {
-    DVLOG(1) << "Disconnecting device: " << device_id.str();
-    connected_devices_->CloseConnectionToDeviceWithId(device_id);
-  }
-}
-
 void WebBluetoothServiceImpl::RemoteServerGetPrimaryServices(
     const WebBluetoothDeviceId& device_id,
     blink::mojom::WebBluetoothGATTQueryQuantity quantity,
     const base::Optional<BluetoothUUID>& services_uuid,
     const RemoteServerGetPrimaryServicesCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   RecordWebBluetoothFunctionCall(
       quantity == blink::mojom::WebBluetoothGATTQueryQuantity::SINGLE
           ? UMAWebBluetoothFunction::GET_PRIMARY_SERVICE
           : UMAWebBluetoothFunction::GET_PRIMARY_SERVICES);
@@ skipping 460 matching lines @@
       new BluetoothDeviceChooserController(this, render_frame_host_, adapter));
 
   device_chooser_controller_->GetDevice(
       std::move(options),
       base::Bind(&WebBluetoothServiceImpl::OnGetDeviceSuccess,
                  weak_ptr_factory_.GetWeakPtr(), callback),
       base::Bind(&WebBluetoothServiceImpl::OnGetDeviceFailed,
                  weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
+void WebBluetoothServiceImpl::HandleServerClientError(
+    const WebBluetoothDeviceId& device_id) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  RecordWebBluetoothFunctionCall(
+      UMAWebBluetoothFunction::REMOTE_GATT_SERVER_DISCONNECT);

[scheib, 2017/03/22 01:11:07]

This UMA was intended to count how often Javascript called disconnect, but now
it also counts when the device disconnects and the browser is informed, or for
any other reason when the client is disconnected.

Perhaps move this UMA to BluetoothRemoteGATTServer::disconnect, with a comment
here and there explaining why we do this.

Another alternative is a patch before this one that moves all
Bluetooth.Web.FunctionCall.Count UMA from browser to WebKit.

[juncai, 2017/03/27 20:44:46]

Filed an issue:
https://bugs.chromium.org/p/chromium/issues/detail?id=703970

+
+  // If a GATT connection exists for device identified by |device_id| then
+  // decreases the ref count for that connection.
+  if (connected_devices_->IsConnectedToDeviceWithId(device_id)) {
+    DVLOG(1) << "Disconnecting device: " << device_id.str();
+    connected_devices_->CloseConnectionToDeviceWithId(device_id);
+  }
+}
+
 void WebBluetoothServiceImpl::RemoteServerGetPrimaryServicesImpl(
     const WebBluetoothDeviceId& device_id,
     blink::mojom::WebBluetoothGATTQueryQuantity quantity,
     const base::Optional<BluetoothUUID>& services_uuid,
     const RemoteServerGetPrimaryServicesCallback& callback,
     device::BluetoothDevice* device) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(device->IsGattServicesDiscoveryComplete());
 
   std::vector<device::BluetoothRemoteGattService*> services =
@@ skipping 92 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   RecordConnectGATTTimeSuccess(base::TimeTicks::Now() - start_time);
   RecordConnectGATTOutcome(UMAConnectGATTOutcome::SUCCESS);
 
   if (connected_devices_->IsConnectedToDeviceWithId(device_id)) {
     DVLOG(1) << "Already connected.";
     callback.Run(blink::mojom::WebBluetoothResult::SUCCESS);
     return;
   }
 
+  client.set_connection_error_handler(
+      base::Bind(&WebBluetoothServiceImpl::HandleServerClientError,
+                 weak_ptr_factory_.GetWeakPtr(), device_id));
   callback.Run(blink::mojom::WebBluetoothResult::SUCCESS);
   connected_devices_->Insert(device_id, std::move(connection),
                              std::move(client));
 }
 
 void WebBluetoothServiceImpl::OnCreateGATTConnectionFailed(
     base::TimeTicks start_time,
     const RemoteServerConnectCallback& callback,
     device::BluetoothDevice::ConnectErrorCode error_code) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
@@ skipping 243 matching lines @@
   descriptor_id_to_characteristic_id_.clear();
   characteristic_id_to_service_id_.clear();
   service_id_to_device_address_.clear();
   connected_devices_.reset(
       new FrameConnectedBluetoothDevices(render_frame_host_));
   device_chooser_controller_.reset();
   BluetoothAdapterFactoryWrapper::Get().ReleaseAdapter(this);
 }
 
 }  // namespace content