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

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/bind.h"
@@ skipping 230 matching lines @@
   }
   return display_name_list;
 }
 
 std::string HashExtensionId(const std::string& extension_id) {
   const std::string id_hash = base::SHA1HashString(extension_id);
   DCHECK(id_hash.length() == base::kSHA1Length);
   return base::HexEncode(id_hash.c_str(), id_hash.length());
 }
 
+bool IsCommandLineSwitchEnabled(const std::string& switch_name) {
+  base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
+  if (command_line->HasSwitch(switch_name + "=1"))
+    return true;
+  if (command_line->HasSwitch(std::string("enable-") + switch_name))
+    return true;
+  return false;
+}
+
 }  // namespace
 
 SimpleFeature::SimpleFeature()
     : location_(UNSPECIFIED_LOCATION),
       min_manifest_version_(0),
       max_manifest_version_(0),
-      has_parent_(false),
       component_extensions_auto_granted_(true) {}
 
 SimpleFeature::~SimpleFeature() {}
 
 bool SimpleFeature::HasDependencies() {
   return !dependencies_.empty();
 }
 
 void SimpleFeature::AddFilter(scoped_ptr<SimpleFeatureFilter> filter) {
   filters_.push_back(make_linked_ptr(filter.release()));
@@ skipping 11 matching lines @@
   ParseEnum<Location>(value, "location", &location_,
                       g_mappings.Get().locations);
   ParseEnumSet<Platform>(value, "platforms", &platforms_,
                          g_mappings.Get().platforms);
   value->GetInteger("min_manifest_version", &min_manifest_version_);
   value->GetInteger("max_manifest_version", &max_manifest_version_);
 
   no_parent_ = false;
   value->GetBoolean("noparent", &no_parent_);
 
-  component_extensions_auto_granted_ = true;
   value->GetBoolean("component_extensions_auto_granted",
                     &component_extensions_auto_granted_);
 
+  value->GetString("command_line_switch", &command_line_switch_);
+
   // NOTE: ideally we'd sanity check that "matches" can be specified if and
   // only if there's a "web_page" or "webui" context, but without
   // (Simple)Features being aware of their own heirarchy this is impossible.
   //
   // For example, we might have feature "foo" available to "web_page" context
   // and "matches" google.com/*. Then a sub-feature "foo.bar" might override
   // "matches" to be chromium.org/*. That sub-feature doesn't need to specify
   // "web_page" context because it's inherited, but we don't know that here.
 
   for (FilterList::iterator filter_iter = filters_.begin();
@@ skipping 57 matching lines @@
   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_)
     return CreateAvailability(INVALID_MAX_MANIFEST_VERSION, type);
 
+  if (!command_line_switch_.empty() &&
+      !IsCommandLineSwitchEnabled(command_line_switch_)) {
+    return CreateAvailability(MISSING_COMMAND_LINE_SWITCH, type);
+  }
+
   for (FilterList::const_iterator filter_iter = filters_.begin();
        filter_iter != filters_.end();
        ++filter_iter) {
     Availability availability = (*filter_iter)->IsAvailableToManifest(
         extension_id, type, location, manifest_version, platform);
     if (!availability.is_available())
       return availability;
   }
 
   return CheckDependencies(base::Bind(&IsAvailableToManifestForBind,
@@ skipping 94 matching lines @@
           name().c_str(),
           max_manifest_version_);
     case NOT_PRESENT:
       return base::StringPrintf(
           "'%s' requires a different Feature that is not present.",
           name().c_str());
     case UNSUPPORTED_CHANNEL:
       return base::StringPrintf(
           "'%s' is unsupported in this version of the platform.",
           name().c_str());
+    case MISSING_COMMAND_LINE_SWITCH:
+      return base::StringPrintf(
+          "'%s' requires the '%s' command line switch to be enabled.",
+          name().c_str(), command_line_switch_.c_str());
   }
 
   NOTREACHED();
   return std::string();
 }
 
 Feature::Availability SimpleFeature::CreateAvailability(
     AvailabilityResult result) const {
   return Availability(
       result, GetAvailabilityMessage(result, Manifest::TYPE_UNKNOWN, GURL(),
@@ skipping 78 matching lines @@
     if (!dependency)
       return CreateAvailability(NOT_PRESENT);
     Availability dependency_availability = checker.Run(dependency);
     if (!dependency_availability.is_available())
       return dependency_availability;
   }
   return CreateAvailability(IS_AVAILABLE);
 }
 
 }  // namespace extensions