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

extensions/browser/api/usb/usb_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/usb/usb_api.h"
 
 #include <string>
 #include <vector>
 
 #include "base/barrier_closure.h"
 #include "base/memory/scoped_ptr.h"
 #include "device/core/device_client.h"
 #include "device/usb/usb_descriptors.h"
 #include "device/usb/usb_device_handle.h"
 #include "device/usb/usb_service.h"
 #include "extensions/browser/api/device_permissions_manager.h"
 #include "extensions/browser/api/device_permissions_prompt.h"
 #include "extensions/browser/api/extensions_api_client.h"
 #include "extensions/browser/api/usb/usb_device_resource.h"
 #include "extensions/browser/api/usb/usb_guid_map.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/common/api/usb.h"
 #include "extensions/common/permissions/permissions_data.h"
 #include "extensions/common/permissions/usb_device_permission.h"
 
-namespace usb = extensions::core_api::usb;
+namespace usb = extensions::api::usb;
 namespace BulkTransfer = usb::BulkTransfer;
 namespace ClaimInterface = usb::ClaimInterface;
 namespace CloseDevice = usb::CloseDevice;
 namespace ControlTransfer = usb::ControlTransfer;
 namespace FindDevices = usb::FindDevices;
 namespace GetDevices = usb::GetDevices;
 namespace GetUserSelectedDevices = usb::GetUserSelectedDevices;
 namespace InterruptTransfer = usb::InterruptTransfer;
 namespace IsochronousTransfer = usb::IsochronousTransfer;
 namespace SetConfiguration = usb::SetConfiguration;
@@ skipping 389 matching lines @@
   }
 }
 
 UsbConnectionFunction::UsbConnectionFunction() {
 }
 
 UsbConnectionFunction::~UsbConnectionFunction() {
 }
 
 scoped_refptr<device::UsbDeviceHandle> UsbConnectionFunction::GetDeviceHandle(
-    const extensions::core_api::usb::ConnectionHandle& handle) {
+    const extensions::api::usb::ConnectionHandle& handle) {
   ApiResourceManager<UsbDeviceResource>* manager =
       ApiResourceManager<UsbDeviceResource>::Get(browser_context());
   if (!manager) {
     return nullptr;
   }
 
   UsbDeviceResource* resource = manager->Get(extension_id(), handle.handle);
   if (!resource) {
     return nullptr;
   }
 
   return resource->device();
 }
 
 void UsbConnectionFunction::ReleaseDeviceHandle(
-    const extensions::core_api::usb::ConnectionHandle& handle) {
+    const extensions::api::usb::ConnectionHandle& handle) {
   ApiResourceManager<UsbDeviceResource>* manager =
       ApiResourceManager<UsbDeviceResource>::Get(browser_context());
   manager->Remove(extension_id(), handle.handle);
 }
 
 UsbTransferFunction::UsbTransferFunction() {
 }
 
 UsbTransferFunction::~UsbTransferFunction() {
 }
@@ skipping 17 matching lines @@
   }
 }
 
 UsbFindDevicesFunction::UsbFindDevicesFunction() {
 }
 
 UsbFindDevicesFunction::~UsbFindDevicesFunction() {
 }
 
 ExtensionFunction::ResponseAction UsbFindDevicesFunction::Run() {
-  scoped_ptr<extensions::core_api::usb::FindDevices::Params> parameters =
+  scoped_ptr<extensions::api::usb::FindDevices::Params> parameters =
       FindDevices::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters.get());
 
   vendor_id_ = parameters->options.vendor_id;
   product_id_ = parameters->options.product_id;
   int interface_id = parameters->options.interface_id.get()
                          ? *parameters->options.interface_id.get()
                          : UsbDevicePermissionData::ANY_INTERFACE;
   UsbDevicePermission::CheckParam param(vendor_id_, product_id_, interface_id);
   if (!extension()->permissions_data()->CheckAPIPermissionWithParam(
@@ skipping 45 matching lines @@
   Respond(OneArgument(result_.release()));
 }
 
 UsbGetDevicesFunction::UsbGetDevicesFunction() {
 }
 
 UsbGetDevicesFunction::~UsbGetDevicesFunction() {
 }
 
 ExtensionFunction::ResponseAction UsbGetDevicesFunction::Run() {
-  scoped_ptr<extensions::core_api::usb::GetDevices::Params> parameters =
+  scoped_ptr<extensions::api::usb::GetDevices::Params> parameters =
       GetDevices::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters.get());
 
   if (parameters->options.filters) {
     filters_.resize(parameters->options.filters->size());
     for (size_t i = 0; i < parameters->options.filters->size(); ++i) {
       ConvertDeviceFilter(*parameters->options.filters->at(i).get(),
                           &filters_[i]);
     }
   }
@@ skipping 30 matching lines @@
   Respond(OneArgument(result.release()));
 }
 
 UsbGetUserSelectedDevicesFunction::UsbGetUserSelectedDevicesFunction() {
 }
 
 UsbGetUserSelectedDevicesFunction::~UsbGetUserSelectedDevicesFunction() {
 }
 
 ExtensionFunction::ResponseAction UsbGetUserSelectedDevicesFunction::Run() {
-  scoped_ptr<extensions::core_api::usb::GetUserSelectedDevices::Params>
-      parameters = GetUserSelectedDevices::Params::Create(*args_);
+  scoped_ptr<extensions::api::usb::GetUserSelectedDevices::Params> parameters =
+      GetUserSelectedDevices::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters.get());
 
   if (!user_gesture()) {
     return RespondNow(OneArgument(new base::ListValue()));
   }
 
   bool multiple = false;
   if (parameters->options.multiple) {
     multiple = *parameters->options.multiple;
   }
@@ skipping 31 matching lines @@
   Respond(OneArgument(result.release()));
 }
 
 UsbRequestAccessFunction::UsbRequestAccessFunction() {
 }
 
 UsbRequestAccessFunction::~UsbRequestAccessFunction() {
 }
 
 ExtensionFunction::ResponseAction UsbRequestAccessFunction::Run() {
-  scoped_ptr<extensions::core_api::usb::RequestAccess::Params> parameters =
+  scoped_ptr<extensions::api::usb::RequestAccess::Params> parameters =
       RequestAccess::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters.get());
   return RespondNow(OneArgument(new base::FundamentalValue(true)));
 }
 
 UsbOpenDeviceFunction::UsbOpenDeviceFunction() {
 }
 
 UsbOpenDeviceFunction::~UsbOpenDeviceFunction() {
 }
 
 ExtensionFunction::ResponseAction UsbOpenDeviceFunction::Run() {
-  scoped_ptr<extensions::core_api::usb::OpenDevice::Params> parameters =
+  scoped_ptr<extensions::api::usb::OpenDevice::Params> parameters =
       OpenDevice::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters.get());
 
   UsbService* service = device::DeviceClient::Get()->GetUsbService();
   if (!service) {
     return RespondNow(Error(kErrorInitService));
   }
 
   std::string guid;
   if (!UsbGuidMap::Get(browser_context())
@@ skipping 33 matching lines @@
       device->vendor_id(), device->product_id())));
 }
 
 UsbSetConfigurationFunction::UsbSetConfigurationFunction() {
 }
 
 UsbSetConfigurationFunction::~UsbSetConfigurationFunction() {
 }
 
 ExtensionFunction::ResponseAction UsbSetConfigurationFunction::Run() {
-  scoped_ptr<extensions::core_api::usb::SetConfiguration::Params> parameters =
+  scoped_ptr<extensions::api::usb::SetConfiguration::Params> parameters =
       SetConfiguration::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters.get());
 
   scoped_refptr<UsbDeviceHandle> device_handle =
       GetDeviceHandle(parameters->handle);
   if (!device_handle.get()) {
     return RespondNow(Error(kErrorNoConnection));
   }
 
   device_handle->SetConfiguration(
@@ skipping 10 matching lines @@
   }
 }
 
 UsbGetConfigurationFunction::UsbGetConfigurationFunction() {
 }
 
 UsbGetConfigurationFunction::~UsbGetConfigurationFunction() {
 }
 
 ExtensionFunction::ResponseAction UsbGetConfigurationFunction::Run() {
-  scoped_ptr<extensions::core_api::usb::GetConfiguration::Params> parameters =
+  scoped_ptr<extensions::api::usb::GetConfiguration::Params> parameters =
       GetConfiguration::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters.get());
 
   scoped_refptr<UsbDeviceHandle> device_handle =
       GetDeviceHandle(parameters->handle);
   if (!device_handle.get()) {
     return RespondNow(Error(kErrorNoConnection));
   }
 
   const UsbConfigDescriptor* config_descriptor =
       device_handle->GetDevice()->GetConfiguration();
   if (config_descriptor) {
     ConfigDescriptor config;
     ConvertConfigDescriptor(*config_descriptor, &config);
     return RespondNow(OneArgument(config.ToValue().release()));
   } else {
     return RespondNow(Error(kErrorNotConfigured));
   }
 }
 
 UsbListInterfacesFunction::UsbListInterfacesFunction() {
 }
 
 UsbListInterfacesFunction::~UsbListInterfacesFunction() {
 }
 
 ExtensionFunction::ResponseAction UsbListInterfacesFunction::Run() {
-  scoped_ptr<extensions::core_api::usb::ListInterfaces::Params> parameters =
+  scoped_ptr<extensions::api::usb::ListInterfaces::Params> parameters =
       ListInterfaces::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters.get());
 
   scoped_refptr<UsbDeviceHandle> device_handle =
       GetDeviceHandle(parameters->handle);
   if (!device_handle.get()) {
     return RespondNow(Error(kErrorNoConnection));
   }
 
   const UsbConfigDescriptor* config_descriptor =
@@ skipping 13 matching lines @@
   }
 }
 
 UsbCloseDeviceFunction::UsbCloseDeviceFunction() {
 }
 
 UsbCloseDeviceFunction::~UsbCloseDeviceFunction() {
 }
 
 ExtensionFunction::ResponseAction UsbCloseDeviceFunction::Run() {
-  scoped_ptr<extensions::core_api::usb::CloseDevice::Params> parameters =
+  scoped_ptr<extensions::api::usb::CloseDevice::Params> parameters =
       CloseDevice::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters.get());
 
   scoped_refptr<UsbDeviceHandle> device_handle =
       GetDeviceHandle(parameters->handle);
   if (!device_handle.get()) {
     return RespondNow(Error(kErrorNoConnection));
   }
 
   // The device handle is closed when the resource is destroyed.
   ReleaseDeviceHandle(parameters->handle);
   return RespondNow(NoArguments());
 }
 
 UsbClaimInterfaceFunction::UsbClaimInterfaceFunction() {
 }
 
 UsbClaimInterfaceFunction::~UsbClaimInterfaceFunction() {
 }
 
 ExtensionFunction::ResponseAction UsbClaimInterfaceFunction::Run() {
-  scoped_ptr<extensions::core_api::usb::ClaimInterface::Params> parameters =
+  scoped_ptr<extensions::api::usb::ClaimInterface::Params> parameters =
       ClaimInterface::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters.get());
 
   scoped_refptr<UsbDeviceHandle> device_handle =
       GetDeviceHandle(parameters->handle);
   if (!device_handle.get()) {
     return RespondNow(Error(kErrorNoConnection));
   }
 
   device_handle->ClaimInterface(
@@ skipping 10 matching lines @@
   }
 }
 
 UsbReleaseInterfaceFunction::UsbReleaseInterfaceFunction() {
 }
 
 UsbReleaseInterfaceFunction::~UsbReleaseInterfaceFunction() {
 }
 
 ExtensionFunction::ResponseAction UsbReleaseInterfaceFunction::Run() {
-  scoped_ptr<extensions::core_api::usb::ReleaseInterface::Params> parameters =
+  scoped_ptr<extensions::api::usb::ReleaseInterface::Params> parameters =
       ReleaseInterface::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters.get());
 
   scoped_refptr<UsbDeviceHandle> device_handle =
       GetDeviceHandle(parameters->handle);
   if (!device_handle.get()) {
     return RespondNow(Error(kErrorNoConnection));
   }
 
   if (device_handle->ReleaseInterface(parameters->interface_number)) {
     return RespondNow(NoArguments());
   } else {
     return RespondNow(Error(kErrorCannotReleaseInterface));
   }
 }
 
 UsbSetInterfaceAlternateSettingFunction::
     UsbSetInterfaceAlternateSettingFunction() {
 }
 
 UsbSetInterfaceAlternateSettingFunction::
     ~UsbSetInterfaceAlternateSettingFunction() {
 }
 
 ExtensionFunction::ResponseAction
 UsbSetInterfaceAlternateSettingFunction::Run() {
-  scoped_ptr<extensions::core_api::usb::SetInterfaceAlternateSetting::Params>
+  scoped_ptr<extensions::api::usb::SetInterfaceAlternateSetting::Params>
       parameters = SetInterfaceAlternateSetting::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters.get());
 
   scoped_refptr<UsbDeviceHandle> device_handle =
       GetDeviceHandle(parameters->handle);
   if (!device_handle.get()) {
     return RespondNow(Error(kErrorNoConnection));
   }
 
   device_handle->SetInterfaceAlternateSetting(
@@ skipping 10 matching lines @@
   }
 }
 
 UsbControlTransferFunction::UsbControlTransferFunction() {
 }
 
 UsbControlTransferFunction::~UsbControlTransferFunction() {
 }
 
 ExtensionFunction::ResponseAction UsbControlTransferFunction::Run() {
-  scoped_ptr<extensions::core_api::usb::ControlTransfer::Params> parameters =
+  scoped_ptr<extensions::api::usb::ControlTransfer::Params> parameters =
       ControlTransfer::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters.get());
 
   scoped_refptr<UsbDeviceHandle> device_handle =
       GetDeviceHandle(parameters->handle);
   if (!device_handle.get()) {
     return RespondNow(Error(kErrorNoConnection));
   }
 
   const ControlTransferInfo& transfer = parameters->transfer_info;
@@ skipping 36 matching lines @@
   return RespondLater();
 }
 
 UsbBulkTransferFunction::UsbBulkTransferFunction() {
 }
 
 UsbBulkTransferFunction::~UsbBulkTransferFunction() {
 }
 
 ExtensionFunction::ResponseAction UsbBulkTransferFunction::Run() {
-  scoped_ptr<extensions::core_api::usb::BulkTransfer::Params> parameters =
+  scoped_ptr<extensions::api::usb::BulkTransfer::Params> parameters =
       BulkTransfer::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters.get());
 
   scoped_refptr<UsbDeviceHandle> device_handle =
       GetDeviceHandle(parameters->handle);
   if (!device_handle.get()) {
     return RespondNow(Error(kErrorNoConnection));
   }
 
   const GenericTransferInfo& transfer = parameters->transfer_info;
@@ skipping 25 matching lines @@
   return RespondLater();
 }
 
 UsbInterruptTransferFunction::UsbInterruptTransferFunction() {
 }
 
 UsbInterruptTransferFunction::~UsbInterruptTransferFunction() {
 }
 
 ExtensionFunction::ResponseAction UsbInterruptTransferFunction::Run() {
-  scoped_ptr<extensions::core_api::usb::InterruptTransfer::Params> parameters =
+  scoped_ptr<extensions::api::usb::InterruptTransfer::Params> parameters =
       InterruptTransfer::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters.get());
 
   scoped_refptr<UsbDeviceHandle> device_handle =
       GetDeviceHandle(parameters->handle);
   if (!device_handle.get()) {
     return RespondNow(Error(kErrorNoConnection));
   }
 
   const GenericTransferInfo& transfer = parameters->transfer_info;
@@ skipping 25 matching lines @@
   return RespondLater();
 }
 
 UsbIsochronousTransferFunction::UsbIsochronousTransferFunction() {
 }
 
 UsbIsochronousTransferFunction::~UsbIsochronousTransferFunction() {
 }
 
 ExtensionFunction::ResponseAction UsbIsochronousTransferFunction::Run() {
-  scoped_ptr<extensions::core_api::usb::IsochronousTransfer::Params>
-      parameters = IsochronousTransfer::Params::Create(*args_);
+  scoped_ptr<extensions::api::usb::IsochronousTransfer::Params> parameters =
+      IsochronousTransfer::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters.get());
 
   scoped_refptr<UsbDeviceHandle> device_handle =
       GetDeviceHandle(parameters->handle);
   if (!device_handle.get()) {
     return RespondNow(Error(kErrorNoConnection));
   }
 
   const IsochronousTransferInfo& transfer = parameters->transfer_info;
   const GenericTransferInfo& generic_transfer = transfer.transfer_info;
@@ skipping 75 matching lines @@
     ReleaseDeviceHandle(parameters_->handle);
 
     scoped_ptr<base::ListValue> error_args(new base::ListValue());
     error_args->AppendBoolean(false);
     // Returning arguments with an error is wrong but we're stuck with it.
     Respond(ErrorWithArguments(error_args.Pass(), kErrorResetDevice));
   }
 }
 
 }  // namespace extensions