Pass a Feature* to IsAnyFeatureAvailableToContext instead of a string name.

extensions/common/extension_api.cc

 // Copyright 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 "extensions/common/extension_api.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 258 matching lines @@
 void ExtensionAPI::RegisterSchemaResource(const std::string& name,
                                           int resource_id) {
   unloaded_schemas_[name] = resource_id;
 }
 
 void ExtensionAPI::RegisterDependencyProvider(const std::string& name,
                                               FeatureProvider* provider) {
   dependency_providers_[name] = provider;
 }
 
-bool ExtensionAPI::IsAnyFeatureAvailableToContext(const std::string& api_name,
+bool ExtensionAPI::IsAnyFeatureAvailableToContext(const Feature& api,
                                                   const Extension* extension,
                                                   Feature::Context context,
                                                   const GURL& url) {
   FeatureProviderMap::iterator provider = dependency_providers_.find("api");
   CHECK(provider != dependency_providers_.end());
   const std::vector<std::string>& features =
       provider->second->GetAllFeatureNames();
 
   // Check to see if there are any parts of this API that are allowed in this
   // context.
   for (std::vector<std::string>::const_iterator i = features.begin();
        i != features.end(); ++i) {
     const std::string& feature_name = *i;
-    if (feature_name != api_name && feature_name.find(api_name + ".") == 0) {
+    if (feature_name != api.name() &&
+        feature_name.find(api.name() + ".") == 0) {
       if (IsAvailable(feature_name, extension, context, url).is_available())
         return true;
     }
   }
-  return IsAvailable(api_name, extension, context, url).is_available();
+  return IsAvailable(api.name(), extension, context, url).is_available();
 }
 
 Feature::Availability ExtensionAPI::IsAvailable(const std::string& full_name,
                                                 const Extension* extension,
                                                 Feature::Context context,
                                                 const GURL& url) {
   Feature* feature = GetFeatureDependency(full_name);
   CHECK(feature) << full_name;
 
   Feature::Availability availability =
@@ skipping 99 matching lines @@
       break;
 
     api_name_candidate = api_name_candidate.substr(0, last_dot_index);
   }
 
   *child_name = "";
   return std::string();
 }
 
 }  // namespace extensions