Revert of Remove Client= from device/serial/data_stream.mojom.

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', [
     'device/serial/data_stream.mojom',
     'device/serial/data_stream_serialization.mojom',
     'mojo/public/js/core',
     'mojo/public/js/router',
 ], function(dataStreamMojom, serialization, core, routerModule) {
@@ skipping 147 matching lines @@
     sink.onData(new Uint8Array(this.data_, 0, numBytesToSend));
     this.data_ = this.data_.slice(numBytesToSend);
     return {
       completed: this.data_.byteLength == 0,
       remainingBufferCapacity: availableBufferCapacity - numBytesToSend,
     };
   };
 
   /**
    * A DataSender that sends data to a DataSink.
-   * @param {!MojoHandle} sink The handle to the DataSink.
-   * @param {!MojoHandle} client The handle to the DataSinkClient.
+   * @param {!MojoHandle} handle The handle to the DataSink.
    * @param {number} bufferSize How large a buffer to use for data.
    * @param {number} fatalErrorValue The send error value to report in the
    *     event of a fatal error.
    * @constructor
    * @alias module:data_sender.DataSender
    */
-  function DataSender(sink, client, bufferSize, fatalErrorValue) {
-    this.init_(sink, client, fatalErrorValue, bufferSize);
+  function DataSender(handle, bufferSize, fatalErrorValue) {
+    this.init_(handle, fatalErrorValue, bufferSize);
     this.sink_.init(bufferSize);
   }
 
   DataSender.prototype =
       $Object.create(dataStreamMojom.DataSinkClient.stubClass.prototype);
 
   /**
    * Closes this DataSender.
    */
   DataSender.prototype.close = function() {
     if (this.shutDown_)
       return;
     this.shutDown_ = true;
     this.router_.close();
-    this.clientRouter_.close();
     while (this.pendingSends_.length) {
       this.pendingSends_.pop().reportBytesSentAndError(
           0, this.fatalErrorValue_);
     }
     while (this.sendsAwaitingAck_.length) {
       this.sendsAwaitingAck_.pop().reportBytesSentAndError(
           0, this.fatalErrorValue_);
     }
     this.callCancelCallback_();
   };
 
   /**
    * Initialize this DataSender.
-   * @param {!MojoHandle} sink A handle to the DataSink.
-   * @param {!MojoHandle} sinkClient A handle to the DataSinkClient.
+   * @param {!MojoHandle} sink A handle to the DataSink
    * @param {number} fatalErrorValue The error to dispatch in the event of a
    *     fatal error.
    * @param {number} bufferSize The size of the send buffer.
    * @private
    */
-  DataSender.prototype.init_ = function(sink, sinkClient, fatalErrorValue,
-                                        bufferSize) {
+  DataSender.prototype.init_ = function(sink, fatalErrorValue, bufferSize) {
     /**
      * The error to be dispatched in the event of a fatal error.
      * @const {number}
      * @private
      */
     this.fatalErrorValue_ = fatalErrorValue;
     /**
      * Whether this DataSender has shut down.
      * @type {boolean}
      * @private
      */
     this.shutDown_ = false;
     /**
      * The [Router]{@link module:mojo/public/js/router.Router} for the
      * connection to the DataSink.
      * @private
      */
     this.router_ = new routerModule.Router(sink);
     /**
-     * The [Router]{@link module:mojo/public/js/router.Router} for the
-     * connection to the DataSinkClient.
-     * @private
-     */
-    this.clientRouter_ = new routerModule.Router(sinkClient);
-    /**
      * The connection to the DataSink.
      * @private
      */
     this.sink_ = new dataStreamMojom.DataSink.proxyClass(this.router_);
-    this.client_ = new dataStreamMojom.DataSinkClient.stubClass(this);
-    this.clientRouter_.setIncomingReceiver(this.client_);
+    this.router_.setIncomingReceiver(this);
     /**
      * A queue of sends that have not fully sent their data to the DataSink.
      * @type {!module:data_sender~PendingSend[]}
      * @private
      */
     this.pendingSends_ = [];
     /**
      * A queue of sends that have sent their data to the DataSink, but have not
      * been received by the DataSink.
      * @type {!module:data_sender~PendingSend[]}
@@ skipping 38 matching lines @@
     var readyToSerialize = Promise.resolve();
     if (this.pendingSends_.length || this.sendsAwaitingAck_.length) {
       if (this.pendingCancel_)
         readyToSerialize = this.cancelPromise_;
       else
         readyToSerialize = this.cancel(this.fatalErrorValue_);
     }
     return readyToSerialize.then(function() {
       var serialized = new serialization.SerializedDataSender();
       serialized.sink = this.router_.connector_.handle_;
-      serialized.client = this.clientRouter_.connector_.handle_;
       serialized.fatal_error_value = this.fatalErrorValue_;
       serialized.buffer_size = this.availableBufferCapacity_;
       this.router_.connector_.handle_ = null;
       this.router_.close();
-      this.clientRouter_.connector_.handle_ = null;
-      this.clientRouter_.close();
       this.shutDown_ = true;
       return serialized;
     }.bind(this));
   };
 
   /**
    * Deserializes a SerializedDataSender.
    * @param {SerializedDataSender} serialized The serialized DataSender.
    * @return {!DataSender} The deserialized DataSender.
    */
   DataSender.deserialize = function(serialized) {
     var sender = $Object.create(DataSender.prototype);
     sender.deserialize_(serialized);
     return sender;
   };
 
   /**
    * Deserializes a SerializedDataSender into this DataSender.
    * @param {SerializedDataSender} serialized The serialized DataSender.
    * @private
    */
   DataSender.prototype.deserialize_ = function(serialized) {
     if (!serialized) {
       this.shutDown_ = true;
       return;
     }
-    this.init_(serialized.sink, serialized.client, serialized.fatal_error_value,
-               serialized.buffer_size);
+    this.init_(
+        serialized.sink, serialized.fatal_error_value, serialized.buffer_size);
   };
 
   /**
    * 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 104 matching lines @@
       // Note: Only the first PendingSend in |pendingSends_| will have data to
       // flush as only the first can have sent data to the DataSink.
       this.availableBufferCapacity_ += result.bytesToFlush;
     }
     this.callCancelCallback_();
     return Promise.resolve();
   };
 
   return {DataSender: DataSender};
 });