bluetooth: Refactor GetDescriptorForUUID to GetDescriptorsForUUID.

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 132 matching lines @@
 
   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, BluetoothGattService::GATT_ERROR_FAILED));
     return;
   }
 
-  BluetoothGattDescriptor* descriptor = GetDescriptorForUUID(
+  std::vector<BluetoothGattDescriptor*> ccc_descriptor = GetDescriptorsByUUID(
       BluetoothGattDescriptor::ClientCharacteristicConfigurationUuid());
 
-  if (!descriptor) {
-    LOG(ERROR)
-        << "Could not find client characteristic configuration descriptor";
+  if (ccc_descriptor.size() != 1u) {
+    LOG(ERROR) << "Found " << ccc_descriptor.size()
+               << " client characteristic configuration descriptors.";
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(error_callback,
-                   BluetoothRemoteGattServiceAndroid::GATT_ERROR_FAILED));
+                   (ccc_descriptor.size() == 0)
+                       ? BluetoothGattService::GATT_ERROR_NOT_SUPPORTED
+                       : BluetoothGattService::GATT_ERROR_FAILED));
     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));
+        base::Bind(error_callback, BluetoothGattService::GATT_ERROR_FAILED));
     return;
   }
 
   std::vector<uint8_t> value;
   value.push_back(hasNotify ? 1 : 2);
   value.push_back(0);
 
   pending_start_notify_calls_.push(std::make_pair(callback, error_callback));
-  descriptor->WriteRemoteDescriptor(
+  ccc_descriptor[0]->WriteRemoteDescriptor(
       value, base::Bind(&BluetoothRemoteGattCharacteristicAndroid::
                             OnStartNotifySessionSuccess,
                         base::Unretained(this)),
       base::Bind(
           &BluetoothRemoteGattCharacteristicAndroid::OnStartNotifySessionError,
           base::Unretained(this)));
 }
 
 void BluetoothRemoteGattCharacteristicAndroid::ReadRemoteCharacteristic(
     const ValueCallback& callback,
     const ErrorCallback& error_callback) {
   if (read_pending_ || write_pending_) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(error_callback,
                               BluetoothGattService::GATT_ERROR_IN_PROGRESS));
     return;
   }
 
   if (!Java_ChromeBluetoothRemoteGattCharacteristic_readRemoteCharacteristic(
           AttachCurrentThread(), j_characteristic_.obj())) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
-        base::Bind(error_callback,
-                   BluetoothRemoteGattServiceAndroid::GATT_ERROR_FAILED));
+        base::Bind(error_callback, BluetoothGattService::GATT_ERROR_FAILED));
     return;
   }
 
   read_pending_ = true;
   read_callback_ = callback;
   read_error_callback_ = error_callback;
 }
 
 void BluetoothRemoteGattCharacteristicAndroid::WriteRemoteCharacteristic(
     const std::vector<uint8_t>& new_value,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   if (read_pending_ || write_pending_) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(error_callback,
                               BluetoothGattService::GATT_ERROR_IN_PROGRESS));
     return;
   }
 
   JNIEnv* env = AttachCurrentThread();
   if (!Java_ChromeBluetoothRemoteGattCharacteristic_writeRemoteCharacteristic(
           env, j_characteristic_.obj(),
           base::android::ToJavaByteArray(env, new_value).obj())) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
-        base::Bind(error_callback,
-                   BluetoothRemoteGattServiceAndroid::GATT_ERROR_FAILED));
+        base::Bind(error_callback, BluetoothGattService::GATT_ERROR_FAILED));
     return;
   }
 
   write_pending_ = true;
   write_callback_ = callback;
   write_error_callback_ = error_callback;
 }
 
 void BluetoothRemoteGattCharacteristicAndroid::OnChanged(
     JNIEnv* env,
@@ skipping 97 matching lines @@
 void BluetoothRemoteGattCharacteristicAndroid::EnsureDescriptorsCreated()
     const {
   if (!descriptors_.empty())
     return;
 
   Java_ChromeBluetoothRemoteGattCharacteristic_createDescriptors(
       AttachCurrentThread(), j_characteristic_.obj());
 }
 
 }  // namespace device