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

extensions/browser/api/sockets_tcp/sockets_tcp_api.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/sockets_tcp/sockets_tcp_api.h"
 
 #include "content/public/browser/browser_context.h"
 #include "content/public/common/socket_permission_request.h"
 #include "extensions/browser/api/socket/tcp_socket.h"
 #include "extensions/browser/api/socket/tls_socket.h"
 #include "extensions/browser/api/sockets_tcp/tcp_socket_event_dispatcher.h"
 #include "extensions/common/api/sockets/sockets_manifest_data.h"
 #include "net/base/net_errors.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 
 using extensions::ResumableTCPSocket;
-using extensions::core_api::sockets_tcp::SocketInfo;
-using extensions::core_api::sockets_tcp::SocketProperties;
+using extensions::api::sockets_tcp::SocketInfo;
+using extensions::api::sockets_tcp::SocketProperties;
 
 namespace {
 
 const char kSocketNotFoundError[] = "Socket not found";
 const char kPermissionError[] = "Does not have permission";
 const char kInvalidSocketStateError[] =
     "Socket must be a connected client TCP socket.";
 const char kSocketNotConnectedError[] = "Socket not connected";
 
 linked_ptr<SocketInfo> CreateSocketInfo(int socket_id,
@@ skipping 45 matching lines @@
   if (properties->buffer_size.get()) {
     // buffer size is validated when issuing the actual Recv operation
     // on the socket.
     socket->set_buffer_size(*properties->buffer_size.get());
   }
 }
 
 }  // namespace
 
 namespace extensions {
-namespace core_api {
+namespace api {
 
 using content::SocketPermissionRequest;
 
 TCPSocketAsyncApiFunction::~TCPSocketAsyncApiFunction() {}
 
 scoped_ptr<SocketResourceManagerInterface>
 TCPSocketAsyncApiFunction::CreateSocketResourceManager() {
   return scoped_ptr<SocketResourceManagerInterface>(
              new SocketResourceManager<ResumableTCPSocket>()).Pass();
 }
@@ skipping 59 matching lines @@
   SetSocketProperties(socket, &params_.get()->properties);
   results_ = sockets_tcp::Update::Results::Create();
 }
 
 SocketsTcpSetPausedFunction::SocketsTcpSetPausedFunction()
     : socket_event_dispatcher_(NULL) {}
 
 SocketsTcpSetPausedFunction::~SocketsTcpSetPausedFunction() {}
 
 bool SocketsTcpSetPausedFunction::Prepare() {
-  params_ = core_api::sockets_tcp::SetPaused::Params::Create(*args_);
+  params_ = api::sockets_tcp::SetPaused::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
 
   socket_event_dispatcher_ = TCPSocketEventDispatcher::Get(browser_context());
   DCHECK(socket_event_dispatcher_)
       << "There is no socket event dispatcher. "
          "If this assertion is failing during a test, then it is likely that "
          "TestExtensionSystem is failing to provide an instance of "
          "TCPSocketEventDispatcher.";
   return socket_event_dispatcher_ != NULL;
 }
@@ skipping 14 matching lines @@
   }
 
   results_ = sockets_tcp::SetPaused::Results::Create();
 }
 
 SocketsTcpSetKeepAliveFunction::SocketsTcpSetKeepAliveFunction() {}
 
 SocketsTcpSetKeepAliveFunction::~SocketsTcpSetKeepAliveFunction() {}
 
 bool SocketsTcpSetKeepAliveFunction::Prepare() {
-  params_ = core_api::sockets_tcp::SetKeepAlive::Params::Create(*args_);
+  params_ = api::sockets_tcp::SetKeepAlive::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SocketsTcpSetKeepAliveFunction::Work() {
   ResumableTCPSocket* socket = GetTcpSocket(params_->socket_id);
   if (!socket) {
     error_ = kSocketNotFoundError;
     return;
   }
 
   int delay = params_->delay ? *params_->delay.get() : 0;
 
   bool success = socket->SetKeepAlive(params_->enable, delay);
   int net_result = (success ? net::OK : net::ERR_FAILED);
   if (net_result != net::OK)
     error_ = net::ErrorToString(net_result);
   results_ = sockets_tcp::SetKeepAlive::Results::Create(net_result);
 }
 
 SocketsTcpSetNoDelayFunction::SocketsTcpSetNoDelayFunction() {}
 
 SocketsTcpSetNoDelayFunction::~SocketsTcpSetNoDelayFunction() {}
 
 bool SocketsTcpSetNoDelayFunction::Prepare() {
-  params_ = core_api::sockets_tcp::SetNoDelay::Params::Create(*args_);
+  params_ = api::sockets_tcp::SetNoDelay::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SocketsTcpSetNoDelayFunction::Work() {
   ResumableTCPSocket* socket = GetTcpSocket(params_->socket_id);
   if (!socket) {
     error_ = kSocketNotFoundError;
     return;
   }
@@ skipping 213 matching lines @@
 }
 
 SocketsTcpSecureFunction::SocketsTcpSecureFunction() {
 }
 
 SocketsTcpSecureFunction::~SocketsTcpSecureFunction() {
 }
 
 bool SocketsTcpSecureFunction::Prepare() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  params_ = core_api::sockets_tcp::Secure::Params::Create(*args_);
+  params_ = api::sockets_tcp::Secure::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   url_request_getter_ = browser_context()->GetRequestContext();
   return true;
 }
 
 // Override the regular implementation, which would call AsyncWorkCompleted
 // immediately after Work().
 void SocketsTcpSecureFunction::AsyncWorkStart() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
@@ skipping 23 matching lines @@
     error_ = kSocketNotConnectedError;
     AsyncWorkCompleted();
     return;
   }
 
   net::URLRequestContext* url_request_context =
       url_request_getter_->GetURLRequestContext();
 
   // UpgradeSocketToTLS() uses the older API's SecureOptions. Copy over the
   // only values inside -- TLSVersionConstraints's |min| and |max|,
-  core_api::socket::SecureOptions legacy_params;
+  api::socket::SecureOptions legacy_params;
   if (params_->options.get() && params_->options->tls_version.get()) {
-    legacy_params.tls_version.reset(
-        new core_api::socket::TLSVersionConstraints);
+    legacy_params.tls_version.reset(new api::socket::TLSVersionConstraints);
     if (params_->options->tls_version->min.get()) {
       legacy_params.tls_version->min.reset(
           new std::string(*params_->options->tls_version->min.get()));
     }
     if (params_->options->tls_version->max.get()) {
       legacy_params.tls_version->max.reset(
           new std::string(*params_->options->tls_version->max.get()));
     }
   }
 
@@ skipping 14 matching lines @@
 
   if (socket && result == net::OK) {
     socket->set_persistent(persistent_);
     socket->set_paused(paused_);
     ReplaceSocket(params_->socket_id, socket.release());
   } else {
     RemoveSocket(params_->socket_id);
     error_ = net::ErrorToString(result);
   }
 
-  results_ = core_api::sockets_tcp::Secure::Results::Create(result);
+  results_ = api::sockets_tcp::Secure::Results::Create(result);
   AsyncWorkCompleted();
 }
 
 }  // namespace api
 }  // namespace extensions