bluetooth: web: Include the UUID in the error message.

third_party/WebKit/Source/modules/bluetooth/BluetoothRemoteGATTService.cpp

 // 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 "modules/bluetooth/BluetoothRemoteGATTService.h"
 
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "core/dom/DOMException.h"
 #include "core/dom/ExceptionCode.h"
@@ skipping 32 matching lines @@
   visitor->trace(m_device);
 }
 
 // Class that allows us to resolve the promise with a single Characteristic or
 // with a vector owning the characteristics.
 class GetCharacteristicsCallback
     : public WebBluetoothGetCharacteristicsCallbacks {
  public:
   GetCharacteristicsCallback(
       BluetoothRemoteGATTService* service,
+      const String characteristicsUUID,
       mojom::blink::WebBluetoothGATTQueryQuantity quantity,
       ScriptPromiseResolver* resolver)
-      : m_service(service), m_quantity(quantity), m_resolver(resolver) {
+      : m_service(service),
+        m_characteristicsUUID(characteristicsUUID),
+        m_quantity(quantity),
+        m_resolver(resolver) {
     // We always check that the device is connected before constructing this
     // object.
     CHECK(m_service->device()->gatt()->connected());
     m_service->device()->gatt()->AddToActiveAlgorithms(m_resolver.get());
   }
 
   void onSuccess(const WebVector<WebBluetoothRemoteGATTCharacteristicInit*>&
                      webCharacteristics) override {
     if (!m_resolver->getExecutionContext() ||
         m_resolver->getExecutionContext()->isContextDestroyed())
@@ skipping 38 matching lines @@
       return;
 
     // If the resolver is not in the set of ActiveAlgorithms then the frame
     // disconnected so we reject.
     if (!m_service->device()->gatt()->RemoveFromActiveAlgorithms(
             m_resolver.get())) {
       m_resolver->reject(
           DOMException::create(NetworkError, kGATTServerDisconnected));
       return;
     }
-
-    m_resolver->reject(BluetoothError::take(m_resolver, error));
+    if (!m_characteristicsUUID.isEmpty() &&
+        BluetoothError::isSameError(
+            error,
+            mojom::blink::WebBluetoothResult::CHARACTERISTIC_NOT_FOUND)) {
+      m_resolver->reject(BluetoothError::take(
+          m_resolver, error,
+          "No Characteristics matching UUID " + m_characteristicsUUID +
+              " found in Service with UUID " + m_service->uuid() + "."));
+    } else {
+      m_resolver->reject(BluetoothError::take(m_resolver, error));
+    }
   }
 
  private:
   Persistent<BluetoothRemoteGATTService> m_service;
+  const String m_characteristicsUUID;
   mojom::blink::WebBluetoothGATTQueryQuantity m_quantity;
   const Persistent<ScriptPromiseResolver> m_resolver;
 };
 
 ScriptPromise BluetoothRemoteGATTService::getCharacteristic(
     ScriptState* scriptState,
     const StringOrUnsignedLong& characteristic,
     ExceptionState& exceptionState) {
   String characteristicUUID =
       BluetoothUUID::getCharacteristic(characteristic, exceptionState);
@@ skipping 41 matching lines @@
         scriptState, DOMException::create(InvalidStateError, kInvalidService));
   }
 
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
   ScriptPromise promise = resolver->promise();
 
   WebBluetooth* webbluetooth =
       BluetoothSupplement::fromScriptState(scriptState);
   webbluetooth->getCharacteristics(
       m_webService->serviceInstanceID, static_cast<int32_t>(quantity),
-      characteristicsUUID,
-      new GetCharacteristicsCallback(this, quantity, resolver));
+      characteristicsUUID, new GetCharacteristicsCallback(
+                               this, characteristicsUUID, quantity, resolver));
 
   return promise;
 }
 
 }  // namespace blink