Add serialization support to the JS DataSender and DataReceiver.

extensions/renderer/resources/data_sender.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.
 
 define('data_sender', [
     'async_waiter',
     'device/serial/data_stream.mojom',
     'mojo/public/js/bindings/core',
     'mojo/public/js/bindings/router',
 ], function(asyncWaiter, dataStreamMojom, core, routerModule) {
@@ skipping 239 matching lines @@
     this.router_.close();
     core.close(this.sendPipe_);
     while (this.pendingSends_.length) {
       this.pendingSends_.pop().reportBytesSentAndError(
           0, this.fatalErrorValue_);
     }
     while (this.sendsAwaitingAck_.length) {
       this.sendsAwaitingAck_.pop().reportBytesSentAndError(
           0, this.fatalErrorValue_);
     }
-    if (this.pendingCancel_) {
-      this.pendingCancel_();
-      this.pendingCancel_ = null;
+    this.callCancelCallback_();
+  };
+
+  DataSender.prototype.serialize = function() {
+    var readyToSerialize = Promise.resolve();
+    if (this.pendingSends_.length) {
+      if (this.pendingCancel_)
+        readyToSerialize = this.cancelPromise_;
+      else
+        readyToSerialize = this.cancel(this.fatalErrorValue_);
     }
+    return readyToSerialize.then(function() {
+      this.waiter_.stop();
+      var serialized = {
+        sink: this.router_.connector_.handle_,
+        data_pipe: this.sendPipe_,
+        fatal_error_value: this.fatalErrorValue_,
+        shut_down: this.shutDown_,
+      };
+      this.router_.connector_.handle_ = null;
+      this.router_.close();
+      this.shutDown_ = true;
+      return serialized;
+    }.bind(this));
+  };
+
+  DataSender.deserialize = function(serialized) {
+    var sender = $Object.create(DataSender.prototype);
+    sender.deserialize_(serialized);
+    return sender;
+  };
+
+  DataSender.prototype.deserialize_ = function(serialized) {
+    this.sendPipe_ = serialized.data_pipe;
+    this.fatalErrorValue_ = serialized.fatal_error_value;
+    this.shutDown_ = serialized.shut_down;
+    this.router_ = new routerModule.Router(serialized.sink);
+    this.sink_ = new dataStreamMojom.DataSinkProxy(this.router_);
+    this.router_.setIncomingReceiver(this);
+    this.waiter_ = new asyncWaiter.AsyncWaiter(this.sendPipe_,
+                                               core.HANDLE_SIGNAL_WRITABLE,
+                                               this.onHandleReady_.bind(this));
+    this.pendingSends_ = [];
+    this.sendsAwaitingAck_ = [];
   };
 
   /**
    * Sends data to the DataSink.
    * @return {Promise.<number>} A promise to the number of bytes sent. If an
    *     error occurs, the promise will reject with an Error object with a
    *     property error containing the error code.
    * @throws Will throw if this has encountered a fatal error or a cancel is in
    *     progress.
    */
@@ skipping 20 matching lines @@
    */
   DataSender.prototype.cancel = function(error) {
     if (this.shutDown_)
       throw new Error('DataSender has been closed');
     if (this.pendingCancel_)
       throw new Error('Cancel already in progress');
     if (this.pendingSends_.length + this.sendsAwaitingAck_.length == 0)
       return Promise.resolve();
 
     this.sink_.cancel(error);
-    return new Promise(function(resolve) {
+    this.cancelPromise_ = new Promise(function(resolve) {
       this.pendingCancel_ = resolve;
     }.bind(this));
+    return this.cancelPromise_;
   };
 
   /**
    * Invoked when |handle_| is ready to write. Writes to the data pipe if the
    * wait is successful.
    * @param {number} waitResult The result of the asynchronous wait.
    * @private
    */
   DataSender.prototype.onHandleReady_ = function(result) {
     if (result != core.RESULT_OK) {
@@ skipping 13 matching lines @@
       }
     }
   };
 
   /**
    * Calls and clears the pending cancel callback if one is pending.
    * @private
    */
   DataSender.prototype.callCancelCallback_ = function() {
     if (this.pendingCancel_) {
+      this.cancelPromise_ = null;
       this.pendingCancel_();
       this.pendingCancel_ = null;
     }
   };
 
   /**
    * Invoked by the DataSink to report that data has been successfully sent.
    * @param {number} numBytes The number of bytes sent.
    * @private
    */
@@ skipping 38 matching lines @@
       // Note: Only the first PendingSend in |pendingSends_| will have data to
       // flush as only the first can have written data to the data pipe.
       bytesToFlush += result.bytesToFlush;
     }
     this.callCancelCallback_();
     return Promise.resolve({bytes_to_flush: bytesToFlush});
   };
 
   return {DataSender: DataSender};
 });