Move serial out of experimental.

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"
@@ skipping 71 matching lines @@
       bitrate_(9600),
       event_notifier_(NULL) {
 }
 
 SerialOpenFunction::~SerialOpenFunction() {
 }
 
 bool SerialOpenFunction::Prepare() {
   set_work_thread_id(BrowserThread::FILE);
 
-  params_ = api::experimental_serial::Open::Params::Create(*args_);
+  params_ = api::serial::Open::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
 
   if (params_->options.get()) {
     scoped_ptr<DictionaryValue> options = params_->options->ToValue();
     if (options->HasKey(kBitrateKey))
       EXTENSION_FUNCTION_VALIDATE(options->GetInteger(kBitrateKey, &bitrate_));
 
     src_id_ = ExtractSrcId(options.get());
     event_notifier_ = CreateEventNotifier(src_id_);
   }
@@ skipping 56 matching lines @@
 
 SerialCloseFunction::SerialCloseFunction() {
 }
 
 SerialCloseFunction::~SerialCloseFunction() {
 }
 
 bool SerialCloseFunction::Prepare() {
   set_work_thread_id(BrowserThread::FILE);
 
-  params_ = api::experimental_serial::Close::Params::Create(*args_);
+  params_ = api::serial::Close::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
 
   return true;
 }
 
 void SerialCloseFunction::Work() {
   bool close_result = false;
   SerialConnection* serial_connection = manager_->Get(params_->connection_id);
   if (serial_connection) {
     serial_connection->Close();
@@ skipping 10 matching lines @@
 
 SerialReadFunction::SerialReadFunction() {
 }
 
 SerialReadFunction::~SerialReadFunction() {
 }
 
 bool SerialReadFunction::Prepare() {
   set_work_thread_id(BrowserThread::FILE);
 
-  params_ = api::experimental_serial::Read::Params::Create(*args_);
+  params_ = api::serial::Read::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   if (params_->bytes_to_read <= 0 || params_->bytes_to_read >= 1024 * 1024) {
     error_ = kSerialReadInvalidBytesToRead;
     return false;
   }
 
   return true;
 }
 
 void SerialReadFunction::Work() {
@@ skipping 24 matching lines @@
 SerialWriteFunction::SerialWriteFunction()
     : io_buffer_(NULL), io_buffer_size_(0) {
 }
 
 SerialWriteFunction::~SerialWriteFunction() {
 }
 
 bool SerialWriteFunction::Prepare() {
   set_work_thread_id(BrowserThread::FILE);
 
-  params_ = api::experimental_serial::Write::Params::Create(*args_);
+  params_ = api::serial::Write::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
 
   io_buffer_size_ = params_->data.size();
   io_buffer_ = new net::WrappedIOBuffer(params_->data.data());
 
   return true;
 }
 
 void SerialWriteFunction::Work() {
   int bytes_written = -1;
@@ skipping 14 matching lines @@
 
 SerialFlushFunction::SerialFlushFunction() {
 }
 
 SerialFlushFunction::~SerialFlushFunction() {
 }
 
 bool SerialFlushFunction::Prepare() {
   set_work_thread_id(BrowserThread::FILE);
 
-  params_ = api::experimental_serial::Flush::Params::Create(*args_);
+  params_ = api::serial::Flush::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SerialFlushFunction::Work() {
   bool flush_result = false;
   SerialConnection* serial_connection = manager_->Get(params_->connection_id);
   if (serial_connection) {
     serial_connection->Flush();
     flush_result = true;
   }
 
   SetResult(Value::CreateBooleanValue(flush_result));
 }
 
 bool SerialFlushFunction::Respond() {
   return true;
 }
 
 SerialGetControlSignalsFunction::SerialGetControlSignalsFunction()
     : api_response_(false) {
 }
 
 SerialGetControlSignalsFunction::~SerialGetControlSignalsFunction() {
 }
 
 bool SerialGetControlSignalsFunction::Prepare() {
   set_work_thread_id(BrowserThread::FILE);
 
-  params_ = api::experimental_serial::GetControlSignals::Params::Create(
+  params_ = api::serial::GetControlSignals::Params::Create(
       *args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
 
   return true;
 }
 
 void SerialGetControlSignalsFunction::Work() {
   DictionaryValue *result = new DictionaryValue();
   SerialConnection* serial_connection = manager_->Get(params_->connection_id);
   if (serial_connection) {
@@ skipping 19 matching lines @@
 
 SerialSetControlSignalsFunction::SerialSetControlSignalsFunction() {
 }
 
 SerialSetControlSignalsFunction::~SerialSetControlSignalsFunction() {
 }
 
 bool SerialSetControlSignalsFunction::Prepare() {
   set_work_thread_id(BrowserThread::FILE);
 
-  params_ = api::experimental_serial::SetControlSignals::Params::Create(
+  params_ = api::serial::SetControlSignals::Params::Create(
       *args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
 
   return true;
 }
 
 void SerialSetControlSignalsFunction::Work() {
   SerialConnection* serial_connection = manager_->Get(params_->connection_id);
   if (serial_connection) {
     SerialConnection::ControlSignals control_signals = { 0 };
@@ skipping 13 matching lines @@
     error_ = kSerialConnectionNotFoundError;
     SetResult(Value::CreateBooleanValue(false));
   }
 }
 
 bool SerialSetControlSignalsFunction::Respond() {
   return true;
 }
 
 }  // namespace extensions