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

extensions/browser/api/printer_provider/printer_provider_api.cc

 // Copyright 2015 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/printer_provider/printer_provider_api.h"
 
 #include <map>
 #include <set>
 #include <utility>
 #include <vector>
@@ skipping 248 matching lines @@
 
   // PrinterProviderInternalAPIObserver implementation:
   void OnGetPrintersResult(
       const Extension* extension,
       int request_id,
       const PrinterProviderInternalAPIObserver::PrinterInfoVector& result)
       override;
   void OnGetCapabilityResult(const Extension* extension,
                              int request_id,
                              const base::DictionaryValue& result) override;
-  void OnPrintResult(
-      const Extension* extension,
-      int request_id,
-      core_api::printer_provider_internal::PrintError error) override;
+  void OnPrintResult(const Extension* extension,
+                     int request_id,
+                     api::printer_provider_internal::PrintError error) override;
   void OnGetUsbPrinterInfoResult(
       const Extension* extension,
       int request_id,
-      const core_api::printer_provider::PrinterInfo* printer_info) override;
+      const api::printer_provider::PrinterInfo* printer_info) override;
 
   // ExtensionRegistryObserver implementation:
   void OnExtensionUnloaded(content::BrowserContext* browser_context,
                            const Extension* extension,
                            UnloadedExtensionInfo::Reason reason) override;
 
   // Called before chrome.printerProvider.onGetPrintersRequested event is
   // dispatched to an extension. It returns whether the extension is interested
   // in the event. If the extension listens to the event, it's added to the set
   // of |request| sources. |request| is |GetPrintersRequest| object associated
@@ skipping 217 matching lines @@
   extension_registry_observer_.Add(ExtensionRegistry::Get(browser_context));
 }
 
 PrinterProviderAPIImpl::~PrinterProviderAPIImpl() {
 }
 
 void PrinterProviderAPIImpl::DispatchGetPrintersRequested(
     const GetPrintersCallback& callback) {
   EventRouter* event_router = EventRouter::Get(browser_context_);
   if (!event_router->HasEventListener(
-          core_api::printer_provider::OnGetPrintersRequested::kEventName)) {
+          api::printer_provider::OnGetPrintersRequested::kEventName)) {
     callback.Run(base::ListValue(), true /* done */);
     return;
   }
 
   // |pending_get_printers_requests_| take ownership of |request| which gets
   // NULLed out. Save the pointer before passing it to the requests, as it will
   // be needed later on.
   int request_id = pending_get_printers_requests_.Add(callback);
 
   scoped_ptr<base::ListValue> internal_args(new base::ListValue);
   // Request id is not part of the public API, but it will be massaged out in
   // custom bindings.
   internal_args->AppendInteger(request_id);
 
   scoped_ptr<Event> event(
       new Event(events::UNKNOWN,
-                core_api::printer_provider::OnGetPrintersRequested::kEventName,
+                api::printer_provider::OnGetPrintersRequested::kEventName,
                 internal_args.Pass()));
   // This callback is called synchronously during |BroadcastEvent|, so
   // Unretained is safe.
   event->will_dispatch_callback =
       base::Bind(&PrinterProviderAPIImpl::WillRequestPrinters,
                  base::Unretained(this), request_id);
 
   event_router->BroadcastEvent(event.Pass());
 }
 
 void PrinterProviderAPIImpl::DispatchGetCapabilityRequested(
     const std::string& printer_id,
     const PrinterProviderAPI::GetCapabilityCallback& callback) {
   std::string extension_id;
   std::string internal_printer_id;
   if (!ParsePrinterId(printer_id, &extension_id, &internal_printer_id)) {
     callback.Run(base::DictionaryValue());
     return;
   }
 
   EventRouter* event_router = EventRouter::Get(browser_context_);
   if (!event_router->ExtensionHasEventListener(
           extension_id,
-          core_api::printer_provider::OnGetCapabilityRequested::kEventName)) {
+          api::printer_provider::OnGetCapabilityRequested::kEventName)) {
     callback.Run(base::DictionaryValue());
     return;
   }
 
   int request_id = pending_capability_requests_[extension_id].Add(callback);
 
   scoped_ptr<base::ListValue> internal_args(new base::ListValue);
   // Request id is not part of the public API, but it will be massaged out in
   // custom bindings.
   internal_args->AppendInteger(request_id);
   internal_args->AppendString(internal_printer_id);
 
-  scoped_ptr<Event> event(new Event(
-      events::UNKNOWN,
-      core_api::printer_provider::OnGetCapabilityRequested::kEventName,
-      internal_args.Pass()));
+  scoped_ptr<Event> event(
+      new Event(events::UNKNOWN,
+                api::printer_provider::OnGetCapabilityRequested::kEventName,
+                internal_args.Pass()));
 
   event_router->DispatchEventToExtension(extension_id, event.Pass());
 }
 
 void PrinterProviderAPIImpl::DispatchPrintRequested(
     const PrinterProviderPrintJob& job,
     const PrinterProviderAPI::PrintCallback& callback) {
   std::string extension_id;
   std::string internal_printer_id;
   if (!ParsePrinterId(job.printer_id, &extension_id, &internal_printer_id)) {
     callback.Run(false, PrinterProviderAPI::GetDefaultPrintError());
     return;
   }
 
   EventRouter* event_router = EventRouter::Get(browser_context_);
   if (!event_router->ExtensionHasEventListener(
-          extension_id,
-          core_api::printer_provider::OnPrintRequested::kEventName)) {
+          extension_id, api::printer_provider::OnPrintRequested::kEventName)) {
     callback.Run(false, PrinterProviderAPI::GetDefaultPrintError());
     return;
   }
 
-  core_api::printer_provider::PrintJob print_job;
+  api::printer_provider::PrintJob print_job;
   print_job.printer_id = internal_printer_id;
 
   JSONStringValueDeserializer deserializer(job.ticket_json);
   scoped_ptr<base::Value> ticket_value(deserializer.Deserialize(NULL, NULL));
   if (!ticket_value ||
-      !core_api::printer_provider::PrintJob::Ticket::Populate(
-          *ticket_value, &print_job.ticket)) {
-    callback.Run(false,
-                 core_api::printer_provider::ToString(
-                     core_api::printer_provider::PRINT_ERROR_INVALID_TICKET));
+      !api::printer_provider::PrintJob::Ticket::Populate(*ticket_value,
+                                                         &print_job.ticket)) {
+    callback.Run(false, api::printer_provider::ToString(
+                            api::printer_provider::PRINT_ERROR_INVALID_TICKET));
     return;
   }
 
   print_job.content_type = job.content_type;
   print_job.title = base::UTF16ToUTF8(job.job_title);
   int request_id = pending_print_requests_[extension_id].Add(job, callback);
 
   scoped_ptr<base::ListValue> internal_args(new base::ListValue);
   // Request id is not part of the public API and it will be massaged out in
   // custom bindings.
   internal_args->AppendInteger(request_id);
   internal_args->Append(print_job.ToValue().release());
   scoped_ptr<Event> event(new Event(
-      events::UNKNOWN, core_api::printer_provider::OnPrintRequested::kEventName,
+      events::UNKNOWN, api::printer_provider::OnPrintRequested::kEventName,
       internal_args.Pass()));
   event_router->DispatchEventToExtension(extension_id, event.Pass());
 }
 
 const PrinterProviderPrintJob* PrinterProviderAPIImpl::GetPrintJob(
     const Extension* extension,
     int request_id) const {
   auto it = pending_print_requests_.find(extension->id());
   if (it == pending_print_requests_.end())
     return nullptr;
   return it->second.GetPrintJob(request_id);
 }
 
 void PrinterProviderAPIImpl::DispatchGetUsbPrinterInfoRequested(
     const std::string& extension_id,
     scoped_refptr<UsbDevice> device,
     const PrinterProviderAPI::GetPrinterInfoCallback& callback) {
   EventRouter* event_router = EventRouter::Get(browser_context_);
   if (!event_router->ExtensionHasEventListener(
-          extension_id, core_api::printer_provider::
-                            OnGetUsbPrinterInfoRequested::kEventName)) {
+          extension_id,
+          api::printer_provider::OnGetUsbPrinterInfoRequested::kEventName)) {
     callback.Run(base::DictionaryValue());
     return;
   }
 
   int request_id =
       pending_usb_printer_info_requests_[extension_id].Add(callback);
-  core_api::usb::Device usb_device;
+  api::usb::Device usb_device;
   usb_device.device =
       UsbGuidMap::Get(browser_context_)->GetIdFromGuid(device->guid());
   usb_device.vendor_id = device->vendor_id();
   usb_device.product_id = device->product_id();
 
   scoped_ptr<base::ListValue> internal_args(new base::ListValue);
   // Request id is not part of the public API and it will be massaged out in
   // custom bindings.
   internal_args->AppendInteger(request_id);
   internal_args->Append(usb_device.ToValue().release());
-  scoped_ptr<Event> event(new Event(
-      events::UNKNOWN,
-      core_api::printer_provider::OnGetUsbPrinterInfoRequested::kEventName,
-      internal_args.Pass()));
+  scoped_ptr<Event> event(
+      new Event(events::UNKNOWN,
+                api::printer_provider::OnGetUsbPrinterInfoRequested::kEventName,
+                internal_args.Pass()));
   event_router->DispatchEventToExtension(extension_id, event.Pass());
 }
 
 void PrinterProviderAPIImpl::OnGetPrintersResult(
     const Extension* extension,
     int request_id,
     const PrinterProviderInternalAPIObserver::PrinterInfoVector& result) {
   base::ListValue printer_list;
 
   // Update some printer description properties to better identify the extension
@@ skipping 11 matching lines @@
 void PrinterProviderAPIImpl::OnGetCapabilityResult(
     const Extension* extension,
     int request_id,
     const base::DictionaryValue& result) {
   pending_capability_requests_[extension->id()].Complete(request_id, result);
 }
 
 void PrinterProviderAPIImpl::OnPrintResult(
     const Extension* extension,
     int request_id,
-    core_api::printer_provider_internal::PrintError error) {
+    api::printer_provider_internal::PrintError error) {
   const std::string error_str =
-      error == core_api::printer_provider_internal::PRINT_ERROR_NONE
+      error == api::printer_provider_internal::PRINT_ERROR_NONE
           ? PrinterProviderAPI::GetDefaultPrintError()
-          : core_api::printer_provider_internal::ToString(error);
+          : api::printer_provider_internal::ToString(error);
   pending_print_requests_[extension->id()].Complete(
-      request_id, error == core_api::printer_provider_internal::PRINT_ERROR_OK,
+      request_id, error == api::printer_provider_internal::PRINT_ERROR_OK,
       error_str);
 }
 
 void PrinterProviderAPIImpl::OnGetUsbPrinterInfoResult(
     const Extension* extension,
     int request_id,
-    const core_api::printer_provider::PrinterInfo* result) {
+    const api::printer_provider::PrinterInfo* result) {
   if (result) {
     scoped_ptr<base::DictionaryValue> printer(result->ToValue());
     UpdatePrinterWithExtensionInfo(printer.get(), extension);
     pending_usb_printer_info_requests_[extension->id()].Complete(request_id,
                                                                  *printer);
   } else {
     pending_usb_printer_info_requests_[extension->id()].Complete(
         request_id, base::DictionaryValue());
   }
 }
@@ skipping 26 matching lines @@
 bool PrinterProviderAPIImpl::WillRequestPrinters(
     int request_id,
     content::BrowserContext* browser_context,
     const Extension* extension,
     base::ListValue* args) {
   if (!extension)
     return false;
   EventRouter* event_router = EventRouter::Get(browser_context_);
   if (!event_router->ExtensionHasEventListener(
           extension->id(),
-          core_api::printer_provider::OnGetPrintersRequested::kEventName)) {
+          api::printer_provider::OnGetPrintersRequested::kEventName)) {
     return false;
   }
 
   return pending_get_printers_requests_.AddSource(request_id, extension->id());
 }
 
 }  // namespace
 
 // static
 PrinterProviderAPI* PrinterProviderAPI::Create(
     content::BrowserContext* context) {
   return new PrinterProviderAPIImpl(context);
 }
 
 // static
 std::string PrinterProviderAPI::GetDefaultPrintError() {
-  return core_api::printer_provider_internal::ToString(
-      core_api::printer_provider_internal::PRINT_ERROR_FAILED);
+  return api::printer_provider_internal::ToString(
+      api::printer_provider_internal::PRINT_ERROR_FAILED);
 }
 
 }  // namespace extensions