Extensions: Only create Web request rules registry if Declarative Web Request is enabled.

extensions/common/features/simple_feature.cc

 // 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.
 
 #include "extensions/common/features/simple_feature.h"
 
 #include <algorithm>
 #include <map>
 #include <utility>
 #include <vector>
@@ skipping 35 matching lines @@
 }
 
 Feature::Availability IsAvailableToContextForBind(const Extension* extension,
                                                   Feature::Context context,
                                                   const GURL& url,
                                                   Feature::Platform platform,
                                                   const Feature* feature) {
   return feature->IsAvailableToContext(extension, context, url, platform);
 }
 
+Feature::Availability IsAvailableToChannelForBind(version_info::Channel channel,
+                                                  const Feature* feature) {
+  return feature->IsAvailableToChannel(channel);
+}
+
 // Gets a human-readable name for the given extension type, suitable for giving
 // to developers in an error message.
 std::string GetDisplayName(Manifest::Type type) {
   switch (type) {
     case Manifest::TYPE_UNKNOWN:
       return "unknown";
     case Manifest::TYPE_EXTENSION:
       return "extension";
     case Manifest::TYPE_HOSTED_APP:
       return "hosted app";
@@ skipping 382 matching lines @@
 }
 
 bool SimpleFeature::IsIdInBlacklist(const std::string& extension_id) const {
   return IsIdInList(extension_id, blacklist_);
 }
 
 bool SimpleFeature::IsIdInWhitelist(const std::string& extension_id) const {
   return IsIdInList(extension_id, whitelist_);
 }
 
+Feature::Availability SimpleFeature::IsAvailableToChannel(
+    version_info::Channel channel) const {
+  if (channel_ && *channel_ < channel)
+    return CreateAvailability(UNSUPPORTED_CHANNEL, *channel_);
+  return CheckDependencies(base::Bind(&IsAvailableToChannelForBind, channel));
+}
+
 // static
 bool SimpleFeature::IsIdInArray(const std::string& extension_id,
                                 const char* const array[],
                                 size_t array_length) {
   if (!IsValidExtensionId(extension_id))
     return false;
 
   const char* const* start = array;
   const char* const* end = array + array_length;
 
@@ skipping 105 matching lines @@
 void SimpleFeature::set_platforms(std::initializer_list<Platform> platforms) {
   platforms_ = platforms;
 }
 
 void SimpleFeature::set_whitelist(
     std::initializer_list<const char* const> whitelist) {
   whitelist_.assign(whitelist.begin(), whitelist.end());
 }
 
 }  // namespace extensions