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

extensions/browser/api/hid/hid_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/hid/hid_api.h"
 
 #include <string>
 #include <vector>
 
 #include "base/stl_util.h"
 #include "device/core/device_client.h"
 #include "device/hid/hid_connection.h"
 #include "device/hid/hid_device_filter.h"
 #include "device/hid/hid_device_info.h"
 #include "device/hid/hid_service.h"
 #include "extensions/browser/api/api_resource_manager.h"
 #include "extensions/browser/api/device_permissions_prompt.h"
 #include "extensions/browser/api/extensions_api_client.h"
 #include "extensions/common/api/hid.h"
 #include "net/base/io_buffer.h"
 
-namespace hid = extensions::core_api::hid;
+namespace hid = extensions::api::hid;
 
 using device::HidConnection;
 using device::HidDeviceFilter;
 using device::HidDeviceInfo;
 using device::HidService;
 
 namespace {
 
 const char kErrorPermissionDenied[] = "Permission to access device was denied.";
 const char kErrorInvalidDeviceId[] = "Invalid HID device ID.";
@@ skipping 26 matching lines @@
 
 }  // namespace
 
 namespace extensions {
 
 HidGetDevicesFunction::HidGetDevicesFunction() {}
 
 HidGetDevicesFunction::~HidGetDevicesFunction() {}
 
 ExtensionFunction::ResponseAction HidGetDevicesFunction::Run() {
-  scoped_ptr<core_api::hid::GetDevices::Params> parameters =
+  scoped_ptr<api::hid::GetDevices::Params> parameters =
       hid::GetDevices::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters);
 
   HidDeviceManager* device_manager = HidDeviceManager::Get(browser_context());
   CHECK(device_manager);
 
   std::vector<HidDeviceFilter> filters;
   if (parameters->options.filters) {
     filters.resize(parameters->options.filters->size());
     for (size_t i = 0; i < parameters->options.filters->size(); ++i) {
@@ skipping 20 matching lines @@
   Respond(OneArgument(devices.release()));
 }
 
 HidGetUserSelectedDevicesFunction::HidGetUserSelectedDevicesFunction() {
 }
 
 HidGetUserSelectedDevicesFunction::~HidGetUserSelectedDevicesFunction() {
 }
 
 ExtensionFunction::ResponseAction HidGetUserSelectedDevicesFunction::Run() {
-  scoped_ptr<core_api::hid::GetUserSelectedDevices::Params> parameters =
+  scoped_ptr<api::hid::GetUserSelectedDevices::Params> parameters =
       hid::GetUserSelectedDevices::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters);
 
   content::WebContents* web_contents = GetSenderWebContents();
   if (!web_contents || !user_gesture()) {
     return RespondNow(OneArgument(new base::ListValue()));
   }
 
   bool multiple = false;
   std::vector<HidDeviceFilter> filters;
@@ skipping 23 matching lines @@
   CHECK(device_manager);
   Respond(OneArgument(device_manager->GetApiDevicesFromList(devices).Pass()));
 }
 
 HidConnectFunction::HidConnectFunction() : connection_manager_(nullptr) {
 }
 
 HidConnectFunction::~HidConnectFunction() {}
 
 ExtensionFunction::ResponseAction HidConnectFunction::Run() {
-  scoped_ptr<core_api::hid::Connect::Params> parameters =
+  scoped_ptr<api::hid::Connect::Params> parameters =
       hid::Connect::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters);
 
   HidDeviceManager* device_manager = HidDeviceManager::Get(browser_context());
   CHECK(device_manager);
 
   connection_manager_ =
       ApiResourceManager<HidConnectionResource>::Get(browser_context());
   CHECK(connection_manager_);
 
@@ skipping 27 matching lines @@
   int connection_id = connection_manager_->Add(
       new HidConnectionResource(extension_id(), connection));
   Respond(OneArgument(PopulateHidConnection(connection_id, connection)));
 }
 
 HidDisconnectFunction::HidDisconnectFunction() {}
 
 HidDisconnectFunction::~HidDisconnectFunction() {}
 
 ExtensionFunction::ResponseAction HidDisconnectFunction::Run() {
-  scoped_ptr<core_api::hid::Disconnect::Params> parameters =
+  scoped_ptr<api::hid::Disconnect::Params> parameters =
       hid::Disconnect::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters);
 
   ApiResourceManager<HidConnectionResource>* connection_manager =
       ApiResourceManager<HidConnectionResource>::Get(browser_context());
   CHECK(connection_manager);
 
   int connection_id = parameters->connection_id;
   HidConnectionResource* resource =
       connection_manager->Get(extension_id(), connection_id);
@@ skipping 142 matching lines @@
 
 void HidSendFeatureReportFunction::OnFinished(bool success) {
   if (success) {
     Respond(NoArguments());
   } else {
     Respond(Error(kErrorTransfer));
   }
 }
 
 }  // namespace extensions