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

chrome/common/extensions/features/feature.h

 // 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.
 
 #ifndef CHROME_COMMON_EXTENSIONS_FEATURES_FEATURE_H_
 #define CHROME_COMMON_EXTENSIONS_FEATURES_FEATURE_H_
 
 #include <set>
 #include <string>
 
 #include "base/values.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/extensions/extension.h"
+#include "chrome/common/extensions/manifest.h"
 
 namespace extensions {
 
 // Represents a single feature accessible to an extension developer, such as a
 // top-level manifest key, a permission, or a programmatic API. A feature can
 // express requirements for where it can be accessed, and supports testing
 // support for those requirements.
 class Feature {
  public:
   // The JavaScript contexts the feature is supported in.
@@ skipping 88 matching lines @@
    private:
     chrome::VersionInfo::Channel original_channel_;
   };
 
   const std::string& name() const { return name_; }
   void set_name(const std::string& name) { name_ = name; }
 
   // Gets the platform the code is currently running on.
   static Platform GetCurrentPlatform();
 
-  // Gets the Feature::Location value for the specified Extension::Location.
-  static Location ConvertLocation(Extension::Location extension_location);
+  // Gets the Feature::Location value for the specified Manifest::Location.
+  static Location ConvertLocation(Manifest::Location extension_location);
 
   // TODO(justinlin): Remove and move to APIFeature when it exists.
   virtual std::set<Context>* GetContexts() = 0;
 
   // Returns true if the feature is available to be parsed into a new extension
   // manifest.
   Availability IsAvailableToManifest(const std::string& extension_id,
-                                     Extension::Type type,
+                                     Manifest::Type type,
                                      Location location,
                                      int manifest_version) const {
     return IsAvailableToManifest(extension_id, type, location, manifest_version,
                                  GetCurrentPlatform());
   }
   virtual Availability IsAvailableToManifest(const std::string& extension_id,
-                                             Extension::Type type,
+                                             Manifest::Type type,
                                              Location location,
                                              int manifest_version,
                                              Platform platform) const = 0;
 
   // Returns true if the feature is available to be used in the specified
   // extension and context.
   Availability IsAvailableToContext(const Extension* extension,
                                     Context context) const {
     return IsAvailableToContext(extension, context, GetCurrentPlatform());
   }
   virtual Availability IsAvailableToContext(const Extension* extension,
                                             Context context,
                                             Platform platform) const = 0;
 
   virtual std::string GetAvailabilityMessage(
-      AvailabilityResult result, Extension::Type type) const = 0;
+      AvailabilityResult result, Manifest::Type type) const = 0;
 
  protected:
   std::string name_;
 };
 
 }  // namespace extensions
 
 #endif  // CHROME_COMMON_EXTENSIONS_FEATURES_FEATURE_H_