Convert SerialIoHandler to use Mojo types.

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

 // Copyright 2012 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 <deque>
 #include <string>
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
 #include "chrome/browser/extensions/api/serial/serial_api.h"
@@ skipping 46 matching lines @@
   explicit FakeEchoSerialIoHandler() : opened_(false) {}
 
   virtual void Open(const std::string& port,
                     const OpenCompleteCallback& callback) OVERRIDE {
     DCHECK(!opened_);
     opened_ = true;
     callback.Run(true);
   }
 
   virtual bool ConfigurePort(
-      const api::serial::ConnectionOptions& options) OVERRIDE {
+      const device::ConnectionOptions& options) OVERRIDE {
     return true;
   }
 
   virtual void ReadImpl() OVERRIDE {}
 
   virtual void CancelReadImpl() OVERRIDE {
     QueueReadCompleted(0, read_cancel_reason());
   }
 
   virtual void WriteImpl() OVERRIDE {
     DCHECK(pending_read_buffer());
     DCHECK_LE(pending_write_buffer_len(), pending_read_buffer_len());
     memcpy(pending_read_buffer()->data(),
            pending_write_buffer()->data(),
            pending_write_buffer_len());
-    QueueReadCompleted(pending_write_buffer_len(),
-                       api::serial::RECEIVE_ERROR_NONE);
-    QueueWriteCompleted(pending_write_buffer_len(),
-                        api::serial::SEND_ERROR_NONE);
+    QueueReadCompleted(pending_write_buffer_len(), device::RECEIVE_ERROR_NONE);
+    QueueWriteCompleted(pending_write_buffer_len(), device::SEND_ERROR_NONE);
   }
 
   virtual void CancelWriteImpl() OVERRIDE {
     QueueWriteCompleted(0, write_cancel_reason());
   }
 
-  virtual bool GetControlSignals(
-      api::serial::DeviceControlSignals* signals) const OVERRIDE {
+  virtual device::DeviceControlSignalsPtr GetControlSignals() const OVERRIDE {
+    device::DeviceControlSignalsPtr signals(
+        device::DeviceControlSignals::New());
     signals->dcd = true;
     signals->cts = true;
     signals->ri = true;
     signals->dsr = true;
-    return true;
+    return signals.Pass();
   }
 
-  virtual bool GetPortInfo(api::serial::ConnectionInfo* info) const OVERRIDE {
-    info->bitrate.reset(new int(9600));
-    info->data_bits = api::serial::DATA_BITS_EIGHT;
-    info->parity_bit = api::serial::PARITY_BIT_NO;
-    info->stop_bits = api::serial::STOP_BITS_ONE;
-    info->cts_flow_control.reset(new bool(false));
-    return true;
+  virtual device::ConnectionInfoPtr GetPortInfo() const OVERRIDE {
+    device::ConnectionInfoPtr info(device::ConnectionInfo::New());
+    info->bitrate = 9600;
+    info->data_bits = device::DATA_BITS_EIGHT;
+    info->parity_bit = device::PARITY_BIT_NO;
+    info->stop_bits = device::STOP_BITS_ONE;
+    info->cts_flow_control = false;
+    return info.Pass();
   }
 
   virtual bool Flush() const OVERRIDE { return true; }
 
-  MOCK_METHOD1(SetControlSignals, bool(const api::serial::HostControlSignals&));
+  MOCK_METHOD1(SetControlSignals, bool(const device::HostControlSignals&));
 
  protected:
   virtual ~FakeEchoSerialIoHandler() {}
 
  private:
   bool opened_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeEchoSerialIoHandler);
 };
 
@@ skipping 59 matching lines @@
 
   ASSERT_TRUE(RunExtensionTest("serial/api")) << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(SerialApiTest, SerialRealHardware) {
   ResultCatcher catcher;
   catcher.RestrictToProfile(browser()->profile());
 
   ASSERT_TRUE(RunExtensionTest("serial/real_hardware")) << message_;
 }