Add serialization support to the JS DataSender and DataReceiver.

extensions/test/data/data_receiver_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_receiver_unittest.cc
 
 var test = require('test').binding;
 var unittestBindings = require('test_environment_specific_bindings');
 
-var fatalErrorValue = 2;
-var bufferSize = 10;
+var BUFFER_SIZE = 10;
+var FATAL_ERROR = 2;
 
+// Returns a promise to a newly created DataReceiver.
 function createReceiver() {
   return Promise.all([
     requireAsync('content/public/renderer/service_provider'),
     requireAsync('data_receiver'),
     requireAsync('device/serial/data_stream.mojom'),
-  ]).then(test.callbackPass(function(modules) {
+  ]).then(function(modules) {
     var serviceProvider = modules[0];
     var dataReceiver = modules[1];
     var dataStream = modules[2];
     return new dataReceiver.DataReceiver(
         serviceProvider.connectToService(dataStream.DataSourceProxy.NAME_),
-        bufferSize,
-        fatalErrorValue);
-  }));
+        BUFFER_SIZE,
+        FATAL_ERROR);
+  });
+}
+
+// Returns a promise that will resolve to |receiver| when it has received an
+// error from its DataSource.
+function waitForReceiveError(receiver) {
+  return new Promise(function(resolve, reject) {
+    var onError = receiver.onError;
+    receiver.onError = function() {
+      $Function.apply(onError, receiver, arguments);
+      resolve(receiver);
+    };
+  });
+}
+
+// Returns a function that receives data from a provided DataReceiver
+// |receiver|, checks that it matches the expected data and returns a promise
+// that will resolve to |receiver|.
+function receiveAndCheckData(expectedData) {
+  return function(receiver) {
+    return receiver.receive().then(function(data) {
+      test.assertEq(expectedData.length, data.byteLength);
+      for (var i = 0; i < expectedData.length; i++)
+        test.assertEq(expectedData.charCodeAt(i), new Int8Array(data)[i]);
+      return receiver;
+    });
+    test.assertThrows(
+        receiver.receive, receiver, [], 'Receive already in progress.');
+  };
+}
+
+// Returns a function that attempts to receive data from a provided DataReceiver
+// |receiver|, checks that the correct error is reported and returns a promise
+// that will resolve to |receiver|.
+function receiveAndCheckError(expectedError) {
+  return function(receiver) {
+    return receiver.receive().catch(function(error) {
+      test.assertEq(expectedError, error.error);
+      return receiver;
+    });
+    test.assertThrows(
+        receiver.receive, receiver, [], 'Receive already in progress.');
+  };
+}
+
+// Serializes and deserializes the provided DataReceiver |receiver|, returning
+// a promise that will resolve to the newly deserialized DataReceiver.
+function serializeRoundTrip(receiver) {
+  return Promise.all([
+    receiver.serialize(),
+    requireAsync('data_receiver'),
+  ]).then(function(promises) {
+    var serialized = promises[0];
+    var dataReceiverModule = promises[1];
+    return dataReceiverModule.DataReceiver.deserialize(serialized);
+  });
+}
+
+// Closes and returns the provided DataReceiver |receiver|.
+function closeReceiver(receiver) {
+  receiver.close();
+  return receiver;
 }
 
 unittestBindings.exportTests([
   function testReceive() {
-    createReceiver().then(test.callbackPass(function(receiver) {
-      receiver.receive().then(test.callbackPass(function(data) {
-        test.assertEq(1, data.byteLength);
-        test.assertEq('a'.charCodeAt(0), new Int8Array(data)[0]);
-        receiver.close();
-      }));
-      test.assertThrows(
-          receiver.receive, receiver, [], 'Receive already in progress.');
-    }));
+    createReceiver()
+        .then(receiveAndCheckData('a'))
+        .then(closeReceiver)
+        .then(test.succeed, test.fail);
   },
 
   function testReceiveError() {
-    createReceiver().then(test.callbackPass(function(receiver) {
-      receiver.receive().catch(test.callbackPass(function(error) {
-        test.assertEq(1, error.error);
-        receiver.close();
-      }));
-    }));
+    createReceiver()
+        .then(receiveAndCheckError(1))
+        .then(closeReceiver)
+        .then(test.succeed, test.fail);
   },
 
   function testReceiveDataAndError() {
-    createReceiver().then(test.callbackPass(function(receiver) {
-      receiver.receive().then(test.callbackPass(function(data) {
-        test.assertEq(1, data.byteLength);
-        test.assertEq('a'.charCodeAt(0), new Int8Array(data)[0]);
-        return receiver.receive();
-      })).catch(test.callbackPass(function(error) {
-        test.assertEq(1, error.error);
-        return receiver.receive();
-      })).then(test.callbackPass(function(data) {
-        test.assertEq(1, data.byteLength);
-        test.assertEq('b'.charCodeAt(0), new Int8Array(data)[0]);
-        receiver.close();
-      }));
-    }));
+    createReceiver()
+        .then(receiveAndCheckData('a'))
+        .then(receiveAndCheckError(1))
+        .then(receiveAndCheckData('b'))
+        .then(closeReceiver)
+        .then(test.succeed, test.fail);
   },
 
   function testReceiveErrorThenData() {
-    createReceiver().then(test.callbackPass(function(receiver) {
-      receiver.receive().catch(test.callbackPass(function(error) {
-        test.assertEq(1, error.error);
-        return receiver.receive();
-      })).then(test.callbackPass(function(data) {
-        test.assertEq(1, data.byteLength);
-        test.assertEq('a'.charCodeAt(0), new Int8Array(data)[0]);
-        receiver.close();
-      }));
-    }));
+    createReceiver()
+        .then(receiveAndCheckError(1))
+        .then(receiveAndCheckData('a'))
+        .then(closeReceiver)
+        .then(test.succeed, test.fail);
+  },
+
+  function testReceiveBeforeAndAfterSerialization() {
+    createReceiver()
+        .then(receiveAndCheckData('a'))
+        .then(serializeRoundTrip)
+        .then(receiveAndCheckData('b'))
+        .then(closeReceiver)
+        .then(test.succeed, test.fail);
+  },
+
+  function testReceiveErrorSerialization() {
+    createReceiver()
+        .then(waitForReceiveError)
+        .then(serializeRoundTrip)
+        .then(receiveAndCheckError(1))
+        .then(receiveAndCheckError(3))
+        .then(closeReceiver)
+        .then(test.succeed, test.fail);
+  },
+
+  function testReceiveDataAndErrorSerialization() {
+    createReceiver()
+        .then(waitForReceiveError)
+        .then(receiveAndCheckData('a'))
+        .then(serializeRoundTrip)
+        .then(receiveAndCheckError(1))
+        .then(receiveAndCheckData('b'))
+        .then(receiveAndCheckError(3))
+        .then(closeReceiver)
+        .then(test.succeed, test.fail);
+  },
+
+  function testSerializeDuringReceive() {
+    var receiver = createReceiver();
+    Promise.all([
+        receiver.then(receiveAndCheckError(FATAL_ERROR)),
+        receiver
+            .then(serializeRoundTrip)
+            .then(receiveAndCheckData('a'))
+            .then(closeReceiver)
+    ]).then(test.succeed, test.fail);
+  },
+
+  function testSerializeAfterClose() {
+    function receiveAfterClose(receiver) {
+      test.assertThrows(
+          receiver.receive, receiver, [], 'DataReceiver has been closed');
+    }
+
+    createReceiver()
+        .then(closeReceiver)
+        .then(serializeRoundTrip)
+        .then(receiveAfterClose)
+        .then(test.succeed, test.fail);
   },
 
   function testSourceShutdown() {
-    createReceiver().then(test.callbackPass(function(receiver) {
-      receiver.receive().catch(test.callbackPass(function(error) {
-        test.assertEq(fatalErrorValue, error.error);
-        receiver.close();
-      }));
-    }));
+    createReceiver()
+        .then(receiveAndCheckError(FATAL_ERROR))
+        .then(closeReceiver)
+        .then(test.succeed, test.fail);
   },
 
 ], test.runTests, exports);