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

Review URL: https://codereview.chromium.org/85943003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@237156 0039d316-1c4b-4281-b951-d872f2087c98

8 files changed, 108 insertions, 86 deletions

diff --git a/chrome/browser/extensions/api/serial/serial_api.cc b/chrome/browser/extensions/api/serial/serial_api.cc
index ebf2a66..81d4d49 100644
--- a/chrome/browser/extensions/api/serial/serial_api.cc
+++ b/chrome/browser/extensions/api/serial/serial_api.cc
@@ -37,7 +37,7 @@ const serial::StopBits kDefaultStopBits = serial::STOP_BITS_ONE;
 const int kDefaultReceiveTimeout = 0;
 const int kDefaultSendTimeout = 0;
 
-const char kErrorOpenFailed[] = "Failed to open the port.";
+const char kErrorConnectFailed[] = "Failed to connect to the port.";
 const char kErrorSerialConnectionNotFound[] = "Serial connection not found.";
 const char kErrorGetControlSignalsFailed[] = "Failed to get control signals.";
 
@@ -98,12 +98,12 @@ void SerialGetDevicesFunction::Work() {
   results_ = serial::GetDevices::Results::Create(devices);
 }
 
-SerialOpenFunction::SerialOpenFunction() {}
+SerialConnectFunction::SerialConnectFunction() {}
 
-SerialOpenFunction::~SerialOpenFunction() {}
+SerialConnectFunction::~SerialConnectFunction() {}
 
-bool SerialOpenFunction::Prepare() {
-  params_ = serial::Open::Params::Create(*args_);
+bool SerialConnectFunction::Prepare() {
+  params_ = serial::Connect::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
 
   // Fill in any omitted options to ensure a known initial configuration.
@@ -131,13 +131,13 @@ bool SerialOpenFunction::Prepare() {
   return true;
 }
 
-void SerialOpenFunction::AsyncWorkStart() {
+void SerialConnectFunction::AsyncWorkStart() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   connection_ = CreateSerialConnection(params_->path, extension_->id());
-  connection_->Open(base::Bind(&SerialOpenFunction::OnOpen, this));
+  connection_->Open(base::Bind(&SerialConnectFunction::OnConnected, this));
 }
 
-void SerialOpenFunction::OnOpen(bool success) {
+void SerialConnectFunction::OnConnected(bool success) {
   DCHECK(connection_);
 
   if (success) {
@@ -152,25 +152,31 @@ void SerialOpenFunction::OnOpen(bool success) {
   }
 
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-                          base::Bind(&SerialOpenFunction::FinishOpen, this));
+                          base::Bind(&SerialConnectFunction::FinishConnect,
+                                     this));
 }
 
-void SerialOpenFunction::FinishOpen() {
+void SerialConnectFunction::FinishConnect() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!connection_) {
-    error_ = kErrorOpenFailed;
+    error_ = kErrorConnectFailed;
   } else {
     int id = manager_->Add(connection_);
-    serial_event_dispatcher_->PollConnection(extension_->id(), id);
-
-    serial::OpenInfo open_info;
-    open_info.connection_id = id;
-    results_ = serial::Open::Results::Create(open_info);
+    serial::ConnectionInfo info;
+    info.connection_id = id;
+    if (connection_->GetInfo(&info)) {
+      serial_event_dispatcher_->PollConnection(extension_->id(), id);
+      results_ = serial::Connect::Results::Create(info);
+    } else {
+      connection_->Close();
+      RemoveSerialConnection(id);
+      error_ = kErrorConnectFailed;
+    }
   }
   AsyncWorkCompleted();
 }
 
-SerialConnection* SerialOpenFunction::CreateSerialConnection(
+SerialConnection* SerialConnectFunction::CreateSerialConnection(
     const std::string& port, const std::string& extension_id) const {
   return new SerialConnection(port, extension_id);
 }
@@ -196,18 +202,18 @@ void SerialUpdateFunction::Work() {
   results_ = serial::Update::Results::Create(success);
 }
 
-SerialCloseFunction::SerialCloseFunction() {}
+SerialDisconnectFunction::SerialDisconnectFunction() {}
 
-SerialCloseFunction::~SerialCloseFunction() {}
+SerialDisconnectFunction::~SerialDisconnectFunction() {}
 
-bool SerialCloseFunction::Prepare() {
-  params_ = serial::Close::Params::Create(*args_);
+bool SerialDisconnectFunction::Prepare() {
+  params_ = serial::Disconnect::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
 
   return true;
 }
 
-void SerialCloseFunction::Work() {
+void SerialDisconnectFunction::Work() {
   SerialConnection* connection = GetSerialConnection(params_->connection_id);
   if (!connection) {
     error_ = kErrorSerialConnectionNotFound;
@@ -215,7 +221,7 @@ void SerialCloseFunction::Work() {
   }
   connection->Close();
   RemoveSerialConnection(params_->connection_id);
-  results_ = serial::Close::Results::Create(true);
+  results_ = serial::Disconnect::Results::Create(true);
 }
 
 SerialSendFunction::SerialSendFunction() {}
diff --git a/chrome/browser/extensions/api/serial/serial_api.h b/chrome/browser/extensions/api/serial/serial_api.h
index 4bd6475..63352c4 100644
--- a/chrome/browser/extensions/api/serial/serial_api.h
+++ b/chrome/browser/extensions/api/serial/serial_api.h
@@ -51,14 +51,14 @@ class SerialGetDevicesFunction : public SerialAsyncApiFunction {
   virtual void Work() OVERRIDE;
 };
 
-class SerialOpenFunction : public SerialAsyncApiFunction {
+class SerialConnectFunction : public SerialAsyncApiFunction {
  public:
-  DECLARE_EXTENSION_FUNCTION("serial.open", SERIAL_OPEN)
+  DECLARE_EXTENSION_FUNCTION("serial.connect", SERIAL_CONNECT)
 
-  SerialOpenFunction();
+  SerialConnectFunction();
 
  protected:
-  virtual ~SerialOpenFunction();
+  virtual ~SerialConnectFunction();
 
   // AsyncApiFunction:
   virtual bool Prepare() OVERRIDE;
@@ -69,16 +69,16 @@ class SerialOpenFunction : public SerialAsyncApiFunction {
       const std::string& extension_id) const;
 
  private:
-  void OnOpen(bool success);
-  void FinishOpen();
+  void OnConnected(bool success);
+  void FinishConnect();
 
-  scoped_ptr<serial::Open::Params> params_;
+  scoped_ptr<serial::Connect::Params> params_;
 
   // SerialEventDispatcher is owned by a Profile.
   SerialEventDispatcher* serial_event_dispatcher_;
 
-  // This connection is created within SerialOpenFunction.
-  // From there it is either destroyed in OnOpen (upon failure)
+  // This connection is created within SerialConnectFunction.
+  // From there it is either destroyed in OnConnected (upon failure)
   // or its ownership is transferred to the profile's.
   // ApiResourceManager<SerialConnection>.
   SerialConnection* connection_;
@@ -101,21 +101,21 @@ class SerialUpdateFunction : public SerialAsyncApiFunction {
   scoped_ptr<serial::Update::Params> params_;
 };
 
-class SerialCloseFunction : public SerialAsyncApiFunction {
+class SerialDisconnectFunction : public SerialAsyncApiFunction {
  public:
-  DECLARE_EXTENSION_FUNCTION("serial.close", SERIAL_CLOSE)
+  DECLARE_EXTENSION_FUNCTION("serial.disconnect", SERIAL_DISCONNECT)
 
-  SerialCloseFunction();
+  SerialDisconnectFunction();
 
  protected:
-  virtual ~SerialCloseFunction();
+  virtual ~SerialDisconnectFunction();
 
   // AsyncApiFunction:
   virtual bool Prepare() OVERRIDE;
   virtual void Work() OVERRIDE;
 
  private:
-  scoped_ptr<serial::Close::Params> params_;
+  scoped_ptr<serial::Disconnect::Params> params_;
 };
 
 class SerialSetPausedFunction : public SerialAsyncApiFunction {
diff --git a/chrome/browser/extensions/api/serial/serial_apitest.cc b/chrome/browser/extensions/api/serial/serial_apitest.cc
index 30165ac..eb2b5cb 100644
--- a/chrome/browser/extensions/api/serial/serial_apitest.cc
+++ b/chrome/browser/extensions/api/serial/serial_apitest.cc
@@ -100,6 +100,20 @@ class FakeEchoSerialConnection : public SerialConnection {
     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:
@@ -109,7 +123,7 @@ class FakeEchoSerialConnection : public SerialConnection {
   DISALLOW_COPY_AND_ASSIGN(FakeEchoSerialConnection);
 };
 
-class FakeSerialOpenFunction : public api::SerialOpenFunction {
+class FakeSerialConnectFunction : public api::SerialConnectFunction {
  protected:
   virtual SerialConnection* CreateSerialConnection(
       const std::string& port,
@@ -122,7 +136,7 @@ class FakeSerialOpenFunction : public api::SerialOpenFunction {
   }
 
  protected:
-  virtual ~FakeSerialOpenFunction() {}
+  virtual ~FakeSerialConnectFunction() {}
 };
 
 }  // namespace extensions
@@ -131,8 +145,8 @@ 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:
@@ -164,8 +178,8 @@ IN_PROC_BROWSER_TEST_F(SerialApiTest, SerialFakeHardware) {
       "serial.getDevices",
       FakeSerialGetDevicesFunctionFactory));
   ASSERT_TRUE(ExtensionFunctionDispatcher::OverrideFunction(
-      "serial.open",
-      FakeSerialOpenFunctionFactory));
+      "serial.connect",
+      FakeSerialConnectFunctionFactory));
 #endif
 
   ASSERT_TRUE(RunExtensionTest("serial/api")) << message_;
diff --git a/chrome/browser/extensions/api/serial/serial_connection.cc b/chrome/browser/extensions/api/serial/serial_connection.cc
index 66e19cf..155026e 100644
--- a/chrome/browser/extensions/api/serial/serial_connection.cc
+++ b/chrome/browser/extensions/api/serial/serial_connection.cc
@@ -49,8 +49,8 @@ SerialConnection::SerialConnection(const std::string& port,
 
 SerialConnection::~SerialConnection() {
   DCHECK(open_complete_.is_null());
-  io_handler_->CancelRead(api::serial::RECEIVE_ERROR_CLOSED);
-  io_handler_->CancelWrite(api::serial::SEND_ERROR_CLOSED);
+  io_handler_->CancelRead(api::serial::RECEIVE_ERROR_DISCONNECTED);
+  io_handler_->CancelWrite(api::serial::SEND_ERROR_DISCONNECTED);
   Close();
 }
 
diff --git a/chrome/browser/extensions/api/serial/serial_event_dispatcher.cc b/chrome/browser/extensions/api/serial/serial_event_dispatcher.cc
index 563ebfb..e25974a4 100644
--- a/chrome/browser/extensions/api/serial/serial_event_dispatcher.cc
+++ b/chrome/browser/extensions/api/serial/serial_event_dispatcher.cc
@@ -20,7 +20,7 @@ namespace {
 bool ShouldPauseOnReceiveError(serial::ReceiveError error) {
   return error == serial::RECEIVE_ERROR_DEVICE_LOST ||
       error == serial::RECEIVE_ERROR_SYSTEM_ERROR ||
-      error == serial::RECEIVE_ERROR_CLOSED;
+      error == serial::RECEIVE_ERROR_DISCONNECTED;
 }
 
 }  // namespace
diff --git a/chrome/browser/extensions/extension_function_histogram_value.h b/chrome/browser/extensions/extension_function_histogram_value.h
index 489e47e..e59aea3 100644
--- a/chrome/browser/extensions/extension_function_histogram_value.h
+++ b/chrome/browser/extensions/extension_function_histogram_value.h
@@ -165,7 +165,7 @@ enum HistogramValue {
   BOOKMARKS_GETCHILDREN,
   BROWSERACTION_GETTITLE,
   TERMINALPRIVATE_OPENTERMINALPROCESS,
-  SERIAL_CLOSE,
+  DELETED_SERIAL_CLOSE,
   CONTEXTMENUS_REMOVE,
   FILEBROWSERPRIVATE_REQUESTFILESYSTEM,
   ECHOPRIVATE_GETREGISTRATIONCODE,
@@ -247,7 +247,7 @@ enum HistogramValue {
   DOWNLOADS_GETFILEICON,
   PAGEACTION_GETTITLE,
   BROWSINGDATA_REMOVE,
-  SERIAL_OPEN,
+  DELETED_SERIAL_OPEN,
   FILESYSTEM_GETDISPLAYPATH,
   FILEBROWSERPRIVATE_FORMATVOLUME,
   BOOKMARKS_GET,
@@ -701,6 +701,8 @@ enum HistogramValue {
   SERIAL_SEND,
   GCM_REGISTER,
   GCM_SEND,
+  SERIAL_CONNECT,
+  SERIAL_DISCONNECT,
   ENUM_BOUNDARY // Last entry: Add new entries above.
 };
 
diff --git a/chrome/common/extensions/api/serial.idl b/chrome/common/extensions/api/serial.idl
index 919de55..786638a 100644
--- a/chrome/common/extensions/api/serial.idl
+++ b/chrome/common/extensions/api/serial.idl
@@ -8,7 +8,8 @@ namespace serial {
 
   dictionary DeviceInfo {
     // The device's system path. This should be passed as the <code>path</code>
-    // argument to <code>chrome.serial.open</code> in order to open this device.
+    // argument to <code>chrome.serial.connect</code> in order to connect to
+    // this device.
     DOMString path;
   };
 
@@ -68,24 +69,6 @@ namespace serial {
     long? sendTimeout;
   };
 
-  // Result of the <code>open</code> method.
-  dictionary OpenInfo {
-    // The id of the opened connection.
-    long connectionId;
-  };
-
-  // Callback from the <code>open</code> method;
-  callback OpenCallback = void (OpenInfo openInfo);
-
-  // Callback from the <code>update</code> method.
-  callback UpdateCallback = void (boolean result);
-
-  // Returns true if operation was successful.
-  callback CloseCallback = void (boolean result);
-
-  // Callback from the <code>setPaused</code> method.
-  callback SetPausedCallback = void ();
-
   // Result of the <code>getInfo</code> method.
   dictionary ConnectionInfo {
     // The id of the serial port connection.
@@ -132,13 +115,28 @@ namespace serial {
     boolean? ctsFlowControl;
   };
 
+  // Callback from the <code>connect</code> method;
+  callback ConnectCallback = void (ConnectionInfo connectionInfo);
+
+  // Callback from the <code>update</code> method.
+  callback UpdateCallback = void (boolean result);
+
+  // Callback from the <code>disconnect</code> method. Returns true if the
+  // operation was successful.
+  callback DisconnectCallback = void (boolean result);
+
+  // Callback from the <code>setPaused</code> method.
+  callback SetPausedCallback = void ();
+
+  // Callback from the <code>getInfo</code> method.
   callback GetInfoCallback = void (ConnectionInfo connectionInfo);
 
+  // Callback from the <code>getConnections</code> method.
   callback GetConnectionsCallback = void (ConnectionInfo[] connectionInfos);
 
   enum SendError {
-    // The connection was closed.
-    closed,
+    // The connection was disconnected.
+    disconnected,
 
     // A send was already pending.
     pending,
@@ -201,8 +199,8 @@ namespace serial {
   };
 
   enum ReceiveError {
-    // The connection was closed.
-    closed,
+    // The connection was disconnected.
+    disconnected,
 
     // No data has been received for <code>receiveTimeout</code> milliseconds.
     timeout,
@@ -229,15 +227,15 @@ namespace serial {
     // |callback| : Called with the list of <code>DeviceInfo</code> objects.
     static void getDevices(GetDevicesCallback callback);
 
-    // Opens a connection to the given serial port.
+    // Connects to a given serial port.
     // |path| : The system path of the serial port to open.
     // |options| : Port configuration options.
     // |callback| : Called when the connection has been opened.
-    static void open(DOMString path,
-                     optional ConnectionOptions options,
-                     OpenCallback callback);
+    static void connect(DOMString path,
+                        optional ConnectionOptions options,
+                        ConnectCallback callback);
 
-    // Update the option settings on an open serial port.
+    // Update the option settings on an open serial port connection.
     // |connectionId| : The id of the opened connection.
     // |options| : Port configuration options.
     // |callback| : Called when the configuation has completed.
@@ -245,10 +243,10 @@ namespace serial {
                        ConnectionOptions options,
                        UpdateCallback callback);
 
-    // Closes an open connection.
+    // Disconnects from a serial port.
     // |connectionId| : The id of the opened connection.
     // |callback| : Called when the connection has been closed.
-    static void close(long connectionId, CloseCallback callback);
+    static void disconnect(long connectionId, DisconnectCallback callback);
 
     // Pauses or unpauses an open connection.
     // |connectionId| : The id of the opened connection.
@@ -300,8 +298,9 @@ namespace serial {
     static void onReceive(ReceiveInfo info);
 
     // Event raised when an error occurred while the runtime was waiting for
-    // data on the serial port. Once this event is raised, the connection is set
-    // to <code>paused</code>.
+    // data on the serial port. Once this event is raised, the connection may be
+    // set to <code>paused</code>. A <code>"timeout"</code> error does not pause
+    // the connection.
     static void onReceiveError(ReceiveErrorInfo info);
   };
 };
diff --git a/chrome/test/data/extensions/api_test/serial/api/background.js b/chrome/test/data/extensions/api_test/serial/api/background.js
index bdc3df7..ff7f76b 100644
--- a/chrome/test/data/extensions/api_test/serial/api/background.js
+++ b/chrome/test/data/extensions/api_test/serial/api/background.js
@@ -39,9 +39,9 @@ var testSerial = function() {
       break;
       case 1:
       var bitrate = 57600;
-      console.log('Opening serial device ' + serialPort + ' at ' +
+      console.log('Connecting to serial device ' + serialPort + ' at ' +
                   bitrate + ' bps.');
-      serial.open(serialPort, {bitrate: bitrate}, onOpen);
+      serial.connect(serialPort, {bitrate: bitrate}, onConnect);
       break;
       case 2:
       serial.setControlSignals(connectionId, {dtr: true}, onSetControlSignals);
@@ -55,7 +55,7 @@ var testSerial = function() {
       serial.send(connectionId, sendBuffer, onSend);
       break;
       case 50:  // GOTO 4 EVER
-      serial.close(connectionId, onClose);
+      serial.disconnect(connectionId, onDisconnect);
       break;
       default:
       // Beware! If you forget to assign a case for your next test, the whole
@@ -75,7 +75,7 @@ var testSerial = function() {
     doNextOperation();
   }
 
-  var onClose = function(result) {
+  var onDisconnect = function(result) {
     chrome.test.assertTrue(result);
     doNextOperation();
   };
@@ -117,9 +117,10 @@ var testSerial = function() {
     doNextOperation();
   };
 
-  var onOpen = function(connectionInfo) {
+  var onConnect = function(connectionInfo) {
+    chrome.test.assertTrue(!!connectionInfo,
+                           'Failed to connect to serial port.');
     connectionId = connectionInfo.connectionId;
-    chrome.test.assertTrue(connectionId > 0, 'Failed to open serial port.');
     doNextOperation();
   };