Revert of Deletes mojo::Callback

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 <memory>
 #include <utility>
 
@@ skipping 32 matching lines @@
   bool cancelled_;
 
   // If |cancelled_|, contains the cancellation error to report.
   int32_t cancellation_error_;
 };
 
 // A frame of data received from the client.
 class DataSinkReceiver::DataFrame {
  public:
   explicit DataFrame(mojo::Array<uint8_t> data,
-                     const serial::DataSink::OnDataCallback& callback);
+                     const mojo::Callback<void(uint32_t, int32_t)>& callback);
 
   // Returns the number of unconsumed bytes remaining of this data frame.
   uint32_t GetRemainingBytes();
 
   // Returns a pointer to the remaining data to be consumed.
   const char* GetData();
 
   // Reports that |bytes_read| bytes have been consumed.
   void OnDataConsumed(uint32_t bytes_read);
 
   // Reports that an error occurred.
   void ReportError(uint32_t bytes_read, int32_t error);
 
  private:
   mojo::Array<uint8_t> data_;
   uint32_t offset_;
-  const serial::DataSink::OnDataCallback callback_;
+  const mojo::Callback<void(uint32_t, int32_t)> callback_;
 };
 
 DataSinkReceiver::DataSinkReceiver(
     mojo::InterfaceRequest<serial::DataSink> request,
     const ReadyCallback& ready_callback,
     const CancelCallback& cancel_callback,
     const ErrorCallback& error_callback)
     : binding_(this, std::move(request)),
       ready_callback_(ready_callback),
       cancel_callback_(cancel_callback),
@@ skipping 33 matching lines @@
     buffer_in_use_->Cancel(error);
     if (!cancel_callback_.is_null())
       cancel_callback_.Run(error);
     return;
   }
   ReportError(0, error);
 }
 
 void DataSinkReceiver::OnData(
     mojo::Array<uint8_t> data,
-    const serial::DataSink::OnDataCallback& callback) {
+    const mojo::Callback<void(uint32_t, int32_t)>& callback) {
   if (current_error_) {
     callback.Run(0, current_error_);
     return;
   }
   pending_data_buffers_.push(
       linked_ptr<DataFrame>(new DataFrame(std::move(data), callback)));
   if (!buffer_in_use_)
     RunReadyCallback();
 }
 
@@ skipping 114 matching lines @@
                                              int32_t error) {
   scoped_refptr<DataSinkReceiver> receiver = receiver_;
   receiver_ = nullptr;
   receiver->DoneWithError(bytes_read, error);
   buffer_ = NULL;
   buffer_size_ = 0;
 }
 
 DataSinkReceiver::DataFrame::DataFrame(
     mojo::Array<uint8_t> data,
-    const serial::DataSink::OnDataCallback& callback)
+    const mojo::Callback<void(uint32_t, int32_t)>& callback)
     : data_(std::move(data)), offset_(0), callback_(callback) {
   DCHECK_LT(0u, data_.size());
 }
 
 // Returns the number of uncomsumed bytes remaining of this data frame.
 uint32_t DataSinkReceiver::DataFrame::GetRemainingBytes() {
   return static_cast<uint32_t>(data_.size() - offset_);
 }
 
 // Returns a pointer to the remaining data to be consumed.
 const char* DataSinkReceiver::DataFrame::GetData() {
   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());
   if (offset_ == data_.size())
     callback_.Run(offset_, 0);
 }
 void DataSinkReceiver::DataFrame::ReportError(uint32_t bytes_read,
                                               int32_t error) {
   offset_ += bytes_read;
   DCHECK_LE(offset_, data_.size());
   callback_.Run(offset_, error);
 }
 
 }  // namespace device