Generate all extension schema namespaces as "api" and instead vary the generated bundle names.

extensions/browser/api/serial/serial_connection.cc

 // Copyright 2014 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 "extensions/browser/api/serial/serial_connection.h"
 
 #include <string>
 #include <vector>
 
 #include "base/files/file_path.h"
 #include "base/lazy_instance.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "extensions/browser/api/api_resource_manager.h"
 #include "extensions/common/api/serial.h"
 
 namespace extensions {
 
 namespace {
 
 const int kDefaultBufferSize = 4096;
 
-core_api::serial::SendError ConvertSendErrorFromMojo(
+api::serial::SendError ConvertSendErrorFromMojo(
     device::serial::SendError input) {
   switch (input) {
     case device::serial::SEND_ERROR_NONE:
-      return core_api::serial::SEND_ERROR_NONE;
+      return api::serial::SEND_ERROR_NONE;
     case device::serial::SEND_ERROR_DISCONNECTED:
-      return core_api::serial::SEND_ERROR_DISCONNECTED;
+      return api::serial::SEND_ERROR_DISCONNECTED;
     case device::serial::SEND_ERROR_PENDING:
-      return core_api::serial::SEND_ERROR_PENDING;
+      return api::serial::SEND_ERROR_PENDING;
     case device::serial::SEND_ERROR_TIMEOUT:
-      return core_api::serial::SEND_ERROR_TIMEOUT;
+      return api::serial::SEND_ERROR_TIMEOUT;
     case device::serial::SEND_ERROR_SYSTEM_ERROR:
-      return core_api::serial::SEND_ERROR_SYSTEM_ERROR;
+      return api::serial::SEND_ERROR_SYSTEM_ERROR;
   }
-  return core_api::serial::SEND_ERROR_NONE;
+  return api::serial::SEND_ERROR_NONE;
 }
 
-core_api::serial::ReceiveError ConvertReceiveErrorFromMojo(
+api::serial::ReceiveError ConvertReceiveErrorFromMojo(
     device::serial::ReceiveError input) {
   switch (input) {
     case device::serial::RECEIVE_ERROR_NONE:
-      return core_api::serial::RECEIVE_ERROR_NONE;
+      return api::serial::RECEIVE_ERROR_NONE;
     case device::serial::RECEIVE_ERROR_DISCONNECTED:
-      return core_api::serial::RECEIVE_ERROR_DISCONNECTED;
+      return api::serial::RECEIVE_ERROR_DISCONNECTED;
     case device::serial::RECEIVE_ERROR_TIMEOUT:
-      return core_api::serial::RECEIVE_ERROR_TIMEOUT;
+      return api::serial::RECEIVE_ERROR_TIMEOUT;
     case device::serial::RECEIVE_ERROR_DEVICE_LOST:
-      return core_api::serial::RECEIVE_ERROR_DEVICE_LOST;
+      return api::serial::RECEIVE_ERROR_DEVICE_LOST;
     case device::serial::RECEIVE_ERROR_BREAK:
-      return core_api::serial::RECEIVE_ERROR_BREAK;
+      return api::serial::RECEIVE_ERROR_BREAK;
     case device::serial::RECEIVE_ERROR_FRAME_ERROR:
-      return core_api::serial::RECEIVE_ERROR_FRAME_ERROR;
+      return api::serial::RECEIVE_ERROR_FRAME_ERROR;
     case device::serial::RECEIVE_ERROR_OVERRUN:
-      return core_api::serial::RECEIVE_ERROR_OVERRUN;
+      return api::serial::RECEIVE_ERROR_OVERRUN;
     case device::serial::RECEIVE_ERROR_BUFFER_OVERFLOW:
-      return core_api::serial::RECEIVE_ERROR_BUFFER_OVERFLOW;
+      return api::serial::RECEIVE_ERROR_BUFFER_OVERFLOW;
     case device::serial::RECEIVE_ERROR_PARITY_ERROR:
-      return core_api::serial::RECEIVE_ERROR_PARITY_ERROR;
+      return api::serial::RECEIVE_ERROR_PARITY_ERROR;
     case device::serial::RECEIVE_ERROR_SYSTEM_ERROR:
-      return core_api::serial::RECEIVE_ERROR_SYSTEM_ERROR;
+      return api::serial::RECEIVE_ERROR_SYSTEM_ERROR;
   }
-  return core_api::serial::RECEIVE_ERROR_NONE;
+  return api::serial::RECEIVE_ERROR_NONE;
 }
 
-core_api::serial::DataBits ConvertDataBitsFromMojo(
-    device::serial::DataBits input) {
+api::serial::DataBits ConvertDataBitsFromMojo(device::serial::DataBits input) {
   switch (input) {
     case device::serial::DATA_BITS_NONE:
-      return core_api::serial::DATA_BITS_NONE;
+      return api::serial::DATA_BITS_NONE;
     case device::serial::DATA_BITS_SEVEN:
-      return core_api::serial::DATA_BITS_SEVEN;
+      return api::serial::DATA_BITS_SEVEN;
     case device::serial::DATA_BITS_EIGHT:
-      return core_api::serial::DATA_BITS_EIGHT;
+      return api::serial::DATA_BITS_EIGHT;
   }
-  return core_api::serial::DATA_BITS_NONE;
+  return api::serial::DATA_BITS_NONE;
 }
 
-device::serial::DataBits ConvertDataBitsToMojo(
-    core_api::serial::DataBits input) {
+device::serial::DataBits ConvertDataBitsToMojo(api::serial::DataBits input) {
   switch (input) {
-    case core_api::serial::DATA_BITS_NONE:
+    case api::serial::DATA_BITS_NONE:
       return device::serial::DATA_BITS_NONE;
-    case core_api::serial::DATA_BITS_SEVEN:
+    case api::serial::DATA_BITS_SEVEN:
       return device::serial::DATA_BITS_SEVEN;
-    case core_api::serial::DATA_BITS_EIGHT:
+    case api::serial::DATA_BITS_EIGHT:
       return device::serial::DATA_BITS_EIGHT;
   }
   return device::serial::DATA_BITS_NONE;
 }
 
-core_api::serial::ParityBit ConvertParityBitFromMojo(
+api::serial::ParityBit ConvertParityBitFromMojo(
     device::serial::ParityBit input) {
   switch (input) {
     case device::serial::PARITY_BIT_NONE:
-      return core_api::serial::PARITY_BIT_NONE;
+      return api::serial::PARITY_BIT_NONE;
     case device::serial::PARITY_BIT_ODD:
-      return core_api::serial::PARITY_BIT_ODD;
+      return api::serial::PARITY_BIT_ODD;
     case device::serial::PARITY_BIT_NO:
-      return core_api::serial::PARITY_BIT_NO;
+      return api::serial::PARITY_BIT_NO;
     case device::serial::PARITY_BIT_EVEN:
-      return core_api::serial::PARITY_BIT_EVEN;
+      return api::serial::PARITY_BIT_EVEN;
   }
-  return core_api::serial::PARITY_BIT_NONE;
+  return api::serial::PARITY_BIT_NONE;
 }
 
-device::serial::ParityBit ConvertParityBitToMojo(
-    core_api::serial::ParityBit input) {
+device::serial::ParityBit ConvertParityBitToMojo(api::serial::ParityBit input) {
   switch (input) {
-    case core_api::serial::PARITY_BIT_NONE:
+    case api::serial::PARITY_BIT_NONE:
       return device::serial::PARITY_BIT_NONE;
-    case core_api::serial::PARITY_BIT_NO:
+    case api::serial::PARITY_BIT_NO:
       return device::serial::PARITY_BIT_NO;
-    case core_api::serial::PARITY_BIT_ODD:
+    case api::serial::PARITY_BIT_ODD:
       return device::serial::PARITY_BIT_ODD;
-    case core_api::serial::PARITY_BIT_EVEN:
+    case api::serial::PARITY_BIT_EVEN:
       return device::serial::PARITY_BIT_EVEN;
   }
   return device::serial::PARITY_BIT_NONE;
 }
 
-core_api::serial::StopBits ConvertStopBitsFromMojo(
-    device::serial::StopBits input) {
+api::serial::StopBits ConvertStopBitsFromMojo(device::serial::StopBits input) {
   switch (input) {
     case device::serial::STOP_BITS_NONE:
-      return core_api::serial::STOP_BITS_NONE;
+      return api::serial::STOP_BITS_NONE;
     case device::serial::STOP_BITS_ONE:
-      return core_api::serial::STOP_BITS_ONE;
+      return api::serial::STOP_BITS_ONE;
     case device::serial::STOP_BITS_TWO:
-      return core_api::serial::STOP_BITS_TWO;
+      return api::serial::STOP_BITS_TWO;
   }
-  return core_api::serial::STOP_BITS_NONE;
+  return api::serial::STOP_BITS_NONE;
 }
 
-device::serial::StopBits ConvertStopBitsToMojo(
-    core_api::serial::StopBits input) {
+device::serial::StopBits ConvertStopBitsToMojo(api::serial::StopBits input) {
   switch (input) {
-    case core_api::serial::STOP_BITS_NONE:
+    case api::serial::STOP_BITS_NONE:
       return device::serial::STOP_BITS_NONE;
-    case core_api::serial::STOP_BITS_ONE:
+    case api::serial::STOP_BITS_ONE:
       return device::serial::STOP_BITS_ONE;
-    case core_api::serial::STOP_BITS_TWO:
+    case api::serial::STOP_BITS_TWO:
       return device::serial::STOP_BITS_TWO;
   }
   return device::serial::STOP_BITS_NONE;
 }
 
 class SendBuffer : public device::ReadOnlyBuffer {
  public:
   SendBuffer(
       const std::vector<char>& data,
       const base::Callback<void(int, device::serial::SendError)>& callback)
@@ skipping 88 matching lines @@
   send_timeout_ = send_timeout;
 }
 
 void SerialConnection::set_paused(bool paused) {
   paused_ = paused;
   if (paused) {
     io_handler_->CancelRead(device::serial::RECEIVE_ERROR_NONE);
   }
 }
 
-void SerialConnection::Open(const core_api::serial::ConnectionOptions& options,
+void SerialConnection::Open(const api::serial::ConnectionOptions& options,
                             const OpenCompleteCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (options.persistent.get())
     set_persistent(*options.persistent);
   if (options.name.get())
     set_name(*options.name);
   if (options.buffer_size.get())
     set_buffer_size(*options.buffer_size);
   if (options.receive_timeout.get())
     set_receive_timeout(*options.receive_timeout);
@@ skipping 33 matching lines @@
   send_timeout_task_.reset();
   if (send_timeout_ > 0) {
     send_timeout_task_.reset(new TimeoutTask(
         base::Bind(&SerialConnection::OnSendTimeout, AsWeakPtr()),
         base::TimeDelta::FromMilliseconds(send_timeout_)));
   }
   return true;
 }
 
 bool SerialConnection::Configure(
-    const core_api::serial::ConnectionOptions& options) {
+    const api::serial::ConnectionOptions& options) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (options.persistent.get())
     set_persistent(*options.persistent);
   if (options.name.get())
     set_name(*options.name);
   if (options.buffer_size.get())
     set_buffer_size(*options.buffer_size);
   if (options.receive_timeout.get())
     set_receive_timeout(*options.receive_timeout);
   if (options.send_timeout.get())
     set_send_timeout(*options.send_timeout);
   bool success = io_handler_->ConfigurePort(
       *device::serial::ConnectionOptions::From(options));
   io_handler_->CancelRead(device::serial::RECEIVE_ERROR_NONE);
   return success;
 }
 
 void SerialConnection::SetIoHandlerForTest(
     scoped_refptr<device::SerialIoHandler> handler) {
   io_handler_ = handler;
 }
 
-bool SerialConnection::GetInfo(core_api::serial::ConnectionInfo* info) const {
+bool SerialConnection::GetInfo(api::serial::ConnectionInfo* info) const {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   info->paused = paused_;
   info->persistent = persistent_;
   info->name = name_;
   info->buffer_size = buffer_size_;
   info->receive_timeout = receive_timeout_;
   info->send_timeout = send_timeout_;
   device::serial::ConnectionInfoPtr port_info = io_handler_->GetPortInfo();
   if (!port_info)
     return false;
 
   info->bitrate.reset(new int(port_info->bitrate));
   info->data_bits = ConvertDataBitsFromMojo(port_info->data_bits);
   info->parity_bit = ConvertParityBitFromMojo(port_info->parity_bit);
   info->stop_bits = ConvertStopBitsFromMojo(port_info->stop_bits);
   info->cts_flow_control.reset(new bool(port_info->cts_flow_control));
   return true;
 }
 
 bool SerialConnection::Flush() const {
   return io_handler_->Flush();
 }
 
 bool SerialConnection::GetControlSignals(
-    core_api::serial::DeviceControlSignals* control_signals) const {
+    api::serial::DeviceControlSignals* control_signals) const {
   device::serial::DeviceControlSignalsPtr signals =
       io_handler_->GetControlSignals();
   if (!signals)
     return false;
 
   control_signals->dcd = signals->dcd;
   control_signals->cts = signals->cts;
   control_signals->ri = signals->ri;
   control_signals->dsr = signals->dsr;
   return true;
 }
 
 bool SerialConnection::SetControlSignals(
-    const core_api::serial::HostControlSignals& control_signals) {
+    const api::serial::HostControlSignals& control_signals) {
   return io_handler_->SetControlSignals(
       *device::serial::HostControlSignals::From(control_signals));
 }
 
 bool SerialConnection::SetBreak() {
   return io_handler_->SetBreak();
 }
 
 bool SerialConnection::ClearBreak() {
   return io_handler_->ClearBreak();
@@ skipping 48 matching lines @@
   closure_.Run();
 }
 
 }  // namespace extensions
 
 namespace mojo {
 
 // static
 device::serial::HostControlSignalsPtr
 TypeConverter<device::serial::HostControlSignalsPtr,
-              extensions::core_api::serial::HostControlSignals>::
-    Convert(const extensions::core_api::serial::HostControlSignals& input) {
+              extensions::api::serial::HostControlSignals>::
+    Convert(const extensions::api::serial::HostControlSignals& input) {
   device::serial::HostControlSignalsPtr output(
       device::serial::HostControlSignals::New());
   if (input.dtr.get()) {
     output->has_dtr = true;
     output->dtr = *input.dtr;
   }
   if (input.rts.get()) {
     output->has_rts = true;
     output->rts = *input.rts;
   }
   return output.Pass();
 }
 
 // static
 device::serial::ConnectionOptionsPtr
 TypeConverter<device::serial::ConnectionOptionsPtr,
-              extensions::core_api::serial::ConnectionOptions>::
-    Convert(const extensions::core_api::serial::ConnectionOptions& input) {
+              extensions::api::serial::ConnectionOptions>::
+    Convert(const extensions::api::serial::ConnectionOptions& input) {
   device::serial::ConnectionOptionsPtr output(
       device::serial::ConnectionOptions::New());
   if (input.bitrate.get() && *input.bitrate > 0)
     output->bitrate = *input.bitrate;
   output->data_bits = extensions::ConvertDataBitsToMojo(input.data_bits);
   output->parity_bit = extensions::ConvertParityBitToMojo(input.parity_bit);
   output->stop_bits = extensions::ConvertStopBitsToMojo(input.stop_bits);
   if (input.cts_flow_control.get()) {
     output->has_cts_flow_control = true;
     output->cts_flow_control = *input.cts_flow_control;
   }
   return output.Pass();
 }
 
 }  // namespace mojo