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

chrome/common/extensions/api/serial.idl

 // 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.
 
 // Use the <code>chrome.serial</code> API to read from and write to a device
 // connected to a serial port.
 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;
   };
 
   callback GetDevicesCallback = void (DeviceInfo[] ports);
 
   enum DataBits { seven, eight };
   enum ParityBit { no, odd, even };
   enum StopBits { one, two };
 
   dictionary ConnectionOptions {
@@ skipping 39 matching lines @@
     // Defaults to 0.
     long? receiveTimeout;
 
     // The maximum amount of time (in milliseconds) to wait for a
     // <code>send</code> operation to complete before calling the callback with
     // a "timeout" error. If zero, send timeout errors will not be triggered.
     // Defaults to 0.
     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.
     long connectionId;
 
     // Flag indicating whether the connection is blocked from firing onReceive
     // events.
     boolean paused;
 
     // See <code>ConnectionOptions.persistent</code>
@@ skipping 26 matching lines @@
 
     // See <code>ConnectionOptions.stopBits</code>. This field may be omitted
     // if an error occurred while querying the underlying device.
     StopBits? stopBits;
 
     // See <code>ConnectionOptions.ctsFlowControl</code>. This field may be
     // omitted if an error occurred while querying the underlying device.
     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,
 
     // The send timed out.
     timeout,
 
     // A system error occurred and the connection may be unrecoverable.
     system_error
   };
@@ skipping 42 matching lines @@
   // Data from an <code>onReceive</code> event.
   dictionary ReceiveInfo {
     // The connection identifier.
     long connectionId;
 
     // The data received.
     ArrayBuffer data;
   };
 
   enum ReceiveError {
-    // The connection was closed.
-    closed,
+    // The connection was disconnected.
+    disconnected,
 
     // No data has been received for <code>receiveTimeout</code> milliseconds.
     timeout,
 
     // The device was most likely disconnected from the host.
     device_lost,
 
     // A system error occurred and the connection may be unrecoverable.
     system_error
   };
 
   // Data from an <code>onReceiveError</code> event.
   dictionary ReceiveErrorInfo {
     // The connection identifier.
     long connectionId;
 
     // An error code indicating what went wrong.
     ReceiveError error;
   };
 
   interface Functions {
     // Returns information about available serial devices on the system.
     // The list is regenerated each time this method is called.
     // |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.
     static void update(long connectionId,
                        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.
     // |paused| : Flag to indicate whether to pause or unpause.
     // |callback| : Called when the connection has been successfully paused or
     //              unpaused.
     static void setPaused(long connectionId,
                           boolean paused,
                           SetPausedCallback callback);
 
@@ skipping 31 matching lines @@
                                   ControlSignals signals,
                                   SetControlSignalsCallback callback);
   };
 
   interface Events {
     // Event raised when data has been read from the connection.
     // |info| : Event data.
     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);
   };
 };