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

extensions/browser/api/sockets_udp/sockets_udp_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_udp/sockets_udp_api.h"
 
 #include "content/public/common/socket_permission_request.h"
 #include "extensions/browser/api/socket/udp_socket.h"
 #include "extensions/browser/api/sockets_udp/udp_socket_event_dispatcher.h"
 #include "extensions/common/api/sockets/sockets_manifest_data.h"
 #include "net/base/net_errors.h"
 
 namespace extensions {
-namespace core_api {
+namespace api {
 
 using content::SocketPermissionRequest;
 
 const char kSocketNotFoundError[] = "Socket not found";
 const char kPermissionError[] = "App does not have permission";
 const char kWildcardAddress[] = "*";
 const int kWildcardPort = 0;
 
 UDPSocketAsyncApiFunction::~UDPSocketAsyncApiFunction() {}
 
@@ skipping 105 matching lines @@
   SetSocketProperties(socket, &params_.get()->properties);
   results_ = sockets_udp::Update::Results::Create();
 }
 
 SocketsUdpSetPausedFunction::SocketsUdpSetPausedFunction()
     : socket_event_dispatcher_(NULL) {}
 
 SocketsUdpSetPausedFunction::~SocketsUdpSetPausedFunction() {}
 
 bool SocketsUdpSetPausedFunction::Prepare() {
-  params_ = core_api::sockets_udp::SetPaused::Params::Create(*args_);
+  params_ = api::sockets_udp::SetPaused::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
 
   socket_event_dispatcher_ = UDPSocketEventDispatcher::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 "
          "UDPSocketEventDispatcher.";
   return socket_event_dispatcher_ != NULL;
 }
@@ skipping 236 matching lines @@
   if (net_result != net::OK)
     error_ = net::ErrorToString(net_result);
   results_ = sockets_udp::JoinGroup::Results::Create(net_result);
 }
 
 SocketsUdpLeaveGroupFunction::SocketsUdpLeaveGroupFunction() {}
 
 SocketsUdpLeaveGroupFunction::~SocketsUdpLeaveGroupFunction() {}
 
 bool SocketsUdpLeaveGroupFunction::Prepare() {
-  params_ = core_api::sockets_udp::LeaveGroup::Params::Create(*args_);
+  params_ = api::sockets_udp::LeaveGroup::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SocketsUdpLeaveGroupFunction::Work() {
   ResumableUDPSocket* socket = GetUdpSocket(params_->socket_id);
   if (!socket) {
     error_ = kSocketNotFoundError;
     return;
   }
@@ skipping 13 matching lines @@
   results_ = sockets_udp::LeaveGroup::Results::Create(net_result);
 }
 
 SocketsUdpSetMulticastTimeToLiveFunction::
     SocketsUdpSetMulticastTimeToLiveFunction() {}
 
 SocketsUdpSetMulticastTimeToLiveFunction::
     ~SocketsUdpSetMulticastTimeToLiveFunction() {}
 
 bool SocketsUdpSetMulticastTimeToLiveFunction::Prepare() {
-  params_ =
-      core_api::sockets_udp::SetMulticastTimeToLive::Params::Create(*args_);
+  params_ = api::sockets_udp::SetMulticastTimeToLive::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SocketsUdpSetMulticastTimeToLiveFunction::Work() {
   ResumableUDPSocket* socket = GetUdpSocket(params_->socket_id);
   if (!socket) {
     error_ = kSocketNotFoundError;
     return;
   }
 
   int net_result = socket->SetMulticastTimeToLive(params_->ttl);
   if (net_result != net::OK)
     error_ = net::ErrorToString(net_result);
   results_ = sockets_udp::SetMulticastTimeToLive::Results::Create(net_result);
 }
 
 SocketsUdpSetMulticastLoopbackModeFunction::
     SocketsUdpSetMulticastLoopbackModeFunction() {}
 
 SocketsUdpSetMulticastLoopbackModeFunction::
     ~SocketsUdpSetMulticastLoopbackModeFunction() {}
 
 bool SocketsUdpSetMulticastLoopbackModeFunction::Prepare() {
-  params_ =
-      core_api::sockets_udp::SetMulticastLoopbackMode::Params::Create(*args_);
+  params_ = api::sockets_udp::SetMulticastLoopbackMode::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SocketsUdpSetMulticastLoopbackModeFunction::Work() {
   ResumableUDPSocket* socket = GetUdpSocket(params_->socket_id);
   if (!socket) {
     error_ = kSocketNotFoundError;
     return;
   }
 
   int net_result = socket->SetMulticastLoopbackMode(params_->enabled);
   if (net_result != net::OK)
     error_ = net::ErrorToString(net_result);
   results_ = sockets_udp::SetMulticastLoopbackMode::Results::Create(net_result);
 }
 
 SocketsUdpGetJoinedGroupsFunction::SocketsUdpGetJoinedGroupsFunction() {}
 
 SocketsUdpGetJoinedGroupsFunction::~SocketsUdpGetJoinedGroupsFunction() {}
 
 bool SocketsUdpGetJoinedGroupsFunction::Prepare() {
-  params_ = core_api::sockets_udp::GetJoinedGroups::Params::Create(*args_);
+  params_ = api::sockets_udp::GetJoinedGroups::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SocketsUdpGetJoinedGroupsFunction::Work() {
   ResumableUDPSocket* socket = GetUdpSocket(params_->socket_id);
   if (!socket) {
     error_ = kSocketNotFoundError;
     return;
   }
@@ skipping 11 matching lines @@
   results_ = sockets_udp::GetJoinedGroups::Results::Create(groups);
 }
 
 SocketsUdpSetBroadcastFunction::SocketsUdpSetBroadcastFunction() {
 }
 
 SocketsUdpSetBroadcastFunction::~SocketsUdpSetBroadcastFunction() {
 }
 
 bool SocketsUdpSetBroadcastFunction::Prepare() {
-  params_ = core_api::sockets_udp::SetBroadcast::Params::Create(*args_);
+  params_ = api::sockets_udp::SetBroadcast::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SocketsUdpSetBroadcastFunction::Work() {
   ResumableUDPSocket* socket = GetUdpSocket(params_->socket_id);
   if (!socket) {
     error_ = kSocketNotFoundError;
     return;
   }
 
   int net_result = socket->SetBroadcast(params_->enabled);
   if (net_result != net::OK) {
     error_ = net::ErrorToString(net_result);
   }
   results_ = sockets_udp::SetBroadcast::Results::Create(net_result);
 }
 
-}  // namespace core_api
+}  // namespace api
 }  // namespace extensions