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

extensions/browser/api/webcam_private/visca_webcam.cc

 // Copyright 2015 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/webcam_private/visca_webcam.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "content/public/browser/browser_thread.h"
 
@@ skipping 93 matching lines @@
 void ViscaWebcam::Open(const OpenCompleteCallback& open_callback) {
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&ViscaWebcam::OpenOnIOThread, weak_ptr_factory_.GetWeakPtr(),
                  open_callback));
 }
 
 void ViscaWebcam::OpenOnIOThread(const OpenCompleteCallback& open_callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
-  core_api::serial::ConnectionOptions options;
+  api::serial::ConnectionOptions options;
 
   // Set the receive buffer size to receive the response data 1 by 1.
   options.buffer_size.reset(new int(1));
   options.persistent.reset(new bool(false));
   options.bitrate.reset(new int(9600));
   options.cts_flow_control.reset(new bool(false));
   options.receive_timeout.reset(new int(0));
   options.send_timeout.reset(new int(0));
-  options.data_bits = core_api::serial::DATA_BITS_EIGHT;
-  options.parity_bit = core_api::serial::PARITY_BIT_NO;
-  options.stop_bits = core_api::serial::STOP_BITS_ONE;
+  options.data_bits = api::serial::DATA_BITS_EIGHT;
+  options.parity_bit = api::serial::PARITY_BIT_NO;
+  options.stop_bits = api::serial::STOP_BITS_ONE;
 
   serial_connection_.reset(new SerialConnection(path_, extension_id_));
   serial_connection_->Open(
       options, base::Bind(&ViscaWebcam::OnConnected,
                           weak_ptr_factory_.GetWeakPtr(), open_callback));
 }
 
 void ViscaWebcam::OnConnected(const OpenCompleteCallback& open_callback,
                               bool success) {
   if (!success) {
@@ skipping 42 matching lines @@
   if (!commands_.empty() ||
       !serial_connection_->Send(
           command, base::Bind(&ViscaWebcam::OnSendCompleted,
                               weak_ptr_factory_.GetWeakPtr(), callback))) {
     commands_.push_back(std::make_pair(command, callback));
   }
 }
 
 void ViscaWebcam::OnSendCompleted(const CommandCompleteCallback& callback,
                                   int bytes_sent,
-                                  core_api::serial::SendError error) {
-  if (error == core_api::serial::SEND_ERROR_NONE) {
+                                  api::serial::SendError error) {
+  if (error == api::serial::SEND_ERROR_NONE) {
     ReceiveLoop(callback);
   } else {
     const std::vector<char> response;
     callback.Run(false, response);
   }
 }
 
 void ViscaWebcam::ReceiveLoop(const CommandCompleteCallback& callback) {
   serial_connection_->Receive(base::Bind(&ViscaWebcam::OnReceiveCompleted,
                                          weak_ptr_factory_.GetWeakPtr(),
                                          callback));
 }
 
 void ViscaWebcam::OnReceiveCompleted(const CommandCompleteCallback& callback,
                                      const std::vector<char>& data,
-                                     core_api::serial::ReceiveError error) {
+                                     api::serial::ReceiveError error) {
   data_buffer_.insert(data_buffer_.end(), data.begin(), data.end());
 
-  if (error == core_api::serial::RECEIVE_ERROR_NONE) {
+  if (error == api::serial::RECEIVE_ERROR_NONE) {
     // Loop until encounter the terminator.
     if (int(data_buffer_.back()) != VISCA_TERMINATOR) {
       base::MessageLoop::current()->PostTask(
           FROM_HERE, base::Bind(&ViscaWebcam::ReceiveLoop,
                                 weak_ptr_factory_.GetWeakPtr(), callback));
     } else {
       // Clear |data_buffer_|.
       std::vector<char> response;
       response.swap(data_buffer_);
 
@@ skipping 171 matching lines @@
     case TILT_DOWN:
       command = kPTDownCommand;
       break;
   }
   Send(command, base::Bind(&ViscaWebcam::OnCommandCompleted,
                            weak_ptr_factory_.GetWeakPtr(), COMMAND, &tilt_));
   return true;
 }
 
 }  // namespace extensions