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

device/serial/data_sink_receiver.cc

 // 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.
 
 #include "device/serial/data_sink_receiver.h"
 
 #include <limits>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 43 matching lines @@
   const char* GetData();
 
   // Reports that |bytes_read| bytes have been consumed.
   void OnDataConsumed(uint32_t bytes_read);
 
  private:
   mojo::Array<uint8_t> data_;
   uint32_t offset_;
 };
 
-DataSinkReceiver::DataSinkReceiver(
-    mojo::InterfaceRequest<serial::DataSink> request,
-    mojo::InterfacePtr<serial::DataSinkClient> client,
-    const ReadyCallback& ready_callback,
-    const CancelCallback& cancel_callback,
-    const ErrorCallback& error_callback)
-    : binding_(this, request.Pass()),
-      client_(client.Pass()),
-      ready_callback_(ready_callback),
+DataSinkReceiver::DataSinkReceiver(const ReadyCallback& ready_callback,
+                                   const CancelCallback& cancel_callback,
+                                   const ErrorCallback& error_callback)
+    : ready_callback_(ready_callback),
       cancel_callback_(cancel_callback),
       error_callback_(error_callback),
       flush_pending_(false),
       buffer_in_use_(NULL),
       initialized_(false),
       available_buffer_capacity_(0),
       shut_down_(false),
       weak_factory_(this) {
-  binding_.set_error_handler(this);
-  client_.set_error_handler(this);
 }
 
 void DataSinkReceiver::ShutDown() {
   shut_down_ = true;
 }
 
 DataSinkReceiver::~DataSinkReceiver() {
 }
 
 void DataSinkReceiver::Init(uint32_t buffer_size) {
@@ skipping 58 matching lines @@
   buffer_in_use_ =
       new Buffer(this,
                  pending_data_buffers_.front()->GetData(),
                  pending_data_buffers_.front()->GetRemainingBytes());
   ready_callback_.Run(scoped_ptr<ReadOnlyBuffer>(buffer_in_use_));
 }
 
 void DataSinkReceiver::Done(uint32_t bytes_read) {
   if (!DoneInternal(bytes_read))
     return;
-  client_->ReportBytesSent(bytes_read);
+  client()->ReportBytesSent(bytes_read);
   if (!pending_data_buffers_.empty()) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&DataSinkReceiver::RunReadyCallback,
                    weak_factory_.GetWeakPtr()));
   }
 }
 
 void DataSinkReceiver::DoneWithError(uint32_t bytes_read, int32_t error) {
   if (!DoneInternal(bytes_read))
@@ skipping 12 matching lines @@
   if (pending_data_buffers_.front()->GetRemainingBytes() == 0)
     pending_data_buffers_.pop();
   return true;
 }
 
 void DataSinkReceiver::ReportBytesSentAndError(uint32_t bytes_read,
                                                int32_t error) {
   // When we encounter an error, we must discard the data from any send buffers
   // transmitted by the DataSinkClient before it receives this error.
   flush_pending_ = true;
-  client_->ReportBytesSentAndError(
-      bytes_read, error,
+  client()->ReportBytesSentAndError(
+      bytes_read,
+      error,
       base::Bind(&DataSinkReceiver::DoFlush, weak_factory_.GetWeakPtr()));
 }
 
 void DataSinkReceiver::DoFlush() {
   DCHECK(flush_pending_);
   flush_pending_ = false;
   while (!pending_data_buffers_.empty()) {
     available_buffer_capacity_ +=
         pending_data_buffers_.front()->GetRemainingBytes();
     pending_data_buffers_.pop();
@@ skipping 76 matching lines @@
   DCHECK_LT(offset_, data_.size());
   return reinterpret_cast<const char*>(&data_[0]) + offset_;
 }
 
 void DataSinkReceiver::DataFrame::OnDataConsumed(uint32_t bytes_read) {
   offset_ += bytes_read;
   DCHECK_LE(offset_, data_.size());
 }
 
 }  // namespace device