bluetooth: Test & make StartNotifySession reentrant.

device/bluetooth/bluetooth_remote_gatt_characteristic_android.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/bluetooth_remote_gatt_characteristic_android.h"
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/bind.h"
@@ skipping 30 matching lines @@
           base::android::ConvertUTF8ToJavaString(env, instance_id).obj(),
           chrome_bluetooth_device));
 
   return characteristic;
 }
 
 BluetoothRemoteGattCharacteristicAndroid::
     ~BluetoothRemoteGattCharacteristicAndroid() {
   Java_ChromeBluetoothRemoteGattCharacteristic_onBluetoothRemoteGattCharacteristicAndroidDestruction(
       AttachCurrentThread(), j_characteristic_.obj());
+
+  if (pending_start_notify_calls_.size()) {
+    OnStartNotifySessionError(device::BluetoothGattService::GATT_ERROR_FAILED);
+  }
 }
 
 // static
 bool BluetoothRemoteGattCharacteristicAndroid::RegisterJNI(JNIEnv* env) {
   return RegisterNativesImpl(
       env);  // Generated in ChromeBluetoothRemoteGattCharacteristic_jni.h
 }
 
 base::android::ScopedJavaLocalRef<jobject>
 BluetoothRemoteGattCharacteristicAndroid::GetJavaObject() {
@@ skipping 65 matching lines @@
   NOTIMPLEMENTED();
   return false;
 }
 
 bool BluetoothRemoteGattCharacteristicAndroid::UpdateValue(
     const std::vector<uint8_t>& value) {
   NOTIMPLEMENTED();
   return false;
 }
 
 void BluetoothRemoteGattCharacteristicAndroid::StartNotifySession(

[ortuno, 2016/03/13 22:45:03]

We need an issue to track IsNotifying(). Otherwise we will write to the
descriptor every time we call StartNotifySession.

[scheib, 2016/03/14 20:00:16]

Done. https://bugs.chromium.org/p/chromium/issues/detail?id=594665

     const NotifySessionCallback& callback,
     const ErrorCallback& error_callback) {
   if (!pending_start_notify_calls_.empty()) {
-    pending_start_notify_calls_.push(std::make_pair(callback, error_callback));
+    pending_start_notify_calls_.push_back(
+        std::make_pair(callback, error_callback));
     return;
   }
 
   Properties properties = GetProperties();
 
   bool hasNotify = properties & PROPERTY_NOTIFY;
   bool hasIndicate = properties & PROPERTY_INDICATE;
 
   if (!hasNotify && !hasIndicate) {
     LOG(ERROR) << "Characteristic needs NOTIFY or INDICATE";
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
-        base::Bind(error_callback,
-                   BluetoothRemoteGattServiceAndroid::GATT_ERROR_FAILED));
+        base::Bind(
+            error_callback,
+            BluetoothRemoteGattServiceAndroid::GATT_ERROR_NOT_SUPPORTED));
     return;
   }
 
   std::vector<BluetoothGattDescriptor*> ccc_descriptor = GetDescriptorsForUUID(
       BluetoothGattDescriptor::ClientCharacteristicConfigurationUuid());
 
   if (ccc_descriptor.size() != 1u) {
     LOG(ERROR)
         << "Could not find client characteristic configuration descriptor";
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
-        base::Bind(error_callback,
-                   BluetoothRemoteGattServiceAndroid::GATT_ERROR_FAILED));
+        base::Bind(
+            error_callback,
+            BluetoothRemoteGattServiceAndroid::GATT_ERROR_NOT_SUPPORTED));
     return;
   }
 
   if (!Java_ChromeBluetoothRemoteGattCharacteristic_setCharacteristicNotification(
           AttachCurrentThread(), j_characteristic_.obj(), true)) {
     LOG(ERROR) << "Error enabling characteristic notification";
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(error_callback,
                    BluetoothRemoteGattServiceAndroid::GATT_ERROR_FAILED));
     return;
   }
 
-  std::vector<uint8_t> value;
+  std::vector<uint8_t> value(2);
   value.push_back(hasNotify ? 1 : 2);
   value.push_back(0);
 
-  pending_start_notify_calls_.push(std::make_pair(callback, error_callback));
+  pending_start_notify_calls_.push_back(
+      std::make_pair(callback, error_callback));
   ccc_descriptor[0]->WriteRemoteDescriptor(
       value, base::Bind(&BluetoothRemoteGattCharacteristicAndroid::
                             OnStartNotifySessionSuccess,
                         base::Unretained(this)),
       base::Bind(
           &BluetoothRemoteGattCharacteristicAndroid::OnStartNotifySessionError,
           base::Unretained(this)));
 }
 
 void BluetoothRemoteGattCharacteristicAndroid::ReadRemoteCharacteristic(
@@ skipping 49 matching lines @@
 
 void BluetoothRemoteGattCharacteristicAndroid::OnChanged(
     JNIEnv* env,
     const JavaParamRef<jobject>& jcaller,
     const JavaParamRef<jbyteArray>& value) {
   base::android::JavaByteArrayToByteVector(env, value, &value_);
   adapter_->NotifyGattCharacteristicValueChanged(this, value_);
 }
 
 void BluetoothRemoteGattCharacteristicAndroid::OnStartNotifySessionSuccess() {
-  while (!pending_start_notify_calls_.empty()) {
-    PendingStartNotifyCall callbacks = pending_start_notify_calls_.front();
-    pending_start_notify_calls_.pop();
+  std::vector<PendingStartNotifyCall> reentrant_safe_callbacks;
+  reentrant_safe_callbacks.swap(pending_start_notify_calls_);
+
+  for (const auto& callback_pair : reentrant_safe_callbacks) {
     scoped_ptr<device::BluetoothGattNotifySession> notify_session(
         new BluetoothGattNotifySessionAndroid(instance_id_));
-    callbacks.first.Run(std::move(notify_session));
+    callback_pair.first.Run(std::move(notify_session));
   }
 }
 
 void BluetoothRemoteGattCharacteristicAndroid::OnStartNotifySessionError(
     BluetoothGattService::GattErrorCode error) {
-  while (!pending_start_notify_calls_.empty()) {
-    PendingStartNotifyCall callbacks = pending_start_notify_calls_.front();
-    pending_start_notify_calls_.pop();
-    callbacks.second.Run(error);
+  std::vector<PendingStartNotifyCall> reentrant_safe_callbacks;
+  reentrant_safe_callbacks.swap(pending_start_notify_calls_);
+
+  for (auto const& callback_pair : reentrant_safe_callbacks) {
+    callback_pair.second.Run(error);
   }
 }
 
 void BluetoothRemoteGattCharacteristicAndroid::OnRead(
     JNIEnv* env,
     const JavaParamRef<jobject>& jcaller,
     int32_t status,
     const JavaParamRef<jbyteArray>& value) {
   read_pending_ = false;
 
@@ skipping 65 matching lines @@
 void BluetoothRemoteGattCharacteristicAndroid::EnsureDescriptorsCreated()
     const {
   if (!descriptors_.empty())
     return;
 
   Java_ChromeBluetoothRemoteGattCharacteristic_createDescriptors(
       AttachCurrentThread(), j_characteristic_.obj());
 }
 
 }  // namespace device