Add BluetoothGattCharacteristicTest::StartNotifySession_Reentrant unit test

device/bluetooth/test/bluetooth_test.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 "device/bluetooth/test/bluetooth_test.h"
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 143 matching lines @@
     BluetoothRemoteGattService::GattErrorCode error_code) {
   ++error_callback_count_;
   last_gatt_error_code_ = error_code;
 
   if (expected == Call::EXPECTED)
     ++actual_error_callback_calls_;
   else
     unexpected_error_callback_ = true;
 }
 
+void BluetoothTestBase::ReentrantStartNotifySessionSuccessCallback(
+    Call expected,
+    BluetoothRemoteGattCharacteristic* characteristic,
+    std::unique_ptr<BluetoothGattNotifySession> notify_session) {
+  ++callback_count_;
+  notify_sessions_.push_back(notify_session.release());

[ortuno, 2016/04/22 16:23:39]

I think std::move(notify_session) would be better here. Specially since we will
soon get rid of ScopedVector.

[gogerald1, 2016/04/27 20:15:32]

Done.

+
+  if (expected == Call::EXPECTED)
+    ++actual_success_callback_calls_;
+  else
+    unexpected_success_callback_ = true;
+
+  characteristic->StartNotifySession(GetNotifyCallback(Call::EXPECTED),
+                                     GetGattErrorCallback(Call::NOT_EXPECTED));
+}
+
+void BluetoothTestBase::ReentrantStartNotifySessionErrorCallback(
+    Call expected,
+    BluetoothRemoteGattCharacteristic* characteristic,
+    bool error_in_reentrant,
+    BluetoothGattService::GattErrorCode error_code) {
+  ++error_callback_count_;
+  last_gatt_error_code_ = error_code;
+
+  if (expected == Call::EXPECTED)
+    ++actual_error_callback_calls_;
+  else
+    unexpected_error_callback_ = true;
+
+  if (error_in_reentrant) {
+    SimulateGattCharacteristicSetNotifyWillFailAsynchronouslyOnce(
+        characteristic);
+    characteristic->StartNotifySession(GetNotifyCallback(Call::NOT_EXPECTED),
+                                       GetGattErrorCallback(Call::EXPECTED));
+  } else {
+    characteristic->StartNotifySession(
+        GetNotifyCallback(Call::EXPECTED),
+        GetGattErrorCallback(Call::NOT_EXPECTED));
+  }
+}
+
 base::Closure BluetoothTestBase::GetCallback(Call expected) {
   if (expected == Call::EXPECTED)
     ++expected_success_callback_calls_;
   return base::Bind(&BluetoothTestBase::Callback, weak_factory_.GetWeakPtr(),
                     expected);
 }
 
 BluetoothAdapter::DiscoverySessionCallback
 BluetoothTestBase::GetDiscoverySessionCallback(Call expected) {
   if (expected == Call::EXPECTED)
@@ skipping 43 matching lines @@
 }
 
 base::Callback<void(BluetoothRemoteGattService::GattErrorCode)>
 BluetoothTestBase::GetGattErrorCallback(Call expected) {
   if (expected == Call::EXPECTED)
     ++expected_error_callback_calls_;
   return base::Bind(&BluetoothTestBase::GattErrorCallback,
                     weak_factory_.GetWeakPtr(), expected);
 }
 
+BluetoothRemoteGattCharacteristic::NotifySessionCallback
+BluetoothTestBase::GetReentrantStartNotifySessionSuccessCallback(
+    Call expected,
+    BluetoothRemoteGattCharacteristic* characteristic) {
+  if (expected == Call::EXPECTED)
+    ++expected_success_callback_calls_;
+  return base::Bind(
+      &BluetoothTestBase::ReentrantStartNotifySessionSuccessCallback,
+      weak_factory_.GetWeakPtr(), expected, characteristic);
+}
+
+base::Callback<void(BluetoothGattService::GattErrorCode)>
+BluetoothTestBase::GetReentrantStartNotifySessionErrorCallback(
+    Call expected,
+    BluetoothRemoteGattCharacteristic* characteristic,
+    bool error_in_reentrant) {
+  if (expected == Call::EXPECTED)
+    ++expected_error_callback_calls_;
+  return base::Bind(
+      &BluetoothTestBase::ReentrantStartNotifySessionErrorCallback,
+      weak_factory_.GetWeakPtr(), expected, characteristic, error_in_reentrant);
+}
+
 void BluetoothTestBase::ResetEventCounts() {
   last_connect_error_code_ = BluetoothDevice::ERROR_UNKNOWN;
   callback_count_ = 0;
   error_callback_count_ = 0;
   gatt_connection_attempts_ = 0;
   gatt_disconnection_attempts_ = 0;
   gatt_discovery_attempts_ = 0;
   gatt_notify_characteristic_attempts_ = 0;
   gatt_read_characteristic_attempts_ = 0;
   gatt_write_characteristic_attempts_ = 0;
   gatt_read_descriptor_attempts_ = 0;
   gatt_write_descriptor_attempts_ = 0;
 }
 
 }  // namespace device