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

chrome/common/extensions/extension.cc

 // Copyright (c) 2013 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/common/extensions/extension.h"
 
-#include <ostream>
-
 #include "base/base64.h"
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/i18n/rtl.h"
 #include "base/logging.h"
 #include "base/memory/singleton.h"
 #include "base/stl_util.h"
 #include "base/string16.h"
@@ skipping 140 matching lines @@
   }
   ~ExtensionConfig() { }
 
   // A whitelist of extensions that can script anywhere. Do not add to this
   // list (except in tests) without consulting the Extensions team first.
   // Note: Component extensions have this right implicitly and do not need to be
   // added to this list.
   Extension::ScriptingWhitelist scripting_whitelist_;
 };
 
-// Rank extension locations in a way that allows
-// Extension::GetHigherPriorityLocation() to compare locations.
-// An extension installed from two locations will have the location
-// with the higher rank, as returned by this function. The actual
-// integer values may change, and should never be persisted.
-int GetLocationRank(Extension::Location location) {
-  const int kInvalidRank = -1;
-  int rank = kInvalidRank;  // Will CHECK that rank is not kInvalidRank.
-
-  switch (location) {
-    // Component extensions can not be overriden by any other type.
-    case Extension::COMPONENT:
-      rank = 6;
-      break;
-
-    // Policy controlled extensions may not be overridden by any type
-    // that is not part of chrome.
-    case Extension::EXTERNAL_POLICY_DOWNLOAD:
-      rank = 5;
-      break;
-
-    // A developer-loaded extension should override any installed type
-    // that a user can disable.
-    case Extension::LOAD:
-      rank = 4;
-      break;
-
-    // The relative priority of various external sources is not important,
-    // but having some order ensures deterministic behavior.
-    case Extension::EXTERNAL_REGISTRY:
-      rank = 3;
-      break;
-
-    case Extension::EXTERNAL_PREF:
-      rank = 2;
-      break;
-
-    case Extension::EXTERNAL_PREF_DOWNLOAD:
-      rank = 1;
-      break;
-
-    // User installed extensions are overridden by any external type.
-    case Extension::INTERNAL:
-      rank = 0;
-      break;
-
-    default:
-      NOTREACHED() << "Need to add new extension locaton " << location;
-  }
-
-  CHECK(rank != kInvalidRank);
-  return rank;
-}
-
 bool ReadLaunchDimension(const extensions::Manifest* manifest,
                          const char* key,
                          int* target,
                          bool is_valid_container,
                          string16* error) {
   Value* temp = NULL;
   if (manifest->Get(key, &temp)) {
     if (!is_valid_container) {
       *error = ErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidLaunchValueContainer,
@@ skipping 79 matching lines @@
 
 Extension::Requirements::~Requirements() {}
 
 Extension::OAuth2Info::OAuth2Info() {}
 Extension::OAuth2Info::~OAuth2Info() {}
 
 //
 // Extension
 //
 
-bool Extension::InstallWarning::operator==(const InstallWarning& other) const {
-  return format == other.format && message == other.message;
-}
-
 // static
 scoped_refptr<Extension> Extension::Create(const FilePath& path,
-                                           Location location,
+                                           Manifest::Location location,
                                            const DictionaryValue& value,
                                            int flags,
                                            std::string* utf8_error) {
   return Extension::Create(path,
                            location,
                            value,
                            flags,
                            std::string(),  // ID is ignored if empty.
                            utf8_error);
 }
 
 scoped_refptr<Extension> Extension::Create(const FilePath& path,
-                                           Location location,
+                                           Manifest::Location location,
                                            const DictionaryValue& value,
                                            int flags,
                                            const std::string& explicit_id,
                                            std::string* utf8_error) {
   DCHECK(utf8_error);
   string16 error;
   scoped_ptr<extensions::Manifest> manifest(
       new extensions::Manifest(location,
                                scoped_ptr<DictionaryValue>(value.DeepCopy())));
 
   if (!InitExtensionID(manifest.get(), path, explicit_id, flags, &error)) {
     *utf8_error = UTF16ToUTF8(error);
     return NULL;
   }
 
-  InstallWarningVector install_warnings;
+  std::vector<InstallWarning> install_warnings;
   manifest->ValidateManifest(utf8_error, &install_warnings);
   if (!utf8_error->empty())
     return NULL;
 
   scoped_refptr<Extension> extension = new Extension(path, manifest.Pass());
   extension->install_warnings_.swap(install_warnings);
 
   if (!extension->InitFromValue(flags, &error)) {
     *utf8_error = UTF16ToUTF8(error);
     return NULL;
   }
 
   if (!extension->CheckPlatformAppFeatures(utf8_error) ||
       !extension->CheckConflictingFeatures(utf8_error)) {
     return NULL;
   }
 
   return extension;
 }
 
 // static
-Extension::Location Extension::GetHigherPriorityLocation(
-    Extension::Location loc1, Extension::Location loc2) {
-  if (loc1 == loc2)
-    return loc1;
-
-  int loc1_rank = GetLocationRank(loc1);
-  int loc2_rank = GetLocationRank(loc2);
-
-  // If two different locations have the same rank, then we can not
-  // deterministicly choose a location.
-  CHECK(loc1_rank != loc2_rank);
-
-  // Highest rank has highest priority.
-  return (loc1_rank > loc2_rank ? loc1 : loc2 );
-}
-
-// static
 bool Extension::IdIsValid(const std::string& id) {
   // Verify that the id is legal.
   if (id.size() != (kIdSize * 2))
     return false;
 
   // We only support lowercase IDs, because IDs can be used as URL components
   // (where GURL will lowercase it).
   std::string temp = StringToLowerASCII(id);
   for (size_t i = 0; i < temp.size(); i++)
     if (temp[i] < 'a' || temp[i] > 'p')
@@ skipping 27 matching lines @@
   info->SetString(info_keys::kDescriptionKey, description());
   info->SetString(info_keys::kOptionsUrlKey,
                   ManifestURL::GetOptionsPage(this).possibly_invalid_spec());
   info->SetString(info_keys::kHomepageUrlKey,
                   ManifestURL::GetHomepageURL(this).possibly_invalid_spec());
   info->SetString(info_keys::kDetailsUrlKey,
                   ManifestURL::GetDetailsURL(this).possibly_invalid_spec());
   info->SetBoolean(info_keys::kPackagedAppKey, is_platform_app());
 }
 
-Extension::Type Extension::GetType() const {
-  return converted_from_user_script() ? TYPE_USER_SCRIPT : manifest_->type();
+Manifest::Type Extension::GetType() const {
+  return converted_from_user_script() ?
+      Manifest::TYPE_USER_SCRIPT : manifest_->type();
 }
 
 // static
 GURL Extension::GetResourceURL(const GURL& extension_url,
                                const std::string& relative_path) {
   DCHECK(extension_url.SchemeIs(extensions::kExtensionScheme));
   DCHECK_EQ("/", extension_url.path());
 
   std::string path = relative_path;
 
@@ skipping 355 matching lines @@
   return runtime_data_.GetActivePermissions()->
       CheckAPIPermissionWithParam(permission, param);
 }
 
 const URLPatternSet& Extension::GetEffectiveHostPermissions() const {
   base::AutoLock auto_lock(runtime_data_lock_);
   return runtime_data_.GetActivePermissions()->effective_hosts();
 }
 
 bool Extension::CanSilentlyIncreasePermissions() const {
-  return location() != INTERNAL;
+  return location() != Manifest::INTERNAL;
 }
 
 bool Extension::HasHostPermission(const GURL& url) const {
   if (url.SchemeIs(chrome::kChromeUIScheme) &&
       url.host() != chrome::kChromeUIFaviconHost &&
       url.host() != chrome::kChromeUIThumbnailHost &&
-      location() != Extension::COMPONENT) {
+      location() != Manifest::COMPONENT) {
     return false;
   }
 
   base::AutoLock auto_lock(runtime_data_lock_);
   return runtime_data_.GetActivePermissions()->
       HasExplicitAccessToOrigin(url);
 }
 
 bool Extension::HasEffectiveAccessToAllHosts() const {
   base::AutoLock auto_lock(runtime_data_lock_);
@@ skipping 37 matching lines @@
     Extension::GetActivePermissions() const {
   base::AutoLock auto_lock(runtime_data_lock_);
   return runtime_data_.GetActivePermissions();
 }
 
 bool Extension::ShowConfigureContextMenus() const {
   // Don't show context menu for component extensions. We might want to show
   // options for component extension button but now there is no component
   // extension with options. All other menu items like uninstall have
   // no sense for component extensions.
-  return location() != Extension::COMPONENT;
+  return location() != Manifest::COMPONENT;
 }
 
 std::set<FilePath> Extension::GetBrowserImages() const {
   std::set<FilePath> image_paths;
   // TODO(viettrungluu): These |FilePath::FromWStringHack(UTF8ToWide())|
   // indicate that we're doing something wrong.
 
   // Extension icons.
   for (ExtensionIconSet::IconMap::const_iterator iter = icons().map().begin();
        iter != icons().map().end(); ++iter) {
@@ skipping 134 matching lines @@
 
   if (error) {
     *error = ErrorUtils::FormatErrorMessage(errors::kCannotAccessPage,
                                                      document_url.spec());
   }
 
   return false;
 }
 
 bool Extension::CanExecuteScriptEverywhere() const {
-  if (location() == Extension::COMPONENT)
+  if (location() == Manifest::COMPONENT)
     return true;
 
   ScriptingWhitelist* whitelist = ExtensionConfig::GetInstance()->whitelist();
 
   for (ScriptingWhitelist::const_iterator it = whitelist->begin();
        it != whitelist->end(); ++it) {
     if (id() == *it) {
       return true;
     }
   }
@@ skipping 62 matching lines @@
 
   // Disallow extensions with native code plugins.
   //
   // TODO(akalin): Relax this restriction once we've put in UI to
   // approve synced extensions.
   if (!plugins().empty()) {
     return SYNC_TYPE_NONE;
   }
 
   switch (GetType()) {
-    case Extension::TYPE_EXTENSION:
+    case Manifest::TYPE_EXTENSION:
       return SYNC_TYPE_EXTENSION;
 
-    case Extension::TYPE_USER_SCRIPT:
+    case Manifest::TYPE_USER_SCRIPT:
       // We only want to sync user scripts with gallery update URLs.
       if (UpdatesFromGallery())
         return SYNC_TYPE_EXTENSION;
       else
         return SYNC_TYPE_NONE;
 
-    case Extension::TYPE_HOSTED_APP:
-    case Extension::TYPE_LEGACY_PACKAGED_APP:
-    case Extension::TYPE_PLATFORM_APP:
+    case Manifest::TYPE_HOSTED_APP:
+    case Manifest::TYPE_LEGACY_PACKAGED_APP:
+    case Manifest::TYPE_PLATFORM_APP:
         return SYNC_TYPE_APP;
 
     default:
       return SYNC_TYPE_NONE;
   }
 }
 
 bool Extension::IsSyncable() const {
   // TODO(akalin): Figure out if we need to allow some other types.
 
   // Default apps are not synced because otherwise they will pollute profiles
   // that don't already have them. Specially, if a user doesn't have default
   // apps, creates a new profile (which get default apps) and then enables sync
   // for it, then their profile everywhere gets the default apps.
-  bool is_syncable = (location() == Extension::INTERNAL &&
+  bool is_syncable = (location() == Manifest::INTERNAL &&
       !was_installed_by_default());
   // Sync the chrome web store to maintain its position on the new tab page.
   is_syncable |= (id() ==  extension_misc::kWebStoreAppId);
   return is_syncable;
 }
 
 bool Extension::RequiresSortOrdinal() const {
   return is_app() && (display_in_launcher_ || display_in_new_tab_page_);
 }
 
 bool Extension::ShouldDisplayInAppLauncher() const {
   // Only apps should be displayed in the launcher.
   return is_app() && display_in_launcher_;
 }
 
 bool Extension::ShouldDisplayInNewTabPage() const {
   // Only apps should be displayed on the NTP.
   return is_app() && display_in_new_tab_page_;
 }
 
 bool Extension::ShouldDisplayInExtensionSettings() const {
   // Don't show for themes since the settings UI isn't really useful for them.
   if (is_theme())
     return false;
 
   // Don't show component extensions because they are only extensions as an
   // implementation detail of Chrome.
-  if (location() == Extension::COMPONENT &&
+  if (location() == Manifest::COMPONENT &&
       !CommandLine::ForCurrentProcess()->HasSwitch(
         switches::kShowComponentExtensionOptions)) {
     return false;
   }
 
   // Always show unpacked extensions and apps.
-  if (location() == Extension::LOAD)
+  if (location() == Manifest::LOAD)
     return true;
 
   // Unless they are unpacked, never show hosted apps. Note: We intentionally
   // show packaged apps and platform apps because there are some pieces of
   // functionality that are only available in chrome://extensions/ but which
   // are needed for packaged and platform apps. For example, inspecting
   // background pages. See http://crbug.com/116134.
   if (is_hosted_app())
     return false;
 
@@ skipping 35 matching lines @@
     return iter->second.get();
   return NULL;
 }
 
 void Extension::SetManifestData(const std::string& key,
                                 Extension::ManifestData* data) {
   DCHECK(!finished_parsing_manifest_ && thread_checker_.CalledOnValidThread());
   manifest_data_[key] = linked_ptr<ManifestData>(data);
 }
 
-Extension::Location Extension::location() const {
+Manifest::Location Extension::location() const {
   return manifest_->location();
 }
 
 const std::string& Extension::id() const {
   return manifest_->extension_id();
 }
 
 const std::string Extension::VersionString() const {
   return version()->GetString();
 }
 
 void Extension::AddInstallWarning(const InstallWarning& new_warning) {
   install_warnings_.push_back(new_warning);
 }
 
 void Extension::AddInstallWarnings(
-    const InstallWarningVector& new_warnings) {
+    const std::vector<InstallWarning>& new_warnings) {
   install_warnings_.insert(install_warnings_.end(),
                            new_warnings.begin(), new_warnings.end());
 }
 
 bool Extension::is_platform_app() const {
   return manifest_->is_platform_app();
 }
 
 bool Extension::is_hosted_app() const {
   return manifest()->is_hosted_app();
@@ skipping 1696 matching lines @@
 
     URLPattern pattern(kValidWebExtentSchemes);
     URLPattern::ParseResult result = pattern.Parse(new_url.spec());
     DCHECK_EQ(result, URLPattern::PARSE_SUCCESS);
     pattern.SetPath(pattern.path() + '*');
     extent_.AddPattern(pattern);
   }
 }
 
 bool Extension::CanSpecifyExperimentalPermission() const {
-  if (location() == Extension::COMPONENT)
+  if (location() == Manifest::COMPONENT)
     return true;
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableExperimentalExtensionApis)) {
     return true;
   }
 
   // We rely on the webstore to check access to experimental. This way we can
   // whitelist extensions to have access to experimental in just the store, and
   // not have to push a new version of the client.
@@ skipping 86 matching lines @@
 bool Extension::CheckConflictingFeatures(std::string* utf8_error) const {
   if (has_lazy_background_page() &&
       HasAPIPermission(APIPermission::kWebRequest)) {
     *utf8_error = errors::kWebRequestConflictsWithLazyBackground;
     return false;
   }
 
   return true;
 }
 
-void PrintTo(const Extension::InstallWarning& warning, ::std::ostream* os) {
-  *os << "InstallWarning(";
-  switch (warning.format) {
-    case Extension::InstallWarning::FORMAT_TEXT:
-      *os << "FORMAT_TEXT, \"";
-      break;
-    case Extension::InstallWarning::FORMAT_HTML:
-      *os << "FORMAT_HTML, \"";
-      break;
-  }
-  // This is just for test error messages, so no need to escape '"'
-  // characters inside the message.
-  *os << warning.message << "\")";
-}
-
 ExtensionInfo::ExtensionInfo(const DictionaryValue* manifest,
                              const std::string& id,
                              const FilePath& path,
-                             Extension::Location location)
+                             Manifest::Location location)
     : extension_id(id),
       extension_path(path),
       extension_location(location) {
   if (manifest)
     extension_manifest.reset(manifest->DeepCopy());
 }
 
 ExtensionInfo::~ExtensionInfo() {}
 
 UnloadedExtensionInfo::UnloadedExtensionInfo(
     const Extension* extension,
     extension_misc::UnloadedExtensionReason reason)
   : reason(reason),
     already_disabled(false),
     extension(extension) {}
 
 UpdatedExtensionPermissionsInfo::UpdatedExtensionPermissionsInfo(
     const Extension* extension,
     const PermissionSet* permissions,
     Reason reason)
     : reason(reason),
       extension(extension),
       permissions(permissions) {}
 
 }   // namespace extensions