Convert SerialIoHandler to use buffer interfaces for I/O API methods.

device/serial/serial_io_handler.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/serial_io_handler.h"
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_util.h"
 
 namespace device {
 
 SerialIoHandler::SerialIoHandler(
     scoped_refptr<base::MessageLoopProxy> file_thread_message_loop)
-    : pending_read_buffer_len_(0),
-      pending_write_buffer_len_(0),
-      file_thread_message_loop_(file_thread_message_loop) {
+    : file_thread_message_loop_(file_thread_message_loop) {
 }
 
 SerialIoHandler::~SerialIoHandler() {
   DCHECK(CalledOnValidThread());
   Close();
 }
 
-void SerialIoHandler::Initialize(const ReadCompleteCallback& read_callback,
-                                 const WriteCompleteCallback& write_callback) {
-  DCHECK(CalledOnValidThread());
-  read_complete_ = read_callback;
-  write_complete_ = write_callback;
-}
-
 void SerialIoHandler::Open(const std::string& port,
                            const OpenCompleteCallback& callback) {
   DCHECK(CalledOnValidThread());
   DCHECK(open_complete_.is_null());
   open_complete_ = callback;
   DCHECK(file_thread_message_loop_);
   file_thread_message_loop_->PostTask(
       FROM_HERE,
       base::Bind(&SerialIoHandler::StartOpen,
                  this,
@@ skipping 51 matching lines @@
     file_thread_message_loop_->PostTask(
         FROM_HERE, base::Bind(&SerialIoHandler::DoClose, Passed(file_.Pass())));
   }
 }
 
 // static
 void SerialIoHandler::DoClose(base::File port) {
   // port closed by destructor.
 }
 
-void SerialIoHandler::Read(int max_bytes) {
+void SerialIoHandler::Read(scoped_ptr<WritableBuffer> buffer) {
   DCHECK(CalledOnValidThread());
   DCHECK(!IsReadPending());
-  pending_read_buffer_ = new net::IOBuffer(max_bytes);
-  pending_read_buffer_len_ = max_bytes;
+  pending_read_buffer_ = buffer.Pass();
   read_canceled_ = false;
   AddRef();
   ReadImpl();
 }
 
-void SerialIoHandler::Write(const std::string& data) {
+void SerialIoHandler::Write(scoped_ptr<ReadOnlyBuffer> buffer) {
   DCHECK(CalledOnValidThread());
   DCHECK(!IsWritePending());
-  int length = static_cast<int>(data.length());
-  pending_write_buffer_ = new net::IOBuffer(length);
-  pending_write_buffer_len_ = length;
-  memcpy(pending_write_buffer_->data(), data.data(), pending_write_buffer_len_);
+  pending_write_buffer_ = buffer.Pass();
   write_canceled_ = false;
   AddRef();
   WriteImpl();
 }
 
 void SerialIoHandler::ReadCompleted(int bytes_read,
                                     serial::ReceiveError error) {
   DCHECK(CalledOnValidThread());
   DCHECK(IsReadPending());
-  read_complete_.Run(std::string(pending_read_buffer_->data(), bytes_read),
-                     error);
-  pending_read_buffer_ = NULL;
-  pending_read_buffer_len_ = 0;
+  if (error == serial::RECEIVE_ERROR_NONE) {
+    pending_read_buffer_->Done(bytes_read);
+  } else {
+    pending_read_buffer_->DoneWithError(bytes_read, error);
+  }
+  pending_read_buffer_.reset();
   Release();
 }
 
 void SerialIoHandler::WriteCompleted(int bytes_written,
                                      serial::SendError error) {
   DCHECK(CalledOnValidThread());
   DCHECK(IsWritePending());
-  write_complete_.Run(bytes_written, error);
-  pending_write_buffer_ = NULL;
-  pending_write_buffer_len_ = 0;
+  if (error == serial::SEND_ERROR_NONE) {
+    pending_write_buffer_->Done(bytes_written);
+  } else {
+    pending_write_buffer_->DoneWithError(bytes_written, error);
+  }
+  pending_write_buffer_.reset();
   Release();
 }
 
 bool SerialIoHandler::IsReadPending() const {
   DCHECK(CalledOnValidThread());
   return pending_read_buffer_ != NULL;
 }
 
 bool SerialIoHandler::IsWritePending() const {
   DCHECK(CalledOnValidThread());
@@ skipping 26 matching lines @@
 }
 
 void SerialIoHandler::QueueWriteCompleted(int bytes_written,
                                           serial::SendError error) {
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&SerialIoHandler::WriteCompleted, this, bytes_written, error));
 }
 
 }  // namespace device