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

extensions/browser/api/socket/socket_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/socket/socket_api.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/containers/hash_tables.h"
@@ skipping 198 matching lines @@
   }
   AfterDnsLookup(resolve_result);
 }
 
 SocketCreateFunction::SocketCreateFunction()
     : socket_type_(kSocketTypeInvalid) {}
 
 SocketCreateFunction::~SocketCreateFunction() {}
 
 bool SocketCreateFunction::Prepare() {
-  params_ = core_api::socket::Create::Params::Create(*args_);
+  params_ = api::socket::Create::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
 
   switch (params_->type) {
-    case extensions::core_api::socket::SOCKET_TYPE_TCP:
+    case extensions::api::socket::SOCKET_TYPE_TCP:
       socket_type_ = kSocketTypeTCP;
       break;
-    case extensions::core_api::socket::SOCKET_TYPE_UDP:
+    case extensions::api::socket::SOCKET_TYPE_UDP:
       socket_type_ = kSocketTypeUDP;
       break;
-    case extensions::core_api::socket::SOCKET_TYPE_NONE:
+    case extensions::api::socket::SOCKET_TYPE_NONE:
       NOTREACHED();
       break;
   }
 
   return true;
 }
 
 void SocketCreateFunction::Work() {
   Socket* socket = NULL;
   if (socket_type_ == kSocketTypeTCP) {
@@ skipping 154 matching lines @@
   }
 
   OpenFirewallHole(address_, socket_id_, socket);
 }
 
 SocketListenFunction::SocketListenFunction() {}
 
 SocketListenFunction::~SocketListenFunction() {}
 
 bool SocketListenFunction::Prepare() {
-  params_ = core_api::socket::Listen::Params::Create(*args_);
+  params_ = api::socket::Listen::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SocketListenFunction::AsyncWorkStart() {
   Socket* socket = GetSocket(params_->socket_id);
   if (!socket) {
     error_ = kSocketNotFoundError;
     SetResult(new base::FundamentalValue(-1));
     AsyncWorkCompleted();
@@ skipping 20 matching lines @@
   }
 
   OpenFirewallHole(params_->address, params_->socket_id, socket);
 }
 
 SocketAcceptFunction::SocketAcceptFunction() {}
 
 SocketAcceptFunction::~SocketAcceptFunction() {}
 
 bool SocketAcceptFunction::Prepare() {
-  params_ = core_api::socket::Accept::Params::Create(*args_);
+  params_ = api::socket::Accept::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SocketAcceptFunction::AsyncWorkStart() {
   Socket* socket = GetSocket(params_->socket_id);
   if (socket) {
     socket->Accept(base::Bind(&SocketAcceptFunction::OnAccept, this));
   } else {
     error_ = kSocketNotFoundError;
@@ skipping 12 matching lines @@
   SetResult(result);
 
   AsyncWorkCompleted();
 }
 
 SocketReadFunction::SocketReadFunction() {}
 
 SocketReadFunction::~SocketReadFunction() {}
 
 bool SocketReadFunction::Prepare() {
-  params_ = core_api::socket::Read::Params::Create(*args_);
+  params_ = api::socket::Read::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SocketReadFunction::AsyncWorkStart() {
   Socket* socket = GetSocket(params_->socket_id);
   if (!socket) {
     error_ = kSocketNotFoundError;
     OnCompleted(-1, NULL);
     return;
@@ skipping 54 matching lines @@
   SetResult(result);
 
   AsyncWorkCompleted();
 }
 
 SocketRecvFromFunction::SocketRecvFromFunction() {}
 
 SocketRecvFromFunction::~SocketRecvFromFunction() {}
 
 bool SocketRecvFromFunction::Prepare() {
-  params_ = core_api::socket::RecvFrom::Params::Create(*args_);
+  params_ = api::socket::RecvFrom::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SocketRecvFromFunction::AsyncWorkStart() {
   Socket* socket = GetSocket(params_->socket_id);
   if (!socket || socket->GetSocketType() != Socket::TYPE_UDP) {
     error_ = kSocketNotFoundError;
     OnCompleted(-1, NULL, std::string(), 0);
     return;
@@ skipping 96 matching lines @@
   SetResult(result);
 
   AsyncWorkCompleted();
 }
 
 SocketSetKeepAliveFunction::SocketSetKeepAliveFunction() {}
 
 SocketSetKeepAliveFunction::~SocketSetKeepAliveFunction() {}
 
 bool SocketSetKeepAliveFunction::Prepare() {
-  params_ = core_api::socket::SetKeepAlive::Params::Create(*args_);
+  params_ = api::socket::SetKeepAlive::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SocketSetKeepAliveFunction::Work() {
   bool result = false;
   Socket* socket = GetSocket(params_->socket_id);
   if (socket) {
     int delay = 0;
     if (params_->delay.get())
       delay = *params_->delay;
     result = socket->SetKeepAlive(params_->enable, delay);
   } else {
     error_ = kSocketNotFoundError;
   }
   SetResult(new base::FundamentalValue(result));
 }
 
 SocketSetNoDelayFunction::SocketSetNoDelayFunction() {}
 
 SocketSetNoDelayFunction::~SocketSetNoDelayFunction() {}
 
 bool SocketSetNoDelayFunction::Prepare() {
-  params_ = core_api::socket::SetNoDelay::Params::Create(*args_);
+  params_ = api::socket::SetNoDelay::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SocketSetNoDelayFunction::Work() {
   bool result = false;
   Socket* socket = GetSocket(params_->socket_id);
   if (socket)
     result = socket->SetNoDelay(params_->no_delay);
   else
     error_ = kSocketNotFoundError;
   SetResult(new base::FundamentalValue(result));
 }
 
 SocketGetInfoFunction::SocketGetInfoFunction() {}
 
 SocketGetInfoFunction::~SocketGetInfoFunction() {}
 
 bool SocketGetInfoFunction::Prepare() {
-  params_ = core_api::socket::GetInfo::Params::Create(*args_);
+  params_ = api::socket::GetInfo::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SocketGetInfoFunction::Work() {
   Socket* socket = GetSocket(params_->socket_id);
   if (!socket) {
     error_ = kSocketNotFoundError;
     return;
   }
 
-  core_api::socket::SocketInfo info;
+  api::socket::SocketInfo info;
   // This represents what we know about the socket, and does not call through
   // to the system.
   if (socket->GetSocketType() == Socket::TYPE_TCP)
-    info.socket_type = extensions::core_api::socket::SOCKET_TYPE_TCP;
+    info.socket_type = extensions::api::socket::SOCKET_TYPE_TCP;
   else
-    info.socket_type = extensions::core_api::socket::SOCKET_TYPE_UDP;
+    info.socket_type = extensions::api::socket::SOCKET_TYPE_UDP;
   info.connected = socket->IsConnected();
 
   // Grab the peer address as known by the OS. This and the call below will
   // always succeed while the socket is connected, even if the socket has
   // been remotely closed by the peer; only reading the socket will reveal
   // that it should be closed locally.
   net::IPEndPoint peerAddress;
   if (socket->GetPeerAddress(&peerAddress)) {
     info.peer_address.reset(new std::string(peerAddress.ToStringWithoutPort()));
     info.peer_port.reset(new int(peerAddress.port()));
@@ skipping 38 matching lines @@
 void SocketGetNetworkListFunction::HandleGetNetworkListError() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   error_ = kNetworkListError;
   SendResponse(false);
 }
 
 void SocketGetNetworkListFunction::SendResponseOnUIThread(
     const net::NetworkInterfaceList& interface_list) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
-  std::vector<linked_ptr<core_api::socket::NetworkInterface> > create_arg;
+  std::vector<linked_ptr<api::socket::NetworkInterface>> create_arg;
   create_arg.reserve(interface_list.size());
   for (net::NetworkInterfaceList::const_iterator i = interface_list.begin();
        i != interface_list.end();
        ++i) {
-    linked_ptr<core_api::socket::NetworkInterface> info =
-        make_linked_ptr(new core_api::socket::NetworkInterface);
+    linked_ptr<api::socket::NetworkInterface> info =
+        make_linked_ptr(new api::socket::NetworkInterface);
     info->name = i->name;
     info->address = net::IPAddressToString(i->address);
     info->prefix_length = i->prefix_length;
     create_arg.push_back(info);
   }
 
-  results_ = core_api::socket::GetNetworkList::Results::Create(create_arg);
+  results_ = api::socket::GetNetworkList::Results::Create(create_arg);
   SendResponse(true);
 }
 
 SocketJoinGroupFunction::SocketJoinGroupFunction() {}
 
 SocketJoinGroupFunction::~SocketJoinGroupFunction() {}
 
 bool SocketJoinGroupFunction::Prepare() {
-  params_ = core_api::socket::JoinGroup::Params::Create(*args_);
+  params_ = api::socket::JoinGroup::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SocketJoinGroupFunction::Work() {
   int result = -1;
   Socket* socket = GetSocket(params_->socket_id);
   if (!socket) {
     error_ = kSocketNotFoundError;
     SetResult(new base::FundamentalValue(result));
@@ skipping 23 matching lines @@
     error_ = net::ErrorToString(result);
   }
   SetResult(new base::FundamentalValue(result));
 }
 
 SocketLeaveGroupFunction::SocketLeaveGroupFunction() {}
 
 SocketLeaveGroupFunction::~SocketLeaveGroupFunction() {}
 
 bool SocketLeaveGroupFunction::Prepare() {
-  params_ = core_api::socket::LeaveGroup::Params::Create(*args_);
+  params_ = api::socket::LeaveGroup::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SocketLeaveGroupFunction::Work() {
   int result = -1;
   Socket* socket = GetSocket(params_->socket_id);
 
   if (!socket) {
     error_ = kSocketNotFoundError;
@@ skipping 22 matching lines @@
   if (result != 0)
     error_ = net::ErrorToString(result);
   SetResult(new base::FundamentalValue(result));
 }
 
 SocketSetMulticastTimeToLiveFunction::SocketSetMulticastTimeToLiveFunction() {}
 
 SocketSetMulticastTimeToLiveFunction::~SocketSetMulticastTimeToLiveFunction() {}
 
 bool SocketSetMulticastTimeToLiveFunction::Prepare() {
-  params_ = core_api::socket::SetMulticastTimeToLive::Params::Create(*args_);
+  params_ = api::socket::SetMulticastTimeToLive::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 void SocketSetMulticastTimeToLiveFunction::Work() {
   int result = -1;
   Socket* socket = GetSocket(params_->socket_id);
   if (!socket) {
     error_ = kSocketNotFoundError;
     SetResult(new base::FundamentalValue(result));
     return;
@@ skipping 12 matching lines @@
   SetResult(new base::FundamentalValue(result));
 }
 
 SocketSetMulticastLoopbackModeFunction::
     SocketSetMulticastLoopbackModeFunction() {}
 
 SocketSetMulticastLoopbackModeFunction::
     ~SocketSetMulticastLoopbackModeFunction() {}
 
 bool SocketSetMulticastLoopbackModeFunction::Prepare() {
-  params_ = core_api::socket::SetMulticastLoopbackMode::Params::Create(*args_);
+  params_ = api::socket::SetMulticastLoopbackMode::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SocketSetMulticastLoopbackModeFunction::Work() {
   int result = -1;
   Socket* socket = GetSocket(params_->socket_id);
   if (!socket) {
     error_ = kSocketNotFoundError;
     SetResult(new base::FundamentalValue(result));
@@ skipping 11 matching lines @@
   if (result != 0)
     error_ = net::ErrorToString(result);
   SetResult(new base::FundamentalValue(result));
 }
 
 SocketGetJoinedGroupsFunction::SocketGetJoinedGroupsFunction() {}
 
 SocketGetJoinedGroupsFunction::~SocketGetJoinedGroupsFunction() {}
 
 bool SocketGetJoinedGroupsFunction::Prepare() {
-  params_ = core_api::socket::GetJoinedGroups::Params::Create(*args_);
+  params_ = api::socket::GetJoinedGroups::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SocketGetJoinedGroupsFunction::Work() {
   int result = -1;
   Socket* socket = GetSocket(params_->socket_id);
   if (!socket) {
     error_ = kSocketNotFoundError;
     SetResult(new base::FundamentalValue(result));
@@ skipping 24 matching lines @@
 }
 
 SocketSecureFunction::SocketSecureFunction() {
 }
 
 SocketSecureFunction::~SocketSecureFunction() {
 }
 
 bool SocketSecureFunction::Prepare() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  params_ = core_api::socket::Secure::Params::Create(*args_);
+  params_ = api::socket::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 SocketSecureFunction::AsyncWorkStart() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
@@ skipping 39 matching lines @@
   // if an error occurred, socket MUST be NULL.
   DCHECK(result == net::OK || socket == NULL);
 
   if (socket && result == net::OK) {
     ReplaceSocket(params_->socket_id, socket.release());
   } else {
     RemoveSocket(params_->socket_id);
     error_ = net::ErrorToString(result);
   }
 
-  results_ = core_api::socket::Secure::Results::Create(result);
+  results_ = api::socket::Secure::Results::Create(result);
   AsyncWorkCompleted();
 }
 
 }  // namespace extensions