Support a "policy" extension location in extension features files. At the same

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 <map>
 #include <vector>
 
 #include "base/command_line.h"
@@ skipping 16 matching lines @@
     extension_types["hosted_app"] = Manifest::TYPE_HOSTED_APP;
     extension_types["platform_app"] = Manifest::TYPE_PLATFORM_APP;
     extension_types["shared_module"] = Manifest::TYPE_SHARED_MODULE;
 
     contexts["blessed_extension"] = Feature::BLESSED_EXTENSION_CONTEXT;
     contexts["unblessed_extension"] = Feature::UNBLESSED_EXTENSION_CONTEXT;
     contexts["content_script"] = Feature::CONTENT_SCRIPT_CONTEXT;
     contexts["web_page"] = Feature::WEB_PAGE_CONTEXT;
     contexts["blessed_web_page"] = Feature::BLESSED_WEB_PAGE_CONTEXT;
 
-    locations["component"] = Feature::COMPONENT_LOCATION;
+    locations["component"] = SimpleFeature::COMPONENT_LOCATION;
+    locations["policy"] = SimpleFeature::POLICY_LOCATION;
 
     platforms["chromeos"] = Feature::CHROMEOS_PLATFORM;
     platforms["linux"] = Feature::LINUX_PLATFORM;
     platforms["mac"] = Feature::MACOSX_PLATFORM;
     platforms["win"] = Feature::WIN_PLATFORM;
   }
 
   std::map<std::string, Manifest::Type> extension_types;
   std::map<std::string, Feature::Context> contexts;
-  std::map<std::string, Feature::Location> locations;
+  std::map<std::string, SimpleFeature::Location> locations;
   std::map<std::string, Feature::Platform> platforms;
 };
 
 base::LazyInstance<Mappings> g_mappings = LAZY_INSTANCE_INITIALIZER;
 
 // TODO(aa): Can we replace all this manual parsing with JSON schema stuff?
 
 void ParseSet(const base::DictionaryValue* value,
               const std::string& property,
               std::set<std::string>* set) {
@@ skipping 199 matching lines @@
       return result;
     }
   }
 
   return std::string();
 }
 
 Feature::Availability SimpleFeature::IsAvailableToManifest(
     const std::string& extension_id,
     Manifest::Type type,
-    Location location,
+    Manifest::Location location,
     int manifest_version,
     Platform platform) const {
   // Check extension type first to avoid granting platform app permissions
   // to component extensions.
   // HACK(kalman): user script -> extension. Solve this in a more generic way
   // when we compile feature files.
   Manifest::Type type_to_check = (type == Manifest::TYPE_USER_SCRIPT) ?
       Manifest::TYPE_EXTENSION : type;
   if (!extension_types_.empty() &&
       extension_types_.find(type_to_check) == extension_types_.end()) {
     return CreateAvailability(INVALID_TYPE, type);
   }
 
   // Component extensions can access any feature.
-  if (location == COMPONENT_LOCATION)
+  // TODO(kalman/asargent): Should this match EXTERNAL_COMPONENT too?
+  if (location == Manifest::COMPONENT)
     return CreateAvailability(IS_AVAILABLE, type);
 
   if (!whitelist_.empty()) {
     if (!IsIdInWhitelist(extension_id)) {
       // TODO(aa): This is gross. There should be a better way to test the
       // whitelist.
       CommandLine* command_line = CommandLine::ForCurrentProcess();
       if (!command_line->HasSwitch(switches::kWhitelistedExtensionID))
         return CreateAvailability(NOT_FOUND_IN_WHITELIST, type);
 
       std::string whitelist_switch_value =
           CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
               switches::kWhitelistedExtensionID);
       if (extension_id != whitelist_switch_value)
         return CreateAvailability(NOT_FOUND_IN_WHITELIST, type);
     }
   }
 
-  if (location_ != UNSPECIFIED_LOCATION && location_ != location)
+  if (!MatchesManifestLocation(location))
     return CreateAvailability(INVALID_LOCATION, type);
 
   if (!platforms_.empty() &&
       platforms_.find(platform) == platforms_.end())
     return CreateAvailability(INVALID_PLATFORM, type);
 
   if (min_manifest_version_ != 0 && manifest_version < min_manifest_version_)
     return CreateAvailability(INVALID_MIN_MANIFEST_VERSION, type);
 
   if (max_manifest_version_ != 0 && manifest_version > max_manifest_version_)
@@ skipping 10 matching lines @@
 
   return CreateAvailability(IS_AVAILABLE, type);
 }
 
 Feature::Availability SimpleFeature::IsAvailableToContext(
     const Extension* extension,
     SimpleFeature::Context context,
     const GURL& url,
     SimpleFeature::Platform platform) const {
   if (extension) {
-    Availability result = IsAvailableToManifest(
-        extension->id(),
-        extension->GetType(),
-        ConvertLocation(extension->location()),
-        extension->manifest_version(),
-        platform);
+    Availability result = IsAvailableToManifest(extension->id(),
+                                                extension->GetType(),
+                                                extension->location(),
+                                                extension->manifest_version(),
+                                                platform);
     if (!result.is_available())
       return result;
   }
 
   if (!contexts_.empty() && contexts_.find(context) == contexts_.end())
     return CreateAvailability(INVALID_CONTEXT, context);
 
   if (!matches_.is_empty() && !matches_.MatchesURL(url))
     return CreateAvailability(INVALID_URL, url);
 
@@ skipping 124 matching lines @@
     return false;
 
   if (whitelist.find(extension_id) != whitelist.end() ||
       whitelist.find(HashExtensionId(extension_id)) != whitelist.end()) {
     return true;
   }
 
   return false;
 }
 
+bool SimpleFeature::MatchesManifestLocation(
+    Manifest::Location manifest_location) const {
+  switch (location_) {
+    case SimpleFeature::UNSPECIFIED_LOCATION:
+      return true;
+    case SimpleFeature::COMPONENT_LOCATION:
+      // TODO(kalman/asargent): Should this include EXTERNAL_COMPONENT too?
+      return manifest_location == Manifest::COMPONENT;
+    case SimpleFeature::POLICY_LOCATION:
+      return manifest_location == Manifest::EXTERNAL_POLICY ||
+             manifest_location == Manifest::EXTERNAL_POLICY_DOWNLOAD;
+  }
+  NOTREACHED();
+  return false;
+}
+
 }  // namespace extensions