Rename serial.[open,close] to [connect,disconnect]

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

 // Copyright (c) 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 82 matching lines @@
   }
 
   virtual bool GetControlSignals(api::serial::ControlSignals* signals) const {
     signals->dcd.reset(new bool(true));
     signals->cts.reset(new bool(true));
     signals->dtr.reset(new bool(true));
     signals->ri.reset(new bool(true));
     return true;
   }
 
+  virtual bool GetInfo(api::serial::ConnectionInfo* info) const {
+    info->paused = false;
+    info->persistent = false;
+    info->buffer_size = 4096;
+    info->receive_timeout = 0;
+    info->send_timeout = 0;
+    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;
+  }
+
   MOCK_METHOD1(SetControlSignals, bool(const api::serial::ControlSignals&));
 
  private:
   bool opened_;
   ReceiveCompleteCallback read_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeEchoSerialConnection);
 };
 
-class FakeSerialOpenFunction : public api::SerialOpenFunction {
+class FakeSerialConnectFunction : public api::SerialConnectFunction {
  protected:
   virtual SerialConnection* CreateSerialConnection(
       const std::string& port,
       const std::string& owner_extension_id) const OVERRIDE {
     FakeEchoSerialConnection* serial_connection =
         new FakeEchoSerialConnection(port, owner_extension_id);
     EXPECT_CALL(*serial_connection, SetControlSignals(_)).
         Times(1).WillOnce(Return(true));
     return serial_connection;
   }
 
  protected:
-  virtual ~FakeSerialOpenFunction() {}
+  virtual ~FakeSerialConnectFunction() {}
 };
 
 }  // namespace extensions
 
 ExtensionFunction* FakeSerialGetDevicesFunctionFactory() {
   return new extensions::FakeSerialGetDevicesFunction();
 }
 
-ExtensionFunction* FakeSerialOpenFunctionFactory() {
-  return new extensions::FakeSerialOpenFunction();
+ExtensionFunction* FakeSerialConnectFunctionFactory() {
+  return new extensions::FakeSerialConnectFunction();
 }
 
 // Disable SIMULATE_SERIAL_PORTS only if all the following are true:
 //
 // 1. You have an Arduino or compatible board attached to your machine and
 // properly appearing as the first virtual serial port ("first" is very loosely
 // defined as whichever port shows up in serial.getPorts). We've tested only
 // the Atmega32u4 Breakout Board and Arduino Leonardo; note that both these
 // boards are based on the Atmel ATmega32u4, rather than the more common
 // Arduino '328p with either FTDI or '8/16u2 USB interfaces. TODO: test more
@@ skipping 11 matching lines @@
 #define SIMULATE_SERIAL_PORTS (1)
 IN_PROC_BROWSER_TEST_F(SerialApiTest, SerialFakeHardware) {
   ResultCatcher catcher;
   catcher.RestrictToProfile(browser()->profile());
 
 #if SIMULATE_SERIAL_PORTS
   ASSERT_TRUE(ExtensionFunctionDispatcher::OverrideFunction(
       "serial.getDevices",
       FakeSerialGetDevicesFunctionFactory));
   ASSERT_TRUE(ExtensionFunctionDispatcher::OverrideFunction(
-      "serial.open",
-      FakeSerialOpenFunctionFactory));
+      "serial.connect",
+      FakeSerialConnectFunctionFactory));
 #endif
 
   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_;
 }