Moved ExternalExtensionLoaders/Providers into extensions namespace

chrome/browser/extensions/extension_service.cc

 // Copyright (c) 2012 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 "chrome/browser/extensions/extension_service.h"
 
 #include <algorithm>
 #include <set>
 
 #include "base/basictypes.h"
@@ skipping 39 matching lines @@
 #include "chrome/browser/extensions/extension_input_ime_api.h"
 #include "chrome/browser/extensions/extension_management_api.h"
 #include "chrome/browser/extensions/extension_preference_api.h"
 #include "chrome/browser/extensions/extension_process_manager.h"
 #include "chrome/browser/extensions/extension_processes_api.h"
 #include "chrome/browser/extensions/extension_sorting.h"
 #include "chrome/browser/extensions/extension_special_storage_policy.h"
 #include "chrome/browser/extensions/extension_sync_data.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/extension_web_ui.h"
-#include "chrome/browser/extensions/external_extension_provider_impl.h"
-#include "chrome/browser/extensions/external_extension_provider_interface.h"
+#include "chrome/browser/extensions/external_provider_impl.h"
+#include "chrome/browser/extensions/external_provider_interface.h"
 #include "chrome/browser/extensions/installed_loader.h"
 #include "chrome/browser/extensions/pending_extension_manager.h"
 #include "chrome/browser/extensions/permissions_updater.h"
 #include "chrome/browser/extensions/settings/settings_frontend.h"
 #include "chrome/browser/extensions/unpacked_installer.h"
 #include "chrome/browser/extensions/updater/extension_updater.h"
 #include "chrome/browser/history/history_extension_api.h"
 #include "chrome/browser/net/chrome_url_request_context.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
@@ skipping 120 matching lines @@
 const char* ExtensionService::kSyncAppSettingsDirectoryName =
     "Sync App Settings";
 const char* ExtensionService::kSyncExtensionSettingsDirectoryName =
     "Sync Extension Settings";
 const char* ExtensionService::kStateStoreName = "Extension State";
 
 void ExtensionService::CheckExternalUninstall(const std::string& id) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Check if the providers know about this extension.
-  ProviderCollection::const_iterator i;
+  extensions::ProviderCollection::const_iterator i;
   for (i = external_extension_providers_.begin();
        i != external_extension_providers_.end(); ++i) {
     DCHECK(i->get()->IsReady());
     if (i->get()->HasExtension(id))
       return;  // Yup, known extension, don't uninstall.
   }
 
   // We get the list of external extensions to check from preferences.
   // It is possible that an extension has preferences but is not loaded.
   // For example, an extension that requires experimental permissions
   // will not be loaded if the experimental command line flag is not used.
   // In this case, do not uninstall.
   const Extension* extension = GetInstalledExtension(id);
   if (!extension) {
     // We can't call UninstallExtension with an unloaded/invalid
     // extension ID.
     LOG(WARNING) << "Attempted uninstallation of unloaded/invalid extension "
                  << "with id: " << id;
     return;
   }
   UninstallExtension(id, true, NULL);
 }
 
 void ExtensionService::ClearProvidersForTesting() {
   external_extension_providers_.clear();
 }
 
 void ExtensionService::AddProviderForTesting(
-    ExternalExtensionProviderInterface* test_provider) {
+    extensions::ExternalProviderInterface* test_provider) {
   CHECK(test_provider);
   external_extension_providers_.push_back(
-      linked_ptr<ExternalExtensionProviderInterface>(test_provider));
+      linked_ptr<extensions::ExternalProviderInterface>(test_provider));
 }
 
 bool ExtensionService::OnExternalExtensionUpdateUrlFound(
     const std::string& id,
     const GURL& update_url,
     Extension::Location location) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   CHECK(Extension::IdIsValid(id));
 
   const Extension* extension = GetExtensionById(id, true);
@@ skipping 138 matching lines @@
   component_loader_.reset(
       new extensions::ComponentLoader(this,
                                       profile->GetPrefs(),
                                       g_browser_process->local_state()));
 
   app_notification_manager_->Init();
 
   if (extensions_enabled_) {
     if (!command_line->HasSwitch(switches::kImport) &&
         !command_line->HasSwitch(switches::kImportFromFile)) {
-      ExternalExtensionProviderImpl::CreateExternalProviders(
+      extensions::ExternalProviderImpl::CreateExternalProviders(
           this, profile_, &external_extension_providers_);
     }
   }
 
   // Use monochrome icons for Omnibox icons.
   omnibox_popup_icon_manager_.set_monochrome(true);
   omnibox_icon_manager_.set_monochrome(true);
   omnibox_icon_manager_.set_padding(gfx::Insets(0, kOmniboxIconPaddingLeft,
                                                 0, kOmniboxIconPaddingRight));
 
@@ skipping 27 matching lines @@
 }
 
 PendingExtensionManager* ExtensionService::pending_extension_manager() {
   return &pending_extension_manager_;
 }
 
 ExtensionService::~ExtensionService() {
   // No need to unload extensions here because they are profile-scoped, and the
   // profile is in the process of being deleted.
 
-  ProviderCollection::const_iterator i;
+  extensions::ProviderCollection::const_iterator i;
   for (i = external_extension_providers_.begin();
        i != external_extension_providers_.end(); ++i) {
-    ExternalExtensionProviderInterface* provider = i->get();
+    extensions::ExternalProviderInterface* provider = i->get();
     provider->ServiceShutdown();
   }
 }
 
 void ExtensionService::InitEventRoutersAfterImport() {
   RegisterForImportFinished();
 }
 
 void ExtensionService::RegisterForImportFinished() {
   if (!registrar_.IsRegistered(this, chrome::NOTIFICATION_IMPORT_FINISHED,
@@ skipping 1178 matching lines @@
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Note that this installation is intentionally silent (since it didn't
   // go through the front-end).  Extensions that are registered in this
   // way are effectively considered 'pre-bundled', and so implicitly
   // trusted.  In general, if something has HKLM or filesystem access,
   // they could install an extension manually themselves anyway.
 
   // Ask each external extension provider to give us a call back for each
   // extension they know about. See OnExternalExtension(File|UpdateUrl)Found.
-  ProviderCollection::const_iterator i;
+  extensions::ProviderCollection::const_iterator i;
   for (i = external_extension_providers_.begin();
        i != external_extension_providers_.end(); ++i) {
-    ExternalExtensionProviderInterface* provider = i->get();
+    extensions::ExternalProviderInterface* provider = i->get();
     provider->VisitRegisteredExtension();
   }
 
   // Do any required work that we would have done after completion of all
   // providers.
   if (external_extension_providers_.empty()) {
     OnAllExternalProvidersReady();
   }
 }
 
 void ExtensionService::OnExternalProviderReady(
-    const ExternalExtensionProviderInterface* provider) {
+    const extensions::ExternalProviderInterface* provider) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   CHECK(provider->IsReady());
 
   // An external provider has finished loading.  We only take action
   // if all of them are finished. So we check them first.
   if (AreAllExternalProvidersReady())
     OnAllExternalProvidersReady();
 }
 
 bool ExtensionService::AreAllExternalProvidersReady() const {
-  ProviderCollection::const_iterator i;
+  extensions::ProviderCollection::const_iterator i;
   for (i = external_extension_providers_.begin();
        i != external_extension_providers_.end(); ++i) {
     if (!i->get()->IsReady())
       return false;
   }
   return true;
 }
 
 void ExtensionService::OnAllExternalProvidersReady() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 883 matching lines @@
 
   // To coexist with certain unit tests that don't have a work-thread message
   // loop available at ExtensionService shutdown, we lazy-initialize this
   // object so that those cases neither create nor destroy an
   // APIResourceController.
   if (!api_resource_controller_.get()) {
     api_resource_controller_.reset(new extensions::APIResourceController());
   }
   return api_resource_controller_.get();
 }