bluetooth: Add characteristicvaluechanged event

third_party/WebKit/LayoutTests/bluetooth/resources/bluetooth-helpers.js

 'use strict';
 
 // Sometimes we need to test that using either the name, alias, or UUID
 // produces the same result. The following objects help us do that.
 var generic_access = {
   alias: 0x1800,
   name: 'generic_access',
   uuid: '00001800-0000-1000-8000-00805f9b34fb'
 };
 var device_name = {
@@ skipping 114 matching lines @@
 }
 
 function runGarbageCollection()
 {
   // Run gc() as a promise.
   return new Promise(
       function(resolve, reject) {
         GCController.collect();
         setTimeout(resolve, 0);
       });
-  return Promise.resolve();
 }
+
+// Creates |num_listeners| promises. Each adds an event listener
+// to object. The promises resolve once the object fires |event| but
+// reject if the event is fired before |object|.|func|() resolves.
+// Returns a promise that fulfills with the result of |object|.|func()|
+// and |event.target.value| of each of the other promises.
+function assert_event_fires_after_promise(object, func, event, num_listeners) {
+  num_listeners = num_listeners !== undefined ? num_listeners : 1;
+
+  if (object[func] === undefined) {
+    return Promise.reject('Function \'' + func + '\' not available in object.');
+  }
+  let should_resolve = false;
+  let event_promises = [];
+  for (let i = 0; i < num_listeners; i++) {
+    event_promises.push(new Promise((resolve, reject) => {
+      let event_listener = (e) => {
+        object.removeEventListener(event, event_listener);
+        if (should_resolve) {
+          resolve(e.target.value);
+        } else {
+          reject(event + ' was triggered before the promise resolved.');
+        }
+      };
+      object.addEventListener(event, event_listener);
+    }));
+  }
+  return object[func]().then(result => {
+    should_resolve = true;
+    return Promise.all([result, ...event_promises]);
+  });
+}
+
+// Returns a promise that resolves after 100ms unless

[scheib, 2015/10/16 20:39:25]

Timers in tests are super bad, causing flake or tests that appear to offer
coverage but don't, and tests that take longer than they should. 

OK, in this test if the bot is running too slowly the 100ms will trigger and
resolve with the test passing. The test may pass when it otherwise shouldn't.
This is not so good, but at least it won't cause flake.

Probably explain this and copy the comment and issue number to not use timers.

[ortuno, 2015/10/16 21:55:49]

The idea behind the setTimeout is to add an event to the end of the event queue
after any notification events are fired. But setting the timeout to 0 might miss
events being fired if the renderer or the browser are busy so I set it to 100ms
just in case. I can set it to 0 but then chances of missing events being
incorrectly fired increase.

Added a comment explaining this.

[scheib, 2015/10/17 19:33:43]

Either:

The task just needs to be placed in the queue to have deterministic ordering so
that it doesn't process until after e.g. this execution turn completes. That
would be OK.

Or, there's some amount of time needed for some reason, e.g. waiting on the
browser process. That is not OK. We can never be certain about the amount of
time. The test won't be clean until the delay is expressed in events, and not
duration of time. So, e.g. we can send a signal to the browser, or we can have
the browser send another signal to us that it has completed whatever may be in
process that would send an event.

The solution that comes to mind for me is to not have the browser send
notifications based on a timer. Instead have them sent when a test API call
causes them - and have that test API have a promise/callback that informs the
test that the event would have been sent and received by the time the result
comes in. 

[ortuno, 2015/10/19 18:23:47]

Added TODO that points to http://crbug.com/543884

+// the the event is fired on the object in which case
+// the promise rejects.
+function assert_no_events(object, event_name) {
+  return new Promise((resolve, reject) => {
+    let event_listener = (e) => {
+      object.removeEventListener(event_name, event_listener);
+      assert_unreached('Object should not fire an event.');
+    };
+    object.addEventListener(event_name, event_listener);
+    setTimeout(() => {
+      object.removeEventListener(event_name, event_listener);
+      resolve();
+    }, 100);
+  });
+}