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

chrome/browser/extensions/api/serial/serial_api.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 "chrome/browser/extensions/api/serial/serial_api.h"
 
 #include <algorithm>
 
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_system.h"
@@ skipping 19 matching lines @@
 // But we'd like to pick something that has a chance of working, and 9600 is a
 // good balance between popularity and speed. So 9600 it is.
 const int kDefaultBufferSize = 4096;
 const int kDefaultBitrate = 9600;
 const serial::DataBits kDefaultDataBits = serial::DATA_BITS_EIGHT;
 const serial::ParityBit kDefaultParityBit = serial::PARITY_BIT_NO;
 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.";
 
 template <class T>
 void SetDefaultScopedPtrValue(scoped_ptr<T>& ptr, const T& value) {
   if (!ptr.get())
     ptr.reset(new T(value));
 }
 
 }  // namespace
@@ skipping 40 matching lines @@
           port_names.begin();
        iter != port_names.end();
        ++iter) {
     linked_ptr<serial::DeviceInfo> info(new serial::DeviceInfo);
     info->path = *iter;
     devices.push_back(info);
   }
   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.
   if (!params_->options.get())
     params_->options.reset(new serial::ConnectionOptions());
   serial::ConnectionOptions* options = params_->options.get();
 
   SetDefaultScopedPtrValue(options->persistent, false);
   SetDefaultScopedPtrValue(options->buffer_size, kDefaultBufferSize);
   SetDefaultScopedPtrValue(options->bitrate, kDefaultBitrate);
   SetDefaultScopedPtrValue(options->cts_flow_control, false);
   SetDefaultScopedPtrValue(options->receive_timeout, kDefaultReceiveTimeout);
   SetDefaultScopedPtrValue(options->send_timeout, kDefaultSendTimeout);
 
   if (options->data_bits == serial::DATA_BITS_NONE)
     options->data_bits = kDefaultDataBits;
   if (options->parity_bit == serial::PARITY_BIT_NONE)
     options->parity_bit = kDefaultParityBit;
   if (options->stop_bits == serial::STOP_BITS_NONE)
     options->stop_bits = kDefaultStopBits;
 
   serial_event_dispatcher_ = SerialEventDispatcher::Get(GetProfile());
   DCHECK(serial_event_dispatcher_);
 
   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) {
     if (!connection_->Configure(*params_->options.get())) {
       connection_->Close();
       delete connection_;
       connection_ = NULL;
     }
   } else {
     delete connection_;
     connection_ = NULL;
   }
 
   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);
 }
 
 SerialUpdateFunction::SerialUpdateFunction() {}
 
 SerialUpdateFunction::~SerialUpdateFunction() {}
 
 bool SerialUpdateFunction::Prepare() {
   params_ = serial::Update::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
 
   return true;
 }
 
 void SerialUpdateFunction::Work() {
   SerialConnection* connection = GetSerialConnection(params_->connection_id);
   if (!connection) {
     error_ = kErrorSerialConnectionNotFound;
     return;
   }
   bool success = connection->Configure(params_->options);
   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;
     return;
   }
   connection->Close();
   RemoveSerialConnection(params_->connection_id);
-  results_ = serial::Close::Results::Create(true);
+  results_ = serial::Disconnect::Results::Create(true);
 }
 
 SerialSendFunction::SerialSendFunction() {}
 
 SerialSendFunction::~SerialSendFunction() {}
 
 bool SerialSendFunction::Prepare() {
   params_ = serial::Send::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
 
@@ skipping 173 matching lines @@
     return;
   }
 
   bool success = connection->SetControlSignals(params_->signals);
   results_ = serial::SetControlSignals::Results::Create(success);
 }
 
 }  // namespace api
 
 }  // namespace extensions