Convert SerialIoHandler to use Mojo types.

chrome/browser/extensions/api/serial/serial_io_handler.cc

 // Copyright 2013 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 "chrome/browser/extensions/api/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"
@@ skipping 101 matching lines @@
   DCHECK(!IsWritePending());
   pending_write_buffer_ = new net::IOBuffer(data.length());
   pending_write_buffer_len_ = data.length();
   memcpy(pending_write_buffer_->data(), data.data(), pending_write_buffer_len_);
   write_canceled_ = false;
   AddRef();
   WriteImpl();
 }
 
 void SerialIoHandler::ReadCompleted(int bytes_read,
-                                    api::serial::ReceiveError error) {
+                                    device::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;
   Release();
 }
 
 void SerialIoHandler::WriteCompleted(int bytes_written,
-                                     api::serial::SendError error) {
+                                     device::SendError error) {
   DCHECK(CalledOnValidThread());
   DCHECK(IsWritePending());
   write_complete_.Run(bytes_written, error);
   pending_write_buffer_ = NULL;
   pending_write_buffer_len_ = 0;
   Release();
 }
 
 bool SerialIoHandler::IsReadPending() const {
   DCHECK(CalledOnValidThread());
   return pending_read_buffer_ != NULL;
 }
 
 bool SerialIoHandler::IsWritePending() const {
   DCHECK(CalledOnValidThread());
   return pending_write_buffer_ != NULL;
 }
 
-void SerialIoHandler::CancelRead(api::serial::ReceiveError reason) {
+void SerialIoHandler::CancelRead(device::ReceiveError reason) {
   DCHECK(CalledOnValidThread());
   if (IsReadPending()) {
     read_canceled_ = true;
     read_cancel_reason_ = reason;
     CancelReadImpl();
   }
 }
 
-void SerialIoHandler::CancelWrite(api::serial::SendError reason) {
+void SerialIoHandler::CancelWrite(device::SendError reason) {
   DCHECK(CalledOnValidThread());
   if (IsWritePending()) {
     write_canceled_ = true;
     write_cancel_reason_ = reason;
     CancelWriteImpl();
   }
 }
 
 void SerialIoHandler::QueueReadCompleted(int bytes_read,
-                                         api::serial::ReceiveError error) {
+                                         device::ReceiveError error) {
   base::MessageLoop::current()->PostTask(
       FROM_HERE, base::Bind(&SerialIoHandler::ReadCompleted, this,
                             bytes_read, error));
 }
 
 void SerialIoHandler::QueueWriteCompleted(int bytes_written,
-                                          api::serial::SendError error) {
+                                          device::SendError error) {
   base::MessageLoop::current()->PostTask(
       FROM_HERE, base::Bind(&SerialIoHandler::WriteCompleted, this,
                             bytes_written, error));
 }
 
 }  // namespace extensions