Add support for command line switches to Features, and as proof that it works,

extensions/common/manifest_handlers/permissions_parser.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/manifest_handlers/permissions_parser.h"
 
 #include "base/command_line.h"
 #include "base/memory/ref_counted.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
@@ skipping 28 matching lines @@
 };
 
 ManifestPermissions::ManifestPermissions(
     scoped_refptr<const PermissionSet> permissions)
     : permissions(permissions) {
 }
 
 ManifestPermissions::~ManifestPermissions() {
 }
 
-// Custom checks for the experimental permission that can't be expressed in
-// _permission_features.json.
-bool CanSpecifyExperimentalPermission(const Extension* extension) {
-  if (extension->location() == Manifest::COMPONENT)
-    return true;
-
-  if (CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kEnableExperimentalExtensionApis)) {
-    return true;
-  }
-
-  // We rely on the webstore to check access to experimental. This way we can
-  // whitelist extensions to have access to experimental in just the store, and
-  // not have to push a new version of the client.
-  if (extension->from_webstore())
-    return true;
-
-  return false;
-}
-
 // Checks whether the host |pattern| is allowed for the given |extension|,
 // given API permissions |permissions|.
 bool CanSpecifyHostPermission(const Extension* extension,
                               const URLPattern& pattern,
                               const APIPermissionSet& permissions) {
   if (!pattern.match_all_urls() &&
       pattern.MatchesScheme(content::kChromeUIScheme)) {
     URLPatternSet chrome_scheme_hosts =
         ExtensionsClient::Get()->GetPermittedChromeSchemeHosts(extension,
                                                                permissions);
@@ skipping 60 matching lines @@
 
     // The feature should exist since we just got an APIPermission for it. The
     // two systems should be updated together whenever a permission is added.
     DCHECK(feature) << "Could not find feature for " << iter->name();
     // http://crbug.com/176381
     if (!feature) {
       to_remove.push_back(iter->id());
       continue;
     }
 
+    // Sneaky check for "experimental", which we always allow for extensions
+    // installed from the Webstore. This way we can whitelist extensions to
+    // have access to experimental in just the store, and not have to push a
+    // new version of the client. Otherwise, experimental goes through the
+    // usual features check.
+    if (iter->id() == APIPermission::kExperimental &&
+        extension->from_webstore()) {
+      continue;
+    }
+
     Feature::Availability availability =
         feature->IsAvailableToExtension(extension);
     if (!availability.is_available()) {
       // Don't fail, but warn the developer that the manifest contains
       // unrecognized permissions. This may happen legitimately if the
       // extensions requests platform- or channel-specific permissions.
       extension->AddInstallWarning(
           InstallWarning(availability.message(), feature->name()));
       to_remove.push_back(iter->id());
       continue;
     }
-
-    if (iter->id() == APIPermission::kExperimental) {
-      if (!CanSpecifyExperimentalPermission(extension)) {
-        *error = base::ASCIIToUTF16(errors::kExperimentalFlagRequired);
-        return false;
-      }
-    }
   }
 
   api_permissions->AddImpliedPermissions();
 
   // Remove permissions that are not available to this extension.
   for (std::vector<APIPermission::ID>::const_iterator iter = to_remove.begin();
        iter != to_remove.end();
        ++iter) {
     api_permissions->erase(*iter);
   }
@@ skipping 171 matching lines @@
 // static
 scoped_refptr<const PermissionSet> PermissionsParser::GetOptionalPermissions(
     const Extension* extension) {
   DCHECK(extension->GetManifestData(keys::kOptionalPermissions));
   return static_cast<const ManifestPermissions*>(
              extension->GetManifestData(keys::kOptionalPermissions))
       ->permissions;
 }
 
 }  // namespace extensions