Move Extension Location and Type enums to Manifest, and move InstallWarning to its own file.

chrome/browser/extensions/external_provider_impl.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/external_provider_impl.h"
 
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/memory/linked_ptr.h"
 #include "base/metrics/field_trial.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
 #include "base/values.h"
 #include "base/version.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/external_policy_loader.h"
 #include "chrome/browser/extensions/external_pref_loader.h"
 #include "chrome/browser/extensions/external_provider_interface.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
+#include "chrome/common/extensions/extension.h"
+#include "chrome/common/extensions/manifest.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "ui/base/l10n/l10n_util.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/login/user_manager.h"
 #include "chrome/browser/policy/app_pack_updater.h"
 #include "chrome/browser/policy/browser_policy_connector.h"
 #endif
 
@@ skipping 13 matching lines @@
 const char ExternalProviderImpl::kExternalCrx[] = "external_crx";
 const char ExternalProviderImpl::kExternalVersion[] = "external_version";
 const char ExternalProviderImpl::kExternalUpdateUrl[] = "external_update_url";
 const char ExternalProviderImpl::kSupportedLocales[] = "supported_locales";
 const char ExternalProviderImpl::kIsBookmarkApp[] = "is_bookmark_app";
 const char ExternalProviderImpl::kIsFromWebstore[] = "is_from_webstore";
 
 ExternalProviderImpl::ExternalProviderImpl(
     VisitorInterface* service,
     ExternalLoader* loader,
-    Extension::Location crx_location,
-    Extension::Location download_location,
+    Manifest::Location crx_location,
+    Manifest::Location download_location,
     int creation_flags)
   : crx_location_(crx_location),
     download_location_(download_location),
     service_(service),
     prefs_(NULL),
     ready_(false),
     loader_(loader),
     creation_flags_(creation_flags),
     auto_acknowledge_(false) {
   loader_->Init(this);
@@ skipping 119 matching lines @@
         is_bookmark_app) {
       creation_flags |= Extension::FROM_BOOKMARK;
     }
     bool is_from_webstore;
     if (extension->GetBoolean(kIsFromWebstore, &is_from_webstore) &&
         is_from_webstore) {
       creation_flags |= Extension::FROM_WEBSTORE;
     }
 
     if (has_external_crx) {
-      if (crx_location_ == Extension::INVALID) {
+      if (crx_location_ == Manifest::INVALID_LOCATION) {
         LOG(WARNING) << "This provider does not support installing external "
                      << "extensions from crx files.";
         continue;
       }
       if (external_crx.find(FilePath::kParentDirectory) !=
           base::StringPiece::npos) {
         LOG(WARNING) << "Path traversal not allowed in path: "
                      << external_crx.c_str();
         continue;
       }
@@ skipping 16 matching lines @@
         LOG(WARNING) << "Malformed extension dictionary for extension: "
                      << extension_id.c_str() << ".  Invalid version string \""
                      << external_version << "\".";
         continue;
       }
       service_->OnExternalExtensionFileFound(extension_id, &version, path,
                                              crx_location_, creation_flags,
                                              auto_acknowledge_);
     } else { // if (has_external_update_url)
       CHECK(has_external_update_url);  // Checking of keys above ensures this.
-      if (download_location_ == Extension::INVALID) {
+      if (download_location_ == Manifest::INVALID_LOCATION) {
         LOG(WARNING) << "This provider does not support installing external "
                      << "extensions from update URLs.";
         continue;
       }
       GURL update_url(external_update_url);
       if (!update_url.is_valid()) {
         LOG(WARNING) << "Malformed extension dictionary for extension: "
                      << extension_id.c_str() << ".  Key " << kExternalUpdateUrl
                      << " has value \"" << external_update_url
                      << "\", which is not a valid URL.";
@@ skipping 24 matching lines @@
 
 bool ExternalProviderImpl::HasExtension(
     const std::string& id) const {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   CHECK(prefs_.get());
   CHECK(ready_);
   return prefs_->HasKey(id);
 }
 
 bool ExternalProviderImpl::GetExtensionDetails(
-    const std::string& id, Extension::Location* location,
+    const std::string& id, Manifest::Location* location,
     scoped_ptr<Version>* version) const {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   CHECK(prefs_.get());
   CHECK(ready_);
   DictionaryValue* extension = NULL;
   if (!prefs_->GetDictionary(id, &extension))
     return false;
 
-  Extension::Location loc = Extension::INVALID;
+  Manifest::Location loc = Manifest::INVALID_LOCATION;
   if (extension->HasKey(kExternalUpdateUrl)) {
     loc = download_location_;
 
   } else if (extension->HasKey(kExternalCrx)) {
     loc = crx_location_;
 
     std::string external_version;
     if (!extension->GetString(kExternalVersion, &external_version))
       return false;
 
@@ skipping 15 matching lines @@
 void ExternalProviderImpl::CreateExternalProviders(
     VisitorInterface* service,
     Profile* profile,
     ProviderCollection* provider_list) {
   // Policies are mandatory so they can't be skipped with command line flag.
   provider_list->push_back(
       linked_ptr<ExternalProviderInterface>(
           new ExternalProviderImpl(
               service,
               new ExternalPolicyLoader(profile),
-              Extension::INVALID,
-              Extension::EXTERNAL_POLICY_DOWNLOAD,
+              Manifest::INVALID_LOCATION,
+              Manifest::EXTERNAL_POLICY_DOWNLOAD,
               Extension::NO_FLAGS)));
 
   // In tests don't install extensions from default external sources.
   // It would only slowdown tests and make them flaky.
   if (CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kDisableDefaultApps))
     return;
 
   // On Mac OS, items in /Library/... should be written by the superuser.
   // Check that all components of the path are writable by root only.
@@ skipping 17 matching lines @@
       Extension::WAS_INSTALLED_BY_DEFAULT;
 #endif
 
   if (!is_chromeos_demo_session) {
     provider_list->push_back(
         linked_ptr<ExternalProviderInterface>(
             new ExternalProviderImpl(
                 service,
                 new ExternalPrefLoader(chrome::DIR_EXTERNAL_EXTENSIONS,
                                        check_admin_permissions_on_mac),
-                Extension::EXTERNAL_PREF,
-                Extension::EXTERNAL_PREF_DOWNLOAD,
+                Manifest::EXTERNAL_PREF,
+                Manifest::EXTERNAL_PREF_DOWNLOAD,
                 bundled_extension_creation_flags)));
   }
 
 #if defined(OS_CHROMEOS) || defined (OS_MACOSX)
   // Define a per-user source of external extensions.
   // On Chrome OS, this serves as a source for OEM customization.
   provider_list->push_back(
       linked_ptr<ExternalProviderInterface>(
           new ExternalProviderImpl(
               service,
               new ExternalPrefLoader(chrome::DIR_USER_EXTERNAL_EXTENSIONS,
                                      ExternalPrefLoader::NONE),
-              Extension::EXTERNAL_PREF,
-              Extension::EXTERNAL_PREF_DOWNLOAD,
+              Manifest::EXTERNAL_PREF,
+              Manifest::EXTERNAL_PREF_DOWNLOAD,
               Extension::NO_FLAGS)));
 #endif
 #if defined(OS_WIN)
   provider_list->push_back(
       linked_ptr<ExternalProviderInterface>(
           new ExternalProviderImpl(
               service,
               new ExternalRegistryLoader,
-              Extension::EXTERNAL_REGISTRY,
-              Extension::INVALID,
+              Manifest::EXTERNAL_REGISTRY,
+              Manifest::INVALID_LOCATION,
               Extension::NO_FLAGS)));
 #endif
 
 #if defined(OS_LINUX)
   provider_list->push_back(
       linked_ptr<ExternalProviderInterface>(
           new ExternalProviderImpl(
               service,
               new ExternalPrefLoader(chrome::DIR_STANDALONE_EXTERNAL_EXTENSIONS,
                                      ExternalPrefLoader::NONE),
-              Extension::EXTERNAL_PREF,
-              Extension::EXTERNAL_PREF_DOWNLOAD,
+              Manifest::EXTERNAL_PREF,
+              Manifest::EXTERNAL_PREF_DOWNLOAD,
               bundled_extension_creation_flags)));
 #endif
 
 #if !defined(OS_CHROMEOS)
   // The default apps are installed as INTERNAL but use the external
   // extension installer codeflow.
   provider_list->push_back(
       linked_ptr<ExternalProviderInterface>(
           new default_apps::Provider(
               profile,
               service,
               new ExternalPrefLoader(chrome::DIR_DEFAULT_APPS,
                                      ExternalPrefLoader::NONE),
-              Extension::INTERNAL,
-              Extension::INVALID,
+              Manifest::INTERNAL,
+              Manifest::INVALID_LOCATION,
               Extension::FROM_WEBSTORE |
                   Extension::WAS_INSTALLED_BY_DEFAULT)));
 #endif
 
 #if defined(OS_CHROMEOS)
   policy::BrowserPolicyConnector* connector =
       g_browser_process->browser_policy_connector();
   if (is_chromeos_demo_session && connector->GetAppPackUpdater()) {
     provider_list->push_back(
         linked_ptr<ExternalProviderInterface>(
           new ExternalProviderImpl(
               service,
               connector->GetAppPackUpdater()->CreateExternalLoader(),
-              Extension::EXTERNAL_PREF,
-              Extension::INVALID,
+              Manifest::EXTERNAL_PREF,
+              Manifest::INVALID_LOCATION,
               Extension::NO_FLAGS)));
   }
 #endif
 }
 
 }  // namespace extensions