Overhaul JSON Schema Compiler to support a number of features required to

chrome/browser/extensions/api/declarative/declarative_rule.h

 // Copyright (c) 2013 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.
 //
 // DeclarativeRule<>, DeclarativeConditionSet<>, and DeclarativeActionSet<>
 // templates usable with multiple different declarativeFoo systems.  These are
 // templated on the Condition and Action types that define the behavior of a
 // particular declarative event.
 
 #ifndef CHROME_BROWSER_EXTENSIONS_API_DECLARATIVE_DECLARATIVE_RULE_H__
 #define CHROME_BROWSER_EXTENSIONS_API_DECLARATIVE_DECLARATIVE_RULE_H__
 
 #include <limits>
 
 #include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/time.h"
 #include "chrome/common/extensions/api/events.h"
 #include "chrome/common/extensions/matcher/url_matcher.h"
 
 namespace base {
 class Time;
+class Value;
 }
 
 namespace extensions {
 
 // This class stores a set of conditions that may be part of a DeclarativeRule.
 // If any condition is fulfilled, the Actions of the DeclarativeRule can be
 // triggered.
 //
 // ConditionT should be immutable after creation.  It must define the following
 // members:
@@ skipping 13 matching lines @@
 //   // argument.
 //   bool has_url_matcher_condition_set();
 //   // |url_matches| and |match_data| passed through from
 //   // ConditionSet::IsFulfilled.
 //   bool IsFulfilled(
 //       const std::set<URLMatcherConditionSet::ID>& url_matches,
 //       const ConditionT::MatchData&);
 template<typename ConditionT>
 class DeclarativeConditionSet {
  public:
-  typedef std::vector<linked_ptr<json_schema_compiler::any::Any> > AnyVector;
+  typedef std::vector<linked_ptr<base::Value> > AnyVector;
   typedef std::vector<linked_ptr<const ConditionT> > Conditions;
   typedef typename Conditions::const_iterator const_iterator;
 
   // Factory method that creates an WebRequestConditionSet according to the JSON
   // array |conditions| passed by the extension API.
   // Sets |error| and returns NULL in case of an error.
   static scoped_ptr<DeclarativeConditionSet> Create(
       URLMatcherConditionFactory* url_matcher_condition_factory,
       const AnyVector& conditions,
       std::string* error);
@@ skipping 73 matching lines @@
 //   // Return the minimum priority of rules that can be evaluated after this
 //   // action runs.  Return MIN_INT by default.
 //   int GetMinimumPriority() const;
 //
 // TODO(battre): As DeclarativeActionSet can become the single owner of all
 // actions, we can optimize here by making some of them singletons (e.g. Cancel
 // actions).
 template<typename ActionT>
 class DeclarativeActionSet {
  public:
-  typedef std::vector<linked_ptr<json_schema_compiler::any::Any> > AnyVector;
+  typedef std::vector<linked_ptr<base::Value> > AnyVector;
   typedef std::vector<linked_ptr<const ActionT> > Actions;
 
   explicit DeclarativeActionSet(const Actions& actions);
 
   // Factory method that instantiates a DeclarativeActionSet according to
   // |actions| which represents the array of actions received from the
   // extension API.
   static scoped_ptr<DeclarativeActionSet> Create(const AnyVector& actions,
                                                  std::string* error,
                                                  bool* bad_message);
@@ skipping 139 matching lines @@
 DeclarativeConditionSet<ConditionT>::Create(
     URLMatcherConditionFactory* url_matcher_condition_factory,
     const AnyVector& conditions,
     std::string* error) {
   Conditions result;
 
   for (AnyVector::const_iterator i = conditions.begin();
        i != conditions.end(); ++i) {
     CHECK(i->get());
     scoped_ptr<ConditionT> condition =
-        ConditionT::Create(url_matcher_condition_factory,
-                           (*i)->value(), error);
+        ConditionT::Create(url_matcher_condition_factory, **i, error);
     if (!error->empty())
       return scoped_ptr<DeclarativeConditionSet>(NULL);
     result.push_back(make_linked_ptr(condition.release()));
   }
 
   URLMatcherIdToCondition match_id_to_condition;
   std::vector<const ConditionT*> conditions_without_urls;
   URLMatcherConditionSet::Vector condition_sets;
 
   for (typename Conditions::const_iterator i = result.begin();
@@ skipping 38 matching lines @@
     const AnyVector& actions,
     std::string* error,
     bool* bad_message) {
   *error = "";
   *bad_message = false;
   Actions result;
 
   for (AnyVector::const_iterator i = actions.begin();
        i != actions.end(); ++i) {
     CHECK(i->get());
-    scoped_ptr<ActionT> action =
-        ActionT::Create((*i)->value(), error, bad_message);
+    scoped_ptr<ActionT> action = ActionT::Create(**i, error, bad_message);
     if (!error->empty() || *bad_message)
       return scoped_ptr<DeclarativeActionSet>(NULL);
     result.push_back(make_linked_ptr(action.release()));
   }
 
   return scoped_ptr<DeclarativeActionSet>(new DeclarativeActionSet(result));
 }
 
 template<typename ActionT>
 void DeclarativeActionSet<ActionT>::Apply(
@@ skipping 101 matching lines @@
 }
 
 template<typename ConditionT, typename ActionT>
 int DeclarativeRule<ConditionT, ActionT>::GetMinimumPriority() const {
   return actions_->GetMinimumPriority();
 }
 
 }  // namespace extensions
 
 #endif  // CHROME_BROWSER_EXTENSIONS_API_DECLARATIVE_DECLARATIVE_RULE_H__