[Extensions] Move Feature channel code into //extensions

extensions/common/features/simple_feature.h

 // Copyright 2014 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 EXTENSIONS_COMMON_FEATURES_SIMPLE_FEATURE_H_
 #define EXTENSIONS_COMMON_FEATURES_SIMPLE_FEATURE_H_
 
 #include <stddef.h>
 
 #include <memory>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/callback_forward.h"
 #include "base/gtest_prod_util.h"
 #include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/values.h"
+#include "components/version_info/version_info.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/features/feature.h"
-#include "extensions/common/features/simple_feature_filter.h"
 #include "extensions/common/manifest.h"
 
 namespace extensions {
 
 class BaseFeatureProviderTest;
 class ExtensionAPITest;
 class ManifestUnitTest;
 class SimpleFeatureTest;
 
 class SimpleFeature : public Feature {
  public:
   // Used by tests to override the cached --whitelisted-extension-id.
   class ScopedWhitelistForTest {
    public:
     explicit ScopedWhitelistForTest(const std::string& id);
     ~ScopedWhitelistForTest();
 
    private:
     std::string* previous_id_;
 
     DISALLOW_COPY_AND_ASSIGN(ScopedWhitelistForTest);
   };
 
   SimpleFeature();
   ~SimpleFeature() override;
 
-  // Dependency resolution is a property of Features that is preferrably
-  // handled internally to avoid temptation, but FeatureFilters may need
-  // to know if there are any at all.
-  bool HasDependencies() const;
-
-  // Adds a filter to this feature. The feature takes ownership of the filter.
-  void AddFilter(std::unique_ptr<SimpleFeatureFilter> filter);
-
   // Parses the JSON representation of a feature into the fields of this object.
   // Unspecified values in the JSON are not modified in the object. This allows
   // us to implement inheritance by parsing one value after another. Returns
   // the error found, or an empty string on success.
   virtual std::string Parse(const base::DictionaryValue* dictionary);
 
   Availability IsAvailableToContext(const Extension* extension,
                                     Context context) const {
     return IsAvailableToContext(extension, context, GURL());
   }
@@ skipping 13 matching lines @@
                                      Manifest::Type type,
                                      Manifest::Location location,
                                      int manifest_version,
                                      Platform platform) const override;
 
   Availability IsAvailableToContext(const Extension* extension,
                                     Context context,
                                     const GURL& url,
                                     Platform platform) const override;
 
-  std::string GetAvailabilityMessage(AvailabilityResult result,
-                                     Manifest::Type type,
-                                     const GURL& url,
-                                     Context context) const override;
-
   bool IsInternal() const override;
 
   bool IsIdInBlacklist(const std::string& extension_id) const override;
   bool IsIdInWhitelist(const std::string& extension_id) const override;
 
   static bool IsIdInArray(const std::string& extension_id,
                           const char* const array[],
                           size_t array_length);
 
  protected:
@@ skipping 29 matching lines @@
   void set_max_manifest_version(int max_manifest_version) {
     max_manifest_version_ = max_manifest_version;
   }
   const std::string& command_line_switch() const {
     return command_line_switch_;
   }
   void set_command_line_switch(const std::string& command_line_switch) {
     command_line_switch_ = command_line_switch;
   }
 
+  std::string GetAvailabilityMessage(AvailabilityResult result,
+                                     Manifest::Type type,
+                                     const GURL& url,
+                                     Context context,
+                                     version_info::Channel channel) const;
+
   // Handy utilities which construct the correct availability message.
   Availability CreateAvailability(AvailabilityResult result) const;
   Availability CreateAvailability(AvailabilityResult result,
                                   Manifest::Type type) const;
   Availability CreateAvailability(AvailabilityResult result,
                                   const GURL& url) const;
   Availability CreateAvailability(AvailabilityResult result,
                                   Context context) const;
+  Availability CreateAvailability(AvailabilityResult result,
+                                  version_info::Channel channel) const;
 
  private:
   friend class SimpleFeatureTest;
   FRIEND_TEST_ALL_PREFIXES(BaseFeatureProviderTest, ManifestFeatureTypes);
   FRIEND_TEST_ALL_PREFIXES(BaseFeatureProviderTest, PermissionFeatureTypes);
   FRIEND_TEST_ALL_PREFIXES(ExtensionAPITest, DefaultConfigurationFeatures);
   FRIEND_TEST_ALL_PREFIXES(ManifestUnitTest, Extension);
   FRIEND_TEST_ALL_PREFIXES(SimpleFeatureTest, Blacklist);
   FRIEND_TEST_ALL_PREFIXES(SimpleFeatureTest, CommandLineSwitch);
   FRIEND_TEST_ALL_PREFIXES(SimpleFeatureTest, Context);
@@ skipping 35 matching lines @@
   std::vector<std::string> dependencies_;
   std::vector<Manifest::Type> extension_types_;
   std::vector<Context> contexts_;
   std::vector<Platform> platforms_;
   URLPatternSet matches_;
   Location location_;
   int min_manifest_version_;
   int max_manifest_version_;
   bool component_extensions_auto_granted_;
   std::string command_line_switch_;
-
-  std::vector<std::unique_ptr<SimpleFeatureFilter>> filters_;
+  std::unique_ptr<version_info::Channel> channel_;
 
   DISALLOW_COPY_AND_ASSIGN(SimpleFeature);
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_COMMON_FEATURES_SIMPLE_FEATURE_H_