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

chrome/common/extensions/feature.h

 // 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.
 
 #ifndef CHROME_COMMON_EXTENSIONS_FEATURE_H_
 #define CHROME_COMMON_EXTENSIONS_FEATURE_H_
 #pragma once
 
 #include <set>
 #include <string>
@@ skipping 83 matching lines @@
   }
 
   int max_manifest_version() const { return max_manifest_version_; }
   void set_max_manifest_version(int max_manifest_version) {
     max_manifest_version_ = max_manifest_version;
   }
 
   // Parses the JSON representation of a feature into the fields of this object.
   // Unspecified values in the JSON are not modified in the object. This allows
   // us to implement inheritance by parsing one value after another.
-  void Parse(const DictionaryValue* value);
+  virtual void Parse(const DictionaryValue* value);
 
   // Returns true if the feature contains the same values as another.
   bool Equals(const Feature& other) const;
 
+  // Returns true if the Feature contains no specification.
+  bool IsEmpty() const;
+
   // Returns true if the feature is available to be parsed into a new extension
   // manifest.
   Availability IsAvailableToManifest(const std::string& extension_id,
                                      Extension::Type type,
                                      Location location,
                                      int manifest_version) const {
     return IsAvailableToManifest(extension_id, type, location, manifest_version,
                                  GetCurrentPlatform());
   }
   Availability IsAvailableToManifest(const std::string& extension_id,
                                      Extension::Type type,
                                      Location location,
                                      int manifest_version,
                                      Platform platform) const;
 
   // Returns true if the feature is available to be used in the specified
   // extension and context.
   Availability IsAvailableToContext(const Extension* extension,
                                     Context context) const {
     return IsAvailableToContext(extension, context, GetCurrentPlatform());
   }
   virtual Availability IsAvailableToContext(const Extension* extension,
                                             Context context,
                                             Platform platform) const;
 
   // Returns an error message for an Availability code.
   std::string GetErrorMessage(Availability result);
 
+ protected:
+  static void ParseSet(const DictionaryValue* value,
+                       const std::string& property,
+                       std::set<std::string>* set);
+
  private:
   std::string name_;
 
   // For clarify and consistency, we handle the default value of each of these
   // members the same way: it matches everything. It is up to the higher level
   // code that reads Features out of static data to validate that data and set
   // sensible defaults.
   std::set<std::string> whitelist_;
   std::set<Extension::Type> extension_types_;
   std::set<Context> contexts_;
   Location location_;  // we only care about component/not-component now
   Platform platform_;  // we only care about chromeos/not-chromeos now
   int min_manifest_version_;
   int max_manifest_version_;
 };
 
 }  // namespace extensions
 
 #endif  // CHROME_COMMON_EXTENSIONS_FEATURE_H_