Moved ExternalExtensionLoaders/Providers into extensions namespace

chrome/browser/policy/app_pack_updater.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/policy/app_pack_updater.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
 #include "base/location.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "base/values.h"
 #include "base/version.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/cros_settings.h"
 #include "chrome/browser/chromeos/cros_settings_names.h"
 #include "chrome/browser/extensions/crx_installer.h"
-#include "chrome/browser/extensions/external_extension_loader.h"
-#include "chrome/browser/extensions/external_extension_provider_impl.h"
+#include "chrome/browser/extensions/external_loader.h"
+#include "chrome/browser/extensions/external_provider_impl.h"
 #include "chrome/browser/extensions/updater/extension_downloader.h"
 #include "chrome/browser/policy/browser_policy_connector.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 
 using content::BrowserThread;
 using file_util::FileEnumerator;
 
 namespace policy {
 
 namespace {
 
 // Directory where the AppPack extensions are cached.
 const char kAppPackCacheDir[] = "/var/cache/app_pack";
 
 // File name extension for CRX files (not case sensitive).
 const char kCRXFileExtension[] = ".crx";
 
 }  // namespace
 
 const char AppPackUpdater::kExtensionId[] = "extension-id";
 const char AppPackUpdater::kUpdateUrl[]   = "update-url";
 
-// A custom ExternalExtensionLoader that the AppPackUpdater creates and uses to
-// publish AppPack updates to the extensions system.
-class AppPackExternalExtensionLoader
-    : public ExternalExtensionLoader,
-      public base::SupportsWeakPtr<AppPackExternalExtensionLoader> {
+// A custom extensions::ExternalLoader that the AppPackUpdater creates and uses
+// to publish AppPack updates to the extensions system.
+class AppPackExternalLoader
+    : public extensions::ExternalLoader,
+      public base::SupportsWeakPtr<AppPackExternalLoader> {
  public:
-  AppPackExternalExtensionLoader() {}
+  AppPackExternalLoader() {}
 
   // Used by the AppPackUpdater to update the current list of extensions.
-  // The format of |prefs| is detailed in the ExternalExtensionLoader/Provider
-  // headers.
+  // The format of |prefs| is detailed in the extensions::ExternalLoader/
+  // Provider headers.
   void SetCurrentAppPackExtensions(scoped_ptr<base::DictionaryValue> prefs) {
     app_pack_prefs_.Swap(prefs.get());
     StartLoading();
   }
 
-  // Implementation of ExternalExtensionLoader:
+  // Implementation of extensions::ExternalLoader:
   virtual void StartLoading() OVERRIDE {
     prefs_.reset(app_pack_prefs_.DeepCopy());
     VLOG(1) << "AppPack extension loader publishing "
             << app_pack_prefs_.size() << " crx files.";
     LoadFinished();
   }
 
  protected:
-  virtual ~AppPackExternalExtensionLoader() {}
+  virtual ~AppPackExternalLoader() {}
 
  private:
   base::DictionaryValue app_pack_prefs_;
 
-  DISALLOW_COPY_AND_ASSIGN(AppPackExternalExtensionLoader);
+  DISALLOW_COPY_AND_ASSIGN(AppPackExternalLoader);
 };
 
 AppPackUpdater::AppPackUpdater(net::URLRequestContextGetter* request_context,
                                BrowserPolicyConnector* connector)
     : ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)),
       created_extension_loader_(false),
       request_context_(request_context) {
   if (connector->GetDeviceMode() == DEVICE_MODE_KIOSK) {
     // Already in Kiosk mode, start loading.
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                             base::Bind(&AppPackUpdater::Init,
                                        weak_ptr_factory_.GetWeakPtr()));
   } else if ((connector->GetDeviceMode() == DEVICE_MODE_NOT_SET ||
               connector->GetDeviceMode() == DEVICE_MODE_PENDING) &&
              connector->device_cloud_policy_subsystem()) {
     // Not enrolled yet, listen for enrollment.
     policy_registrar_.reset(new CloudPolicySubsystem::ObserverRegistrar(
         connector->device_cloud_policy_subsystem(), this));
   } else {
     // Linger as a stub.
   }
 }
 
 AppPackUpdater::~AppPackUpdater() {
   chromeos::CrosSettings::Get()->RemoveSettingsObserver(
       chromeos::kAppPack, this);
   net::NetworkChangeNotifier::RemoveIPAddressObserver(this);
 }
 
-ExternalExtensionLoader* AppPackUpdater::CreateExternalExtensionLoader() {
+extensions::ExternalLoader* AppPackUpdater::CreateExternalLoader() {
   if (created_extension_loader_) {
     NOTREACHED();
     return NULL;
   }
   created_extension_loader_ = true;
-  AppPackExternalExtensionLoader* loader = new AppPackExternalExtensionLoader();
+  AppPackExternalLoader* loader = new AppPackExternalLoader();
   extension_loader_ = loader->AsWeakPtr();
 
   // The cache may have been already checked. In that case, load the current
   // extensions into the loader immediately.
   UpdateExtensionLoader();
 
   return loader;
 }
 
 void AppPackUpdater::SetScreenSaverUpdateCallback(
@@ skipping 249 matching lines @@
   DownloadMissingExtensions();
 }
 
 void AppPackUpdater::UpdateExtensionLoader() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!extension_loader_) {
     VLOG(1) << "No AppPack loader created yet, not pushing extensions.";
     return;
   }
 
-  // Build a DictionaryValue with the format that ExternalExtensionProviderImpl
-  // expects, containing info about the locally cached extensions.
+  // Build a DictionaryValue with the format that
+  // extensions::ExternalProviderImpl expects, containing info about the locally
+  // cached extensions.
 
   scoped_ptr<base::DictionaryValue> prefs(new base::DictionaryValue());
   for (CacheEntryMap::iterator it = cached_extensions_.begin();
        it != cached_extensions_.end(); ++it) {
     // The screensaver isn't installed into the Profile.
     if (it->first == screen_saver_id_)
       continue;
 
     base::DictionaryValue* dict = new base::DictionaryValue();
-    dict->SetString(ExternalExtensionProviderImpl::kExternalCrx,
+    dict->SetString(extensions::ExternalProviderImpl::kExternalCrx,
                     it->second.path);
-    dict->SetString(ExternalExtensionProviderImpl::kExternalVersion,
+    dict->SetString(extensions::ExternalProviderImpl::kExternalVersion,
                     it->second.cached_version);
     prefs->Set(it->first, dict);
 
     VLOG(1) << "Updating AppPack extension loader, added " << it->second.path;
   }
 
   extension_loader_->SetCurrentAppPackExtensions(prefs.Pass());
 }
 
 void AppPackUpdater::DownloadMissingExtensions() {
@@ skipping 177 matching lines @@
   }
 }
 
 void AppPackUpdater::SetUpdateChecked(const std::string& id) {
   PolicyEntryMap::iterator entry = app_pack_extensions_.find(id);
   if (entry != app_pack_extensions_.end())
     entry->second.update_checked = true;
 }
 
 }  // namespace policy