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

chrome/common/extensions/features/simple_feature.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/common/extensions/features/simple_feature.h"
 
 #include <map>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "chrome/common/chrome_switches.h"
 
 using chrome::VersionInfo;
-using extensions::Extension;
+
+namespace extensions {
 
 namespace {
 
 struct Mappings {
   Mappings() {
-    extension_types["extension"] = Extension::TYPE_EXTENSION;
-    extension_types["theme"] = Extension::TYPE_THEME;
-    extension_types["packaged_app"]
-        = Extension::TYPE_LEGACY_PACKAGED_APP;
-    extension_types["hosted_app"] = Extension::TYPE_HOSTED_APP;
-    extension_types["platform_app"] = Extension::TYPE_PLATFORM_APP;
+    extension_types["extension"] = Manifest::TYPE_EXTENSION;
+    extension_types["theme"] = Manifest::TYPE_THEME;
+    extension_types["packaged_app"] = Manifest::TYPE_LEGACY_PACKAGED_APP;
+    extension_types["hosted_app"] = Manifest::TYPE_HOSTED_APP;
+    extension_types["platform_app"] = Manifest::TYPE_PLATFORM_APP;
 
-    contexts["blessed_extension"] =
-        extensions::Feature::BLESSED_EXTENSION_CONTEXT;
-    contexts["unblessed_extension"] =
-        extensions::Feature::UNBLESSED_EXTENSION_CONTEXT;
-    contexts["content_script"] = extensions::Feature::CONTENT_SCRIPT_CONTEXT;
-    contexts["web_page"] = extensions::Feature::WEB_PAGE_CONTEXT;
+    contexts["blessed_extension"] = Feature::BLESSED_EXTENSION_CONTEXT;
+    contexts["unblessed_extension"] = Feature::UNBLESSED_EXTENSION_CONTEXT;
+    contexts["content_script"] = Feature::CONTENT_SCRIPT_CONTEXT;
+    contexts["web_page"] = Feature::WEB_PAGE_CONTEXT;
 
-    locations["component"] = extensions::Feature::COMPONENT_LOCATION;
+    locations["component"] = Feature::COMPONENT_LOCATION;
 
-    platforms["chromeos"] = extensions::Feature::CHROMEOS_PLATFORM;
+    platforms["chromeos"] = Feature::CHROMEOS_PLATFORM;
 
     channels["trunk"] = VersionInfo::CHANNEL_UNKNOWN;
     channels["canary"] = VersionInfo::CHANNEL_CANARY;
     channels["dev"] = VersionInfo::CHANNEL_DEV;
     channels["beta"] = VersionInfo::CHANNEL_BETA;
     channels["stable"] = VersionInfo::CHANNEL_STABLE;
   }
 
-  std::map<std::string, Extension::Type> extension_types;
-  std::map<std::string, extensions::Feature::Context> contexts;
-  std::map<std::string, extensions::Feature::Location> locations;
-  std::map<std::string, extensions::Feature::Platform> platforms;
+  std::map<std::string, Manifest::Type> extension_types;
+  std::map<std::string, Feature::Context> contexts;
+  std::map<std::string, Feature::Location> locations;
+  std::map<std::string, Feature::Platform> platforms;
   std::map<std::string, VersionInfo::Channel> channels;
 };
 
 base::LazyInstance<Mappings> g_mappings = LAZY_INSTANCE_INITIALIZER;
 
 std::string GetChannelName(VersionInfo::Channel channel) {
   typedef std::map<std::string, VersionInfo::Channel> ChannelsMap;
   ChannelsMap channels = g_mappings.Get().channels;
   for (ChannelsMap::iterator i = channels.begin(); i != channels.end(); ++i) {
     if (i->second == channel)
@@ skipping 67 matching lines @@
   ParseSet(value, property, &string_set);
   for (std::set<std::string>::iterator iter = string_set.begin();
        iter != string_set.end(); ++iter) {
     T enum_value = static_cast<T>(0);
     ParseEnum(*iter, &enum_value, mapping);
     enum_set->insert(enum_value);
   }
 }
 
 // Gets a human-readable name for the given extension type.
-std::string GetDisplayTypeName(Extension::Type type) {
+std::string GetDisplayTypeName(Manifest::Type type) {
   switch (type) {
-    case Extension::TYPE_UNKNOWN:
+    case Manifest::TYPE_UNKNOWN:
       return "unknown";
-    case Extension::TYPE_EXTENSION:
+    case Manifest::TYPE_EXTENSION:
       return "extension";
-    case Extension::TYPE_HOSTED_APP:
+    case Manifest::TYPE_HOSTED_APP:
       return "hosted app";
-    case Extension::TYPE_LEGACY_PACKAGED_APP:
+    case Manifest::TYPE_LEGACY_PACKAGED_APP:
       return "legacy packaged app";
-    case Extension::TYPE_PLATFORM_APP:
+    case Manifest::TYPE_PLATFORM_APP:
       return "packaged app";
-    case Extension::TYPE_THEME:
+    case Manifest::TYPE_THEME:
       return "theme";
-    case Extension::TYPE_USER_SCRIPT:
+    case Manifest::TYPE_USER_SCRIPT:
       return "user script";
   }
 
   NOTREACHED();
   return "";
 }
 
 }  // namespace
 
-namespace extensions {
-
 SimpleFeature::SimpleFeature()
   : location_(UNSPECIFIED_LOCATION),
     platform_(UNSPECIFIED_PLATFORM),
     min_manifest_version_(0),
     max_manifest_version_(0),
     channel_(VersionInfo::CHANNEL_UNKNOWN) {
 }
 
 SimpleFeature::SimpleFeature(const SimpleFeature& other)
     : whitelist_(other.whitelist_),
@@ skipping 15 matching lines @@
       contexts_ == other.contexts_ &&
       location_ == other.location_ &&
       platform_ == other.platform_ &&
       min_manifest_version_ == other.min_manifest_version_ &&
       max_manifest_version_ == other.max_manifest_version_ &&
       channel_ == other.channel_;
 }
 
 void SimpleFeature::Parse(const DictionaryValue* value) {
   ParseSet(value, "whitelist", &whitelist_);
-  ParseEnumSet<Extension::Type>(value, "extension_types", &extension_types_,
+  ParseEnumSet<Manifest::Type>(value, "extension_types", &extension_types_,
                                 g_mappings.Get().extension_types);
   ParseEnumSet<Context>(value, "contexts", &contexts_,
                         g_mappings.Get().contexts);
   ParseEnum<Location>(value, "location", &location_,
                       g_mappings.Get().locations);
   ParseEnum<Platform>(value, "platform", &platform_,
                       g_mappings.Get().platforms);
   value->GetInteger("min_manifest_version", &min_manifest_version_);
   value->GetInteger("max_manifest_version", &max_manifest_version_);
   ParseEnum<VersionInfo::Channel>(
       value, "channel", &channel_,
       g_mappings.Get().channels);
 }
 
 Feature::Availability SimpleFeature::IsAvailableToManifest(
     const std::string& extension_id,
-    Extension::Type type,
+    Manifest::Type type,
     Location location,
     int manifest_version,
     Platform platform) const {
   // Component extensions can access any feature.
   if (location == COMPONENT_LOCATION)
     return CreateAvailability(IS_AVAILABLE, type);
 
   if (!whitelist_.empty()) {
     if (whitelist_.find(extension_id) == whitelist_.end()) {
       // TODO(aa): This is gross. There should be a better way to test the
@@ skipping 48 matching lines @@
 
   if (!contexts_.empty() &&
       contexts_.find(context) == contexts_.end()) {
     return CreateAvailability(INVALID_CONTEXT, extension->GetType());
   }
 
   return CreateAvailability(IS_AVAILABLE);
 }
 
 std::string SimpleFeature::GetAvailabilityMessage(
-    AvailabilityResult result, Extension::Type type) const {
+    AvailabilityResult result, Manifest::Type type) const {
   switch (result) {
     case IS_AVAILABLE:
       return "";
     case NOT_FOUND_IN_WHITELIST:
       return base::StringPrintf(
           "'%s' is not allowed for specified extension ID.",
           name().c_str());
     case INVALID_TYPE: {
       std::string allowed_type_names;
       // Turn the set of allowed types into a vector so that it's easier to
       // inject the appropriate separator into the display string.
-      std::vector<Extension::Type> extension_types(
+      std::vector<Manifest::Type> extension_types(
           extension_types_.begin(), extension_types_.end());
       for (size_t i = 0; i < extension_types.size(); i++) {
         // Pluralize type name.
         allowed_type_names += GetDisplayTypeName(extension_types[i]) + "s";
         if (i == extension_types_.size() - 2) {
           allowed_type_names += " and ";
         } else if (i != extension_types_.size() - 1) {
           allowed_type_names += ", ";
         }
       }
@@ skipping 40 matching lines @@
           GetChannelName(GetCurrentChannel()).c_str());
   }
 
   NOTREACHED();
   return "";
 }
 
 Feature::Availability SimpleFeature::CreateAvailability(
     AvailabilityResult result) const {
   return Availability(
-      result, GetAvailabilityMessage(result, Extension::TYPE_UNKNOWN));
+      result, GetAvailabilityMessage(result, Manifest::TYPE_UNKNOWN));
 }
 
 Feature::Availability SimpleFeature::CreateAvailability(
-    AvailabilityResult result, Extension::Type type) const {
+    AvailabilityResult result, Manifest::Type type) const {
   return Availability(result, GetAvailabilityMessage(result, type));
 }
 
 std::set<Feature::Context>* SimpleFeature::GetContexts() {
   return &contexts_;
 }
 
 }  // namespace extensions