Remove GetContexts() from the public interface of extensions::Feature. It was

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 244 matching lines @@
                                               const FeatureProvider* provider) {
   dependency_providers_[name] = provider;
 }
 
 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());
+
   if (api.IsAvailableToContext(extension, context, url).is_available())
     return true;
 
   // Check to see if there are any parts of this API that are allowed in this
   // context.
   const std::vector<Feature*> features = provider->second->GetChildren(api);
   for (std::vector<Feature*>::const_iterator it = features.begin();
        it != features.end();
        ++it) {
     if ((*it)->IsAvailableToContext(extension, context, url).is_available())
       return true;
   }
   return false;
 }
 
 Feature::Availability ExtensionAPI::IsAvailable(const std::string& full_name,
                                                 const Extension* extension,
                                                 Feature::Context context,
                                                 const GURL& url) {
   Feature* feature = GetFeatureDependency(full_name);
   if (!feature) {
     return Feature::CreateAvailability(Feature::NOT_PRESENT,
         std::string("Unknown feature: ") + full_name);
   }
   return feature->IsAvailableToContext(extension, context, url);
 }
 
-bool ExtensionAPI::IsPrivileged(const std::string& full_name) {
-  Feature* feature = GetFeatureDependency(full_name);
-  CHECK(feature) << full_name;
-  DCHECK(!feature->GetContexts()->empty()) << full_name;
-  // An API is 'privileged' if it can only be run in a blessed context.
-  return feature->GetContexts()->size() ==
-      feature->GetContexts()->count(Feature::BLESSED_EXTENSION_CONTEXT);
+bool ExtensionAPI::IsAvailableInUntrustedContext(const std::string& name,
+                                                 const Extension* extension) {
+  return IsAvailable(name, extension, Feature::CONTENT_SCRIPT_CONTEXT, GURL())

[Ken Rockot(use gerrit already), 2014/07/09 16:24:15]

Heh, this is a little awkward to read, but I realize it's not necessarily a
concern for this CL. Seems like IsAvailable should be called something like
GetAvailabilityForContext.

[not at google - send to devlin, 2014/07/09 16:26:26]

I agree! I can rename in a follow up.

+             .is_available() ||
+         IsAvailable(
+             name, extension, Feature::UNBLESSED_EXTENSION_CONTEXT, GURL())
+             .is_available() ||
+         IsAvailable(name, extension, Feature::BLESSED_WEB_PAGE_CONTEXT, GURL())
+             .is_available() ||
+         IsAvailable(name, extension, Feature::WEB_PAGE_CONTEXT, GURL())
+             .is_available();
 }
 
 const base::DictionaryValue* ExtensionAPI::GetSchema(
     const std::string& full_name) {
   std::string child_name;
   std::string api_name = GetAPINameFromFullName(full_name, &child_name);
 
   const base::DictionaryValue* result = NULL;
   SchemaMap::iterator maybe_schema = schemas_.find(api_name);
   if (maybe_schema != schemas_.end()) {
@@ skipping 73 matching lines @@
       break;
 
     api_name_candidate = api_name_candidate.substr(0, last_dot_index);
   }
 
   *child_name = "";
   return std::string();
 }
 
 }  // namespace extensions