bluetooth: Fix crash when trying to read or write when operation pending

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 "base/bind.h"
 #include "base/logging.h"
 #include "base/run_loop.h"
 #include "device/bluetooth/bluetooth_adapter.h"
@@ skipping 16 matching lines @@
 
 BluetoothTestBase::BluetoothTestBase() : weak_factory_(this) {}
 
 BluetoothTestBase::~BluetoothTestBase() {
 }
 
 void BluetoothTestBase::StartLowEnergyDiscoverySession() {
   adapter_->StartDiscoverySessionWithFilter(
       make_scoped_ptr(new BluetoothDiscoveryFilter(
           BluetoothDiscoveryFilter::Transport::TRANSPORT_LE)),
-      GetDiscoverySessionCallback(), GetErrorCallback());
+      GetDiscoverySessionCallback(Call::EXPECTED),
+      GetErrorCallback(Call::NOT_EXPECTED));
   base::RunLoop().RunUntilIdle();
 }
 
+void BluetoothTestBase::StartLowEnergyDiscoverySessionExpectedToFail() {
+  adapter_->StartDiscoverySessionWithFilter(
+      make_scoped_ptr(new BluetoothDiscoveryFilter(
+          BluetoothDiscoveryFilter::Transport::TRANSPORT_LE)),
+      GetDiscoverySessionCallback(Call::NOT_EXPECTED),
+      GetErrorCallback(Call::EXPECTED));
+  base::RunLoop().RunUntilIdle();
+}
+
+void BluetoothTestBase::TearDown() {
+  EXPECT_EQ(expected_success_callback_calls_, actual_success_callback_calls_);
+  EXPECT_EQ(expected_error_callback_calls_, actual_error_callback_calls_);
+  EXPECT_FALSE(unexpected_success_callback_);
+  EXPECT_FALSE(unexpected_error_callback_);
+}
+
 bool BluetoothTestBase::DenyPermission() {
   return false;
 }
 
 BluetoothDevice* BluetoothTestBase::DiscoverLowEnergyDevice(
     int device_ordinal) {
   NOTIMPLEMENTED();
   return nullptr;
 }
 
 void BluetoothTestBase::DeleteDevice(BluetoothDevice* device) {
   adapter_->DeleteDeviceForTesting(device->GetAddress());
 }
 
-void BluetoothTestBase::Callback() {
+void BluetoothTestBase::Callback(Call expected) {
   ++callback_count_;
+
+  if (expected == Call::NOT_EXPECTED)
+    unexpected_success_callback_ = true;
+  else
+    ++actual_success_callback_calls_;
 }
 
 void BluetoothTestBase::DiscoverySessionCallback(
+    Call expected,
     scoped_ptr<BluetoothDiscoverySession> discovery_session) {
   ++callback_count_;
   discovery_sessions_.push_back(discovery_session.release());
+
+  if (expected == Call::NOT_EXPECTED)

[scheib, 2015/11/21 05:40:22]

Optional, but logic for these may be simpler with the positive logic form of:

if (expected == Call::EXPECTED)

[ortuno, 2015/11/22 04:45:02]

Done.

+    unexpected_success_callback_ = true;
+  else
+    ++actual_success_callback_calls_;
 }
 
 void BluetoothTestBase::GattConnectionCallback(
+    Call expected,
     scoped_ptr<BluetoothGattConnection> connection) {
   ++callback_count_;
   gatt_connections_.push_back(connection.release());
+
+  if (expected == Call::NOT_EXPECTED)
+    unexpected_success_callback_ = true;
+  else
+    ++actual_success_callback_calls_;
 }
 
 void BluetoothTestBase::NotifyCallback(
+    Call expected,
     scoped_ptr<BluetoothGattNotifySession> notify_session) {
   ++callback_count_;
   notify_sessions_.push_back(notify_session.release());
+
+  if (expected == Call::NOT_EXPECTED)
+    unexpected_success_callback_ = true;
+  else
+    ++actual_success_callback_calls_;
 }
 
-void BluetoothTestBase::ReadValueCallback(const std::vector<uint8>& value) {
+void BluetoothTestBase::ReadValueCallback(Call expected,
+                                          const std::vector<uint8>& value) {
   ++callback_count_;
   last_read_value_ = value;
+
+  if (expected == Call::NOT_EXPECTED)
+    unexpected_success_callback_ = true;
+  else
+    ++actual_success_callback_calls_;
 }
 
-void BluetoothTestBase::ErrorCallback() {
+void BluetoothTestBase::ErrorCallback(Call expected) {
   ++error_callback_count_;
+
+  if (expected == Call::NOT_EXPECTED)
+    unexpected_error_callback_ = true;
+  else
+    ++actual_error_callback_calls_;
 }
 
 void BluetoothTestBase::ConnectErrorCallback(
+    Call expected,
     enum BluetoothDevice::ConnectErrorCode error_code) {
   ++error_callback_count_;
   last_connect_error_code_ = error_code;
+
+  if (expected == Call::NOT_EXPECTED)
+    unexpected_error_callback_ = true;
+  else
+    ++actual_error_callback_calls_;
 }
 
 void BluetoothTestBase::GattErrorCallback(
+    Call expected,
     BluetoothGattService::GattErrorCode error_code) {
   ++error_callback_count_;
   last_gatt_error_code_ = error_code;
+
+  if (expected == Call::NOT_EXPECTED)
+    unexpected_error_callback_ = true;
+  else
+    ++actual_error_callback_calls_;
 }
 
-base::Closure BluetoothTestBase::GetCallback() {
-  return base::Bind(&BluetoothTestBase::Callback, weak_factory_.GetWeakPtr());
+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() {
+BluetoothTestBase::GetDiscoverySessionCallback(Call expected) {
+  if (expected == Call::EXPECTED)
+    ++expected_success_callback_calls_;
   return base::Bind(&BluetoothTestBase::DiscoverySessionCallback,
-                    weak_factory_.GetWeakPtr());
+                    weak_factory_.GetWeakPtr(), expected);
 }
 
 BluetoothDevice::GattConnectionCallback
-BluetoothTestBase::GetGattConnectionCallback() {
+BluetoothTestBase::GetGattConnectionCallback(Call expected) {
+  if (expected == Call::EXPECTED)
+    ++expected_success_callback_calls_;
   return base::Bind(&BluetoothTestBase::GattConnectionCallback,
-                    weak_factory_.GetWeakPtr());
+                    weak_factory_.GetWeakPtr(), expected);
 }
 
 BluetoothGattCharacteristic::NotifySessionCallback
-BluetoothTestBase::GetNotifyCallback() {
+BluetoothTestBase::GetNotifyCallback(Call expected) {
+  if (expected == Call::EXPECTED)
+    ++expected_success_callback_calls_;
   return base::Bind(&BluetoothTestBase::NotifyCallback,
-                    weak_factory_.GetWeakPtr());
+                    weak_factory_.GetWeakPtr(), expected);
 }
 
 BluetoothGattCharacteristic::ValueCallback
-BluetoothTestBase::GetReadValueCallback() {
+BluetoothTestBase::GetReadValueCallback(Call expected) {
+  if (expected == Call::EXPECTED)
+    ++expected_success_callback_calls_;
   return base::Bind(&BluetoothTestBase::ReadValueCallback,
-                    weak_factory_.GetWeakPtr());
+                    weak_factory_.GetWeakPtr(), expected);
 }
 
-BluetoothAdapter::ErrorCallback BluetoothTestBase::GetErrorCallback() {
+BluetoothAdapter::ErrorCallback BluetoothTestBase::GetErrorCallback(
+    Call expected) {
+  if (expected == Call::EXPECTED)
+    ++expected_error_callback_calls_;
   return base::Bind(&BluetoothTestBase::ErrorCallback,
-                    weak_factory_.GetWeakPtr());
+                    weak_factory_.GetWeakPtr(), expected);
 }
 
 BluetoothDevice::ConnectErrorCallback
-BluetoothTestBase::GetConnectErrorCallback() {
+BluetoothTestBase::GetConnectErrorCallback(Call expected) {
+  if (expected == Call::EXPECTED)
+    ++expected_error_callback_calls_;
   return base::Bind(&BluetoothTestBase::ConnectErrorCallback,
-                    weak_factory_.GetWeakPtr());
+                    weak_factory_.GetWeakPtr(), expected);
 }
 
 base::Callback<void(BluetoothGattService::GattErrorCode)>
-BluetoothTestBase::GetGattErrorCallback() {
+BluetoothTestBase::GetGattErrorCallback(Call expected) {
+  if (expected == Call::EXPECTED)
+    ++expected_error_callback_calls_;
   return base::Bind(&BluetoothTestBase::GattErrorCallback,
-                    weak_factory_.GetWeakPtr());
+                    weak_factory_.GetWeakPtr(), expected);
 }
 
 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;
 }
 
 }  // namespace device