bluetooth: Add characteristicvaluechanged event

third_party/WebKit/Source/modules/bluetooth/BluetoothGATTCharacteristic.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 "config.h"
 #include "modules/bluetooth/BluetoothGATTCharacteristic.h"
 
 #include "bindings/core/v8/CallbackPromiseAdapter.h"
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "core/dom/DOMException.h"
 #include "core/dom/ExceptionCode.h"
+#include "core/events/Event.h"
 #include "modules/bluetooth/BluetoothError.h"
 #include "modules/bluetooth/BluetoothSupplement.h"
 #include "modules/bluetooth/ConvertWebVectorToArrayBuffer.h"
 #include "public/platform/modules/bluetooth/WebBluetooth.h"
 
 namespace blink {
 
 BluetoothGATTCharacteristic::BluetoothGATTCharacteristic(ExecutionContext* context, PassOwnPtr<WebBluetoothGATTCharacteristicInit> webCharacteristic)
     : ActiveDOMObject(context)
     , m_webCharacteristic(webCharacteristic)
     , m_stopped(false)
 {
     // See example in Source/platform/heap/ThreadState.h
     ThreadState::current()->registerPreFinalizer(this);
 }
 
 BluetoothGATTCharacteristic* BluetoothGATTCharacteristic::take(ScriptPromiseResolver* resolver, PassOwnPtr<WebBluetoothGATTCharacteristicInit> webCharacteristic)
 {
     if (!webCharacteristic) {
         return nullptr;
     }
     BluetoothGATTCharacteristic* characteristic = new BluetoothGATTCharacteristic(resolver->executionContext(), webCharacteristic);
     // See note in ActiveDOMObject about suspendIfNeeded.
     characteristic->suspendIfNeeded();
     return characteristic;
 }
 
+void BluetoothGATTCharacteristic::dispatchCharacteristicValueChanged(
+    const WebVector<uint8_t>& value)
+{
+    static_assert(sizeof(*value.data()) == 1, "uint8_t should be a single byte");

[palmer, 2015/10/19 19:23:33]

This doesn't necessarily mean what you think it means. See
http://en.cppreference.com/w/cpp/language/sizeof:

"""Depending on the computer architecture, a byte may consist of 8 or more bits,
the exact number being recorded in CHAR_BIT."""

[ortuno, 2015/10/19 20:09:18]

That assert is there to make sure that the byteLength of the vector's data is
equal to the number of elements or value.size(). This is because we pass
value.size() as byteLength to DOMArrayBuffer::create():

https://code.google.com/p/chromium/codesearch#chromium/src/third_party/WebKit...

+
+    m_value = DOMArrayBuffer::create(value.data(), value.size());
+
+    dispatchEvent(Event::create(EventTypeNames::characteristicvaluechanged));
+}
+
 void BluetoothGATTCharacteristic::stop()
 {
     notifyCharacteristicObjectRemoved();
 }
 
 void BluetoothGATTCharacteristic::dispose()
 {
     notifyCharacteristicObjectRemoved();
 }
 
 void BluetoothGATTCharacteristic::notifyCharacteristicObjectRemoved()
 {
     if (!m_stopped) {
         m_stopped = true;
         WebBluetooth* webbluetooth = BluetoothSupplement::fromExecutionContext(ActiveDOMObject::executionContext());
         webbluetooth->characteristicObjectRemoved(m_webCharacteristic->characteristicInstanceID, this);
     }
 }
 
+const WTF::AtomicString& BluetoothGATTCharacteristic::interfaceName() const
+{
+    return EventTargetNames::BluetoothGATTCharacteristic;
+}
+
+ExecutionContext* BluetoothGATTCharacteristic::executionContext() const
+{
+    return ActiveDOMObject::executionContext();
+}
+
+bool BluetoothGATTCharacteristic::addEventListener(const AtomicString& eventType, PassRefPtrWillBeRawPtr<EventListener> listener, bool useCapture)
+{
+    // We will also need to unregister a characteristic once all the event
+    // listeners have been removed. See http://crbug.com/541390
+    if (eventType == EventTypeNames::characteristicvaluechanged) {
+        WebBluetooth* webbluetooth = BluetoothSupplement::fromExecutionContext(executionContext());
+        webbluetooth->registerCharacteristicObject(m_webCharacteristic->characteristicInstanceID, this);
+    }
+    return EventTarget::addEventListener(eventType, listener, useCapture);
+}
+
 ScriptPromise BluetoothGATTCharacteristic::readValue(ScriptState* scriptState)
 {
     WebBluetooth* webbluetooth = BluetoothSupplement::fromScriptState(scriptState);
 
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
     webbluetooth->readValue(m_webCharacteristic->characteristicInstanceID, new CallbackPromiseAdapter<ConvertWebVectorToArrayBuffer, BluetoothError>(resolver));
 
     return promise;
 }
@@ skipping 33 matching lines @@
 {
     WebBluetooth* webbluetooth = BluetoothSupplement::fromScriptState(scriptState);
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
     webbluetooth->stopNotifications(m_webCharacteristic->characteristicInstanceID, this, new CallbackPromiseAdapter<void, BluetoothError>(resolver));
     return promise;
 }
 
 DEFINE_TRACE(BluetoothGATTCharacteristic)
 {
+    RefCountedGarbageCollectedEventTargetWithInlineData<BluetoothGATTCharacteristic>::trace(visitor);
     ActiveDOMObject::trace(visitor);
 }
 
 } // namespace blink