Convert tabs, windows, and extension APIs to feature system.

chrome/common/extensions/feature.cc

 // Copyright (c) 2012 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 "chrome/common/extensions/feature.h"
 
 #include <map>
 
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/stringprintf.h"
 #include "chrome/common/chrome_switches.h"
 
+namespace extensions {
+
 namespace {
 
 struct Mappings {
   Mappings() {
     extension_types["extension"] = Extension::TYPE_EXTENSION;
     extension_types["theme"] = Extension::TYPE_THEME;
     extension_types["packaged_app"] = Extension::TYPE_PACKAGED_APP;
     extension_types["hosted_app"] = Extension::TYPE_HOSTED_APP;
     extension_types["platform_app"] = Extension::TYPE_PLATFORM_APP;
 
@@ skipping 13 matching lines @@
   std::map<std::string, extensions::Feature::Context> contexts;
   std::map<std::string, extensions::Feature::Location> locations;
   std::map<std::string, extensions::Feature::Platform> platforms;
 };
 
 static base::LazyInstance<Mappings> g_mappings =
     LAZY_INSTANCE_INITIALIZER;
 
 // TODO(aa): Can we replace all this manual parsing with JSON schema stuff?
 
-void ParseSet(const DictionaryValue* value,
-              const std::string& property,
-              std::set<std::string>* set) {
+void ParseSetImpl(const DictionaryValue* value,
+                  const std::string& property,
+                  std::set<std::string>* set) {
   ListValue* list_value = NULL;
   if (!value->GetList(property, &list_value))
     return;
 
   set->clear();
   for (size_t i = 0; i < list_value->GetSize(); ++i) {
     std::string str_val;
     CHECK(list_value->GetString(i, &str_val)) << property << " " << i;
     set->insert(str_val);
   }
@@ skipping 36 matching lines @@
     if (property_string == "all") {
       for (typename std::map<std::string, T>::const_iterator j =
                mapping.begin(); j != mapping.end(); ++j) {
         enum_set->insert(j->second);
       }
     }
     return;
   }
 
   std::set<std::string> string_set;
-  ParseSet(value, property, &string_set);
+  ParseSetImpl(value, property, &string_set);
   for (std::set<std::string>::iterator iter = string_set.begin();
        iter != string_set.end(); ++iter) {
     T enum_value = static_cast<T>(0);
     ParseEnum(*iter, &enum_value, mapping);
     enum_set->insert(enum_value);
   }
 }
 
 }  // namespace
 
-namespace extensions {
-
 Feature::Feature()
   : location_(UNSPECIFIED_LOCATION),
     platform_(UNSPECIFIED_PLATFORM),
     min_manifest_version_(0),
     max_manifest_version_(0) {
 }
 
 Feature::Feature(const Feature& other)
-    : whitelist_(other.whitelist_),
+    : name_(other.name_),
+      whitelist_(other.whitelist_),
       extension_types_(other.extension_types_),
       contexts_(other.contexts_),
       location_(other.location_),
       platform_(other.platform_),
       min_manifest_version_(other.min_manifest_version_),
       max_manifest_version_(other.max_manifest_version_) {
 }
 
 Feature::~Feature() {
 }
 
 bool Feature::Equals(const Feature& other) const {
-  return whitelist_ == other.whitelist_ &&
+  return name_ == other.name_ &&
+      whitelist_ == other.whitelist_ &&
       extension_types_ == other.extension_types_ &&
       contexts_ == other.contexts_ &&
       location_ == other.location_ &&
       platform_ == other.platform_ &&
       min_manifest_version_ == other.min_manifest_version_ &&
       max_manifest_version_ == other.max_manifest_version_;
 }
 
+bool Feature::IsEmpty() const {
+  Feature test;
+  test.set_name(name());
+  return Equals(test);
+}
+
 // static
 Feature::Platform Feature::GetCurrentPlatform() {
 #if defined(OS_CHROMEOS)
   return CHROMEOS_PLATFORM;
 #else
   return UNSPECIFIED_PLATFORM;
 #endif
 }
 
 // static
 Feature::Location Feature::ConvertLocation(Extension::Location location) {
   if (location == Extension::COMPONENT)
     return COMPONENT_LOCATION;
   else
     return UNSPECIFIED_LOCATION;
 }
 
+// static
+void Feature::ParseSet(const DictionaryValue* value,
+                       const std::string& property,
+                       std::set<std::string>* set) {
+  ParseSetImpl(value, property, set);
+}
+
 void Feature::Parse(const DictionaryValue* value) {
-  ParseSet(value, "whitelist", &whitelist_);
+  ParseSetImpl(value, "whitelist", &whitelist_);
   ParseEnumSet<Extension::Type>(value, "extension_types", &extension_types_,
                                 g_mappings.Get().extension_types);
   ParseEnumSet<Context>(value, "contexts", &contexts_,
                         g_mappings.Get().contexts);
   ParseEnum<Location>(value, "location", &location_,
                       g_mappings.Get().locations);
   ParseEnum<Platform>(value, "platform", &platform_,
                       g_mappings.Get().platforms);
   value->GetInteger("min_manifest_version", &min_manifest_version_);
   value->GetInteger("max_manifest_version", &max_manifest_version_);
@@ skipping 87 matching lines @@
 
   if (!contexts_.empty() &&
       contexts_.find(context) == contexts_.end()) {
     return INVALID_CONTEXT;
   }
 
   return IS_AVAILABLE;
 }
 
 }  // namespace