Add the JS data pipe client to be used to implement serial send.

extensions/test/data/data_sender_unittest.js

+// Copyright 2014 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.
+
+// Tests launched by extensions/renderer/api/serial/data_sender_unittest.cc
+
+var test = require('test').binding;
+var unittestBindings = require('test_environment_specific_bindings');
+
+function wrapAsyncTest(func) {
+  Promise.all([
+    requireAsync('content/public/renderer/service_provider'),
+    requireAsync('data_sender'),
+    requireAsync('device/serial/data_stream.mojom'),
+  ]).then(test.callbackPass(function(modules) {
+    func(modules[0], modules[1], modules[2]);
+  }));
+}
+
+function generateData(size, character) {
+  if (!character)
+    character = 'a';
+  var buffer = new ArrayBuffer(size);
+  var intView = new Int8Array(buffer);
+  for (var i = 0; i < size; i++) {
+    intView[i] = character.charCodeAt(0);
+  }
+  return buffer;
+}
+
+unittestBindings.exportTests([
+  function testSend() {
+    wrapAsyncTest(
+        function testSend(serviceProvider, dataSender, mojom) {

[raymes, 2014/08/20 04:23:13]

Couldn't we define all of the real test bodies in a list (e.g.

var tests = [
  function testSend(....) {
  },

  function testLargeSend(...) {
  },
  ...
];


And then just have some snippet at the end which wraps them up using
wrapAsyncTest? I'm guessing this is something we probably want to pull out into
a utility.

[Sam McNally, 2014/08/20 04:50:15]

exportTests uses the function names to decide the names to export the test
functions as and I couldn't find a way to generate a wrapper with the same name
as the wrapped function.

Changed to match the style of the receiver unit tests.

+      var sender = new dataSender.DataSender(
+          serviceProvider.connectToService(mojom.DataSinkProxy.NAME_), 10, 2);

[raymes, 2014/08/20 04:23:13]

use constants for construction. If it's easier, pull this line out into a small
function: createDataSender()

[Sam McNally, 2014/08/20 04:50:16]

Done.

+      var seen = null;
+      sender.send(generateData(1)).then(test.callbackPass(function(bytesSent) {
+        test.assertEq(1, bytesSent);
+        test.assertEq(null, seen);
+        seen = 'first';
+      }));
+      sender.send(generateData(1)).then(test.callbackPass(function(bytesSent) {
+        sender.close();
+        test.assertEq(1, bytesSent);
+        test.assertEq('first', seen);
+        seen = 'second';
+      }));
+    });
+  },
+
+  function testLargeSend() {
+    wrapAsyncTest(
+        function testSend(serviceProvider, dataSender, mojom) {
+      var sender = new dataSender.DataSender(
+          serviceProvider.connectToService(mojom.DataSinkProxy.NAME_), 10, 2);
+      sender.send(generateData(100)).then(test.callbackPass(
+          function(bytesSent) {
+        test.assertEq(100, bytesSent);

[raymes, 2014/08/20 04:23:13]

As before consider using a multiple of the buffer size. Also below.

[Sam McNally, 2014/08/20 04:50:16]

Done.

+        sender.close();
+      }));
+    });
+  },
+
+  function testSendError() {
+    wrapAsyncTest(
+        function testSend(serviceProvider, dataSender, mojom) {
+      var sender = new dataSender.DataSender(
+          serviceProvider.connectToService(mojom.DataSinkProxy.NAME_), 10, 2);
+      sender.send(generateData(100, 'b')).catch(test.callbackPass(function(e) {
+        test.assertEq(1, e.error);
+        test.assertEq(0, e.bytesSent);
+        sender.send(generateData(1)).then(test.callbackPass(
+            function(bytesSent) {
+          test.assertEq(1, bytesSent);
+          sender.close();
+        }));
+      }));
+    });
+  },
+
+  function testSendErrorPartialSuccess() {
+    wrapAsyncTest(
+        function testSend(serviceProvider, dataSender, mojom) {
+      var sender = new dataSender.DataSender(
+          serviceProvider.connectToService(mojom.DataSinkProxy.NAME_), 10, 2);
+      sender.send(generateData(100, 'b')).catch(test.callbackPass(function(e) {
+        test.assertEq(1, e.error);
+        test.assertEq(5, e.bytesSent);
+        sender.send(generateData(1)).then(test.callbackPass(
+            function(bytesSent) {
+          test.assertEq(1, bytesSent);
+          sender.close();
+        }));
+      }));
+    });
+  },
+
+  function testSendErrorBetweenPackets() {
+    wrapAsyncTest(
+        function testSend(serviceProvider, dataSender, mojom) {
+      var sender = new dataSender.DataSender(
+          serviceProvider.connectToService(mojom.DataSinkProxy.NAME_), 10, 2);
+      sender.send(generateData(2, 'b')).catch(test.callbackPass(function(e) {
+        test.assertEq(1, e.error);
+        test.assertEq(2, e.bytesSent);
+      }));
+      sender.send(generateData(2, 'b')).catch(test.callbackPass(function(e) {

[raymes, 2014/08/20 04:23:13]

It's easy to forget why this is expected to fail. Maybe make a note here that
after an error all sends in progress will be cancelled.

[Sam McNally, 2014/08/20 04:50:16]

Done.

+        test.assertEq(1, e.error);
+        test.assertEq(0, e.bytesSent);
+        sender.send(generateData(1)).then(test.callbackPass(
+            function(bytesSent) {
+          test.assertEq(1, bytesSent);
+          sender.close();
+        }));
+      }));
+    });
+  },
+
+  function testSendErrorInSecondPacket() {
+    wrapAsyncTest(
+        function testSend(serviceProvider, dataSender, mojom) {
+      var sender = new dataSender.DataSender(
+          serviceProvider.connectToService(mojom.DataSinkProxy.NAME_), 10, 2);
+      sender.send(generateData(2, 'b')).then(test.callbackPass(
+          function(bytesSent) {
+        test.assertEq(2, bytesSent);
+      }));
+      sender.send(generateData(2, 'b')).catch(test.callbackPass(function(e) {
+        test.assertEq(1, e.error);
+        test.assertEq(1, e.bytesSent);
+        sender.send(generateData(1)).then(test.callbackPass(
+            function(bytesSent) {
+          test.assertEq(1, bytesSent);
+          sender.close();
+        }));
+      }));
+    });
+  },
+
+  function testSendErrorBeforeLargeSend() {
+    wrapAsyncTest(
+        function testSend(serviceProvider, dataSender, mojom) {
+      var sender = new dataSender.DataSender(
+          serviceProvider.connectToService(mojom.DataSinkProxy.NAME_), 10, 2);
+      sender.send(generateData(5, 'b')).catch(test.callbackPass(function(e) {
+        test.assertEq(1, e.error);
+        test.assertEq(2, e.bytesSent);
+      }));
+      sender.send(generateData(1000, 'b')).catch(test.callbackPass(function(e) {
+        test.assertEq(1, e.error);
+        test.assertEq(0, e.bytesSent);
+        sender.send(generateData(1)).then(test.callbackPass(
+            function(bytesSent) {
+          test.assertEq(1, bytesSent);
+          sender.close();
+        }));
+      }));
+    });
+  },
+
+  function testCancelWithoutSend() {
+    wrapAsyncTest(
+        function testSend(serviceProvider, dataSender, mojom) {
+      var sender = new dataSender.DataSender(
+          serviceProvider.connectToService(mojom.DataSinkProxy.NAME_), 10, 2);
+      sender.cancel(3).then(test.callbackPass(function() {
+        sender.close();
+      }));
+    });
+  },
+
+  function testCancel() {
+    wrapAsyncTest(
+        function testSend(serviceProvider, dataSender, mojom) {
+      var seen = null;
+      var sender = new dataSender.DataSender(
+          serviceProvider.connectToService(mojom.DataSinkProxy.NAME_), 10, 2);
+      sender.send(generateData(1, 'b')).catch(test.callbackPass(function(e) {
+        test.assertEq(3, e.error);
+        test.assertEq(0, e.bytesSent);
+        test.assertEq(null, seen);
+        seen = 'send';
+      }));
+      sender.cancel(3).then(test.callbackPass(function() {
+        test.assertEq('send', seen);
+        seen = 'cancel';
+        sender.close();
+      }));
+      test.assertThrows(
+          sender.cancel, sender, [], 'Cancel already in progress');
+      test.assertThrows(sender.send, sender, [], 'Cancel in progress');
+    });
+  },
+
+], test.runTests, exports);