Adding unit tests for BLE connection.

components/proximity_auth/ble/bluetooth_low_energy_connection.cc

 // 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 "components/proximity_auth/ble/bluetooth_low_energy_connection.h"
 
 #include "base/bind.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/time/time.h"
@@ skipping 27 matching lines @@
     const BluetoothUUID remote_service_uuid,
     const BluetoothUUID to_peripheral_char_uuid,
     const BluetoothUUID from_peripheral_char_uuid,
     scoped_ptr<BluetoothGattConnection> gatt_connection,
     int max_number_of_write_attempts)
     : Connection(device),
       adapter_(adapter),
       remote_service_({remote_service_uuid, ""}),
       to_peripheral_char_({to_peripheral_char_uuid, ""}),
       from_peripheral_char_({from_peripheral_char_uuid, ""}),
+      connection_(gatt_connection.Pass()),
       sub_status_(SubStatus::DISCONNECTED),
       receiving_bytes_(false),
       write_remote_characteristic_pending_(false),
       max_number_of_write_attempts_(max_number_of_write_attempts),
       weak_ptr_factory_(this) {
   DCHECK(adapter_);
   DCHECK(adapter_->IsInitialized());
 
   start_time_ = base::TimeTicks::Now();
   adapter_->AddObserver(this);
-
-  if (gatt_connection && gatt_connection->IsConnected())
-    OnGattConnectionCreated(gatt_connection.Pass());
 }
 
 BluetoothLowEnergyConnection::~BluetoothLowEnergyConnection() {
   Disconnect();
   if (adapter_) {
     adapter_->RemoveObserver(this);
     adapter_ = NULL;
   }
 }
 
 void BluetoothLowEnergyConnection::Connect() {
+  if (connection_ && connection_->IsConnected()) {
+    OnGattConnectionCreated(connection_.Pass());
+    return;
+  }
+
   BluetoothDevice* remote_device = GetRemoteDevice();
   if (remote_device) {
     SetSubStatus(SubStatus::WAITING_GATT_CONNECTION);
     remote_device->CreateGattConnection(
         base::Bind(&BluetoothLowEnergyConnection::OnGattConnectionCreated,
                    weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&BluetoothLowEnergyConnection::OnCreateGattConnectionError,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 }
 
 // This actually forgets the remote BLE device. This is safe as long as we only
 // connect to BLE devices advertising the SmartLock service (assuming this
 // device has no other connection).
 void BluetoothLowEnergyConnection::Disconnect() {
-  ClearWriteRequestsQueue();
-  StopNotifySession();
-  SetSubStatus(SubStatus::DISCONNECTED);
-  if (connection_) {
-    connection_.reset();
-    BluetoothDevice* device = GetRemoteDevice();
-    if (device) {
-      VLOG(1) << "Forget device " << device->GetAddress();
-      device->Forget(base::Bind(&base::DoNothing));
+  if (sub_status_ != SubStatus::DISCONNECTED) {
+    ClearWriteRequestsQueue();
+    StopNotifySession();
+    SetSubStatus(SubStatus::DISCONNECTED);
+    if (connection_) {
+      connection_.reset();
+      BluetoothDevice* device = GetRemoteDevice();
+      if (device) {
+        VLOG(1) << "Forget device " << device->GetAddress();
+        device->Forget(base::Bind(&base::DoNothing));
+      }
     }
   }
 }
 
 void BluetoothLowEnergyConnection::SetSubStatus(SubStatus new_sub_status) {
   sub_status_ = new_sub_status;
 
   // Sets the status of parent class proximity_auth::Connection accordingly.
   if (new_sub_status == SubStatus::CONNECTED) {
     SetStatus(CONNECTED);
@@ skipping 100 matching lines @@
     device::BluetoothDevice::ConnectErrorCode error_code) {
   VLOG(1) << "Error creating GATT connection to "
           << remote_device().bluetooth_address << "error code: " << error_code;
   Disconnect();
 }
 
 void BluetoothLowEnergyConnection::OnGattConnectionCreated(
     scoped_ptr<device::BluetoothGattConnection> gatt_connection) {
   connection_ = gatt_connection.Pass();
   SetSubStatus(SubStatus::WAITING_CHARACTERISTICS);
+  characteristic_finder_.reset(CreateCharacteristicsFinder(
+      base::Bind(&BluetoothLowEnergyConnection::OnCharacteristicsFound,
+                 weak_ptr_factory_.GetWeakPtr()),
+      base::Bind(&BluetoothLowEnergyConnection::OnCharacteristicsFinderError,
+                 weak_ptr_factory_.GetWeakPtr())));
+}
 
-  characteristic_finder_ =
-      make_scoped_ptr(new BluetoothLowEnergyCharacteristicsFinder(
-          adapter_, GetRemoteDevice(), remote_service_, to_peripheral_char_,
-          from_peripheral_char_,
-          base::Bind(&BluetoothLowEnergyConnection::OnCharacteristicsFound,
-                     weak_ptr_factory_.GetWeakPtr()),
-          base::Bind(
-              &BluetoothLowEnergyConnection::OnCharacteristicsFinderError,
-              weak_ptr_factory_.GetWeakPtr())));
+BluetoothLowEnergyCharacteristicsFinder*
+BluetoothLowEnergyConnection::CreateCharacteristicsFinder(
+    const BluetoothLowEnergyCharacteristicsFinder::SuccessCallback&
+        success_callback,
+    const BluetoothLowEnergyCharacteristicsFinder::ErrorCallback&
+        error_callback) {
+  return new BluetoothLowEnergyCharacteristicsFinder(
+      adapter_, GetRemoteDevice(), remote_service_, to_peripheral_char_,
+      from_peripheral_char_, success_callback, error_callback);
 }
 
 void BluetoothLowEnergyConnection::OnCharacteristicsFound(
     const RemoteAttribute& service,
     const RemoteAttribute& to_peripheral_char,
     const RemoteAttribute& from_peripheral_char) {
   remote_service_ = service;
   to_peripheral_char_ = to_peripheral_char;
   from_peripheral_char_ = from_peripheral_char;
 
@@ skipping 112 matching lines @@
     BluetoothGattService::GattErrorCode error) {
   VLOG(1) << "Error " << error << " writing characteristic: "
           << to_peripheral_char_.uuid.canonical_value();
   write_remote_characteristic_pending_ = false;
   // TODO(sacomoto): Actually pass the current message to the observer.
   if (run_did_send_message_callback)
     OnDidSendMessage(FakeWireMessage(""), false);
 
   // Increases the number of failed attempts and retry.
   DCHECK(!write_requests_queue_.empty());
-  if (write_requests_queue_.front().number_of_failed_attempts++ >=
+  if (++write_requests_queue_.front().number_of_failed_attempts >=
       max_number_of_write_attempts_) {
     Disconnect();
     return;
   }
   ProcessNextWriteRequest();
 }
 
 BluetoothLowEnergyConnection::WriteRequest
 BluetoothLowEnergyConnection::BuildWriteRequest(
     const std::vector<uint8>& signal,
@@ skipping 62 matching lines @@
     const uint32 value) {
   std::vector<uint8> bytes(4, 0);
   bytes[0] = static_cast<uint8>(value);
   bytes[1] = static_cast<uint8>(value >> 8);
   bytes[2] = static_cast<uint8>(value >> 16);
   bytes[3] = static_cast<uint8>(value >> 24);
   return bytes;
 }
 
 }  // namespace proximity_auth