Adds Serial API to set data bits, parity, stop bits.

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 "base/values.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/api/serial/serial_connection.h"
 #include "chrome/browser/extensions/api/serial/serial_port_enumerator.h"
 #include "content/public/browser/browser_thread.h"
 
 using content::BrowserThread;
 
+namespace serial = extensions::api::serial;
+
 namespace extensions {
 
 const char kConnectionIdKey[] = "connectionId";
 const char kDataKey[] = "data";
 const char kBytesReadKey[] = "bytesRead";
 const char kBytesWrittenKey[] = "bytesWritten";
 const char kBitrateKey[] = "bitrate";
+const char kDataBitKey[] = "dataBit";
+const char kParityKey[] = "parityBit";
+const char kStopBitKey[] = "stopBit";
 const char kSuccessKey[] = "success";
 const char kDcdKey[] = "dcd";
 const char kCtsKey[] = "cts";
 
 const char kErrorGetControlSignalsFailed[] = "Failed to get control signals.";
 const char kErrorSetControlSignalsFailed[] = "Failed to set control signals.";
 const char kSerialReadInvalidBytesToRead[] = "Number of bytes to read must "
     "be a positive number less than 1,048,576.";
 
 SerialAsyncApiFunction::SerialAsyncApiFunction()
@@ skipping 44 matching lines @@
 }
 
 // It's a fool's errand to come up with a default bitrate, because we don't get
 // to control both sides of the communication. Unless the other side has
 // implemented auto-bitrate detection (rare), if we pick the wrong rate, then
 // you're gonna have a bad time. Close doesn't count.
 //
 // 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.
 SerialOpenFunction::SerialOpenFunction()
-    : bitrate_(9600) {
+    : bitrate_(9600), databit_(serial::DATA_BIT_EIGHTBIT),
+      parity_(serial::PARITY_BIT_NOPARITY),
+      stopbit_(serial::STOP_BIT_ONESTOPBIT) {
 }
 
 SerialOpenFunction::~SerialOpenFunction() {
 }
 
 bool SerialOpenFunction::Prepare() {
   set_work_thread_id(BrowserThread::FILE);
 
   params_ = api::serial::Open::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
 
   if (params_->options.get()) {
     scoped_ptr<base::DictionaryValue> options = params_->options->ToValue();
     if (options->HasKey(kBitrateKey))
       EXTENSION_FUNCTION_VALIDATE(options->GetInteger(kBitrateKey, &bitrate_));
+    if (options->HasKey(kDataBitKey)) {
+      std::string data;
+      options->GetString(kDataBitKey, &data);
+      if (!data.empty())
+        databit_ = serial::ParseDataBit(data);
+    }
+    if (options->HasKey(kParityKey)) {
+      std::string parity;
+      options->GetString(kParityKey, &parity);
+      if (!parity.empty())
+        parity_ = serial::ParseParityBit(parity);
+    }
+    if (options->HasKey(kStopBitKey)) {
+      std::string stopbit;
+      options->GetString(kStopBitKey, &stopbit);
+      if (!stopbit.empty())
+        stopbit_ = serial::ParseStopBit(stopbit);
+    }
   }
 
   return true;
 }
 
 void SerialOpenFunction::AsyncWorkStart() {
   Work();
 }
 
 void SerialOpenFunction::Work() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   const SerialPortEnumerator::StringSet name_set(
     SerialPortEnumerator::GenerateValidSerialPortNames());
   if (DoesPortExist(params_->port)) {
     SerialConnection* serial_connection = CreateSerialConnection(
       params_->port,
       bitrate_,
+      databit_,
+      parity_,
+      stopbit_,
       extension_->id());
     CHECK(serial_connection);
     int id = manager_->Add(serial_connection);
     CHECK(id);
 
     bool open_result = serial_connection->Open();
     if (!open_result) {
       serial_connection->Close();
       RemoveSerialConnection(id);
       id = -1;
     }
 
     base::DictionaryValue* result = new base::DictionaryValue();
     result->SetInteger(kConnectionIdKey, id);
     SetResult(result);
     AsyncWorkCompleted();
   } else {
     base::DictionaryValue* result = new base::DictionaryValue();
     result->SetInteger(kConnectionIdKey, -1);
     SetResult(result);
     AsyncWorkCompleted();
   }
 }
 
 SerialConnection* SerialOpenFunction::CreateSerialConnection(
     const std::string& port,
     int bitrate,
+    serial::DataBit databit,
+    serial::ParityBit parity,
+    serial::StopBit stopbit,
     const std::string& owner_extension_id) {
-  return new SerialConnection(port, bitrate, owner_extension_id);
+  return new SerialConnection(port, bitrate, databit, parity, stopbit,
+      owner_extension_id);
 }
 
 bool SerialOpenFunction::DoesPortExist(const std::string& port) {
   const SerialPortEnumerator::StringSet name_set(
     SerialPortEnumerator::GenerateValidSerialPortNames());
   return SerialPortEnumerator::DoesPortExist(name_set, params_->port);
 }
 
 bool SerialOpenFunction::Respond() {
   return true;
@@ skipping 220 matching lines @@
     error_ = kSerialConnectionNotFoundError;
     SetResult(new base::FundamentalValue(false));
   }
 }
 
 bool SerialSetControlSignalsFunction::Respond() {
   return true;
 }
 
 }  // namespace extensions