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

extensions/renderer/resources/data_receiver.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_receiver', [
     'device/serial/data_stream.mojom',
     'device/serial/data_stream_serialization.mojom',
     'mojo/public/js/core',
     'mojo/public/js/router',
 ], function(dataStream, serialization, core, router) {
@@ skipping 68 matching lines @@
    * @param {number} error The error to dispatch.
    */
   PendingReceive.prototype.dispatchFatalError = function(error) {
     var e = new Error();
     e.error = error;
     this.errorCallback_(e);
   };
 
   /**
    * A DataReceiver that receives data from a DataSource.
-   * @param {!MojoHandle} source The handle to the DataSource.
-   * @param {!MojoHandle} client The handle to the DataSourceClient.
+   * @param {!MojoHandle} handle The handle to the DataSource.
    * @param {number} bufferSize How large a buffer to use.
    * @param {number} fatalErrorValue The receive error value to report in the
    *     event of a fatal error.
    * @constructor
    * @alias module:data_receiver.DataReceiver
    */
-  function DataReceiver(source, client, bufferSize, fatalErrorValue) {
-    this.init_(source, client, fatalErrorValue, 0, null, [], false);
+  function DataReceiver(handle, bufferSize, fatalErrorValue) {
+    this.init_(handle, fatalErrorValue, 0, null, [], false);
     this.source_.init(bufferSize);
   }
 
   DataReceiver.prototype =
       $Object.create(dataStream.DataSourceClient.stubClass.prototype);
 
   /**
    * Closes this DataReceiver.
    */
   DataReceiver.prototype.close = function() {
     if (this.shutDown_)
       return;
     this.shutDown_ = true;
     this.router_.close();
-    this.clientRouter_.close();
     if (this.receive_) {
       this.receive_.dispatchFatalError(this.fatalErrorValue_);
       this.receive_ = null;
     }
   };
 
   /**
    * Initialize this DataReceiver.
-   * @param {!MojoHandle} source A handle to the DataSource.
-   * @param {!MojoHandle} client A handle to the DataSourceClient.
+   * @param {!MojoHandle} source A handle to the DataSource
    * @param {number} fatalErrorValue The error to dispatch in the event of a
    *     fatal error.
    * @param {number} bytesReceived The number of bytes already received.
    * @param {PendingReceiveError} pendingError The pending error if there is
    *     one.
    * @param {!Array.<!ArrayBuffer>} pendingData Data received from the
    *     DataSource not yet requested by the client.
    * @param {boolean} paused Whether the DataSource is paused.
    * @private
    */
-  DataReceiver.prototype.init_ = function(source, client, fatalErrorValue,
-                                          bytesReceived, pendingError,
-                                          pendingData, paused) {
+  DataReceiver.prototype.init_ = function(source,
+                                          fatalErrorValue,
+                                          bytesReceived,
+                                          pendingError,
+                                          pendingData,
+                                          paused) {
     /**
      * The [Router]{@link module:mojo/public/js/router.Router} for the
      * connection to the DataSource.
      * @private
      */
     this.router_ = new router.Router(source);
     /**
-     * The [Router]{@link module:mojo/public/js/router.Router} for the
-     * connection to the DataSource.
-     * @private
-     */
-    this.clientRouter_ = new router.Router(client);
-    /**
      * The connection to the DataSource.
      * @private
      */
     this.source_ = new dataStream.DataSource.proxyClass(this.router_);
-    this.client_ = new dataStream.DataSourceClient.stubClass(this);
-    this.clientRouter_.setIncomingReceiver(this.client_);
+    this.router_.setIncomingReceiver(this);
     /**
      * The current receive operation.
      * @type {module:data_receiver~PendingReceive}
      * @private
      */
     this.receive_ = null;
     /**
      * The error to be dispatched in the event of a fatal error.
      * @const {number}
      * @private
@@ skipping 36 matching lines @@
   DataReceiver.prototype.serialize = function() {
     if (this.shutDown_)
       return Promise.resolve(null);
 
     if (this.receive_) {
       this.receive_.dispatchFatalError(this.fatalErrorValue_);
       this.receive_ = null;
     }
     var serialized = new serialization.SerializedDataReceiver();
     serialized.source = this.router_.connector_.handle_;
-    serialized.client = this.clientRouter_.connector_.handle_;
     serialized.fatal_error_value = this.fatalErrorValue_;
     serialized.paused = this.paused_;
     serialized.pending_error = this.pendingError_;
     serialized.pending_data = [];
     $Array.forEach(this.pendingDataBuffers_, function(buffer) {
       serialized.pending_data.push(new Uint8Array(buffer));
     });
     this.router_.connector_.handle_ = null;
     this.router_.close();
-    this.clientRouter_.connector_.handle_ = null;
-    this.clientRouter_.close();
     this.shutDown_ = true;
     return Promise.resolve(serialized);
   };
 
   /**
    * Deserializes a SerializedDataReceiver.
    * @param {SerializedDataReceiver} serialized The serialized DataReceiver.
    * @return {!DataReceiver} The deserialized DataReceiver.
    */
   DataReceiver.deserialize = function(serialized) {
@@ skipping 11 matching lines @@
     if (!serialized) {
       this.shutDown_ = true;
       return;
     }
     var pendingData = [];
     $Array.forEach(serialized.pending_data, function(data) {
       var buffer = new Uint8Array(data.length);
       buffer.set(data);
       pendingData.push(buffer.buffer);
     });
-    this.init_(serialized.source, serialized.client,
-               serialized.fatal_error_value, serialized.bytes_received,
-               serialized.pending_error, pendingData, serialized.paused);
+    this.init_(serialized.source,
+               serialized.fatal_error_value,
+               serialized.bytes_received,
+               serialized.pending_error,
+               pendingData,
+               serialized.paused);
   };
 
   /**
    * Receive data from the DataSource.
    * @return {Promise.<ArrayBuffer>} A promise to the received data. 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 another receive
    *     is in progress.
    */
@@ skipping 59 matching lines @@
     var buffer = new ArrayBuffer(data.length);
     var uintView = new Uint8Array(buffer);
     uintView.set(data);
     this.pendingDataBuffers_.push(buffer);
     if (this.receive_)
       this.dispatchData_();
   };
 
   return {DataReceiver: DataReceiver};
 });