bluetooth: Create base class BluetoothDevice::CreateGattConnection impl.

device/bluetooth/bluetooth_device.cc

 // Copyright (c) 2012 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 "device/bluetooth/bluetooth_device.h"
 
+#include <limits>
 #include <string>
 
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
+#include "device/bluetooth/bluetooth_gatt_connection.h"
 #include "device/bluetooth/bluetooth_gatt_service.h"
 #include "grit/device_bluetooth_strings.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace device {
 
 BluetoothDevice::BluetoothDevice(BluetoothAdapter* adapter)
     : adapter_(adapter), services_data_(new base::DictionaryValue()) {}
 
 BluetoothDevice::~BluetoothDevice() {
@@ skipping 170 matching lines @@
 
 bool BluetoothDevice::IsTrustable() const {
   // Sony PlayStation Dualshock3
   if ((GetVendorID() == 0x054c && GetProductID() == 0x0268 &&
        GetDeviceName() == "PLAYSTATION(R)3 Controller"))
     return true;
 
   return false;
 }
 
+void BluetoothDevice::CreateGattConnection(
+    const GattConnectionCallback& callback,
+    const ConnectErrorCallback& error_callback) {
+  create_gatt_connection_success_callbacks_.push_back(callback);
+  create_gatt_connection_error_callbacks_.push_back(error_callback);
+
+  if (IsGattConnected())
+    DidConnectGatt();
+
+  CreateGattConnectionImpl();
+}
+
 std::vector<BluetoothGattService*>
     BluetoothDevice::GetGattServices() const {
   std::vector<BluetoothGattService*> services;
   for (GattServiceMap::const_iterator iter = gatt_services_.begin();
        iter != gatt_services_.end(); ++iter)
     services.push_back(iter->second);
   return services;
 }
 
 BluetoothGattService* BluetoothDevice::GetGattService(
@@ skipping 53 matching lines @@
   std::vector<device::BluetoothUUID> uuids;
   base::DictionaryValue::Iterator iter(*services_data_);
   while (!iter.IsAtEnd()) {
     BluetoothUUID uuid(iter.key());
     uuids.push_back(uuid);
     iter.Advance();
   }
   return uuids;
 }
 
+void BluetoothDevice::DidConnectGatt() {
+  for (const auto& callback : create_gatt_connection_success_callbacks_) {
+    callback.Run(
+        make_scoped_ptr(new BluetoothGattConnection(adapter_, GetAddress())));
+  }
+  create_gatt_connection_success_callbacks_.clear();
+  create_gatt_connection_error_callbacks_.clear();
+}
+
+void BluetoothDevice::DidFailToConnectGatt(ConnectErrorCode error) {
+  for (const auto& error_callback : create_gatt_connection_error_callbacks_)
+    error_callback.Run(error);
+  create_gatt_connection_success_callbacks_.clear();
+  create_gatt_connection_error_callbacks_.clear();
+}
+
+void BluetoothDevice::DidDisconnectGatt() {
+  // If pending calls to connect GATT existed, flush them to ensure a consistent
+  // state.
+  DidFailToConnectGatt(ERROR_UNKNOWN);

[Jeffrey Yasskin, 2015/08/19 22:49:45]

Don't use "UNKNOWN" here (or ever, really). If you need to add a correct
enumerator, do that.

[scheib, 2015/09/13 02:40:27]

Ok, though this scenario is a situation where we don't know why we are failing.
I've added a VLOG to make that more clear, and moved to FAILED. If we don't want
UNKNOWN, we should just remove the enum. Though in this case I believe it is
most semantically correct. In the following patch this is called when Android
reports disconnection and a success error status.

[Jeffrey Yasskin, 2015/09/16 00:45:39]

We have places where we convert a string to an enum value. If an unexpected
string appears, I'd like to propagate it to the user, but our architecture
doesn't allow it, so we have to give the useless UNKNOWN error message. In other
cases, we should give the developer as much information as we can so that they
can debug.

"FAILED" is also bad for developers, since it doesn't tell them what caused the
error. But using FAILED lets us distinguish cases where we're missing a string
translation from other failures that we don't have any more information about.
Would that happen if the user calls connect() and then disconnect() before the
connect succeeds? Then their promises should reject with an AbortError (per
https://github.com/WebBluetoothCG/web-bluetooth/issues/152), not the
NetworkError that ERROR_FAILED causes.

+}
+
+void BluetoothDevice::IncrementGattConnectionReferenceCount() {
+  CHECK(gatt_connection_reference_count_ <

[Jeffrey Yasskin, 2015/08/19 22:49:45]

Use base/numerics/safe_math.h instead of implementing your own checks. Or just
don't check: we don't check in places like IdMap either.

[scheib, 2015/09/13 02:40:27]

Done. IDMap does check: after increment and next set it checks for duplicate. 

+        std::numeric_limits<decltype(gatt_connection_reference_count_)>::max());
+  gatt_connection_reference_count_++;
+}
+
+void BluetoothDevice::DecrementGattConnectionReferenceCount() {
+  CHECK(gatt_connection_reference_count_ > 0);
+  gatt_connection_reference_count_--;
+  if (gatt_connection_reference_count_ == 0)
+    DisconnectGatt();
+}
+
 void BluetoothDevice::ClearServiceData() { services_data_->Clear(); }
 
 void BluetoothDevice::SetServiceData(BluetoothUUID serviceUUID,
                                      const char* buffer, size_t size) {
   services_data_->Set(serviceUUID.value(),
                       base::BinaryValue::CreateWithCopiedBuffer(buffer, size));
 }
 
 }  // namespace device