Browser changes for wiring up RequestContentScript API to shared memory

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__
@@ skipping 11 matching lines @@
 #include "base/time/time.h"
 #include "chrome/common/extensions/api/events.h"
 #include "components/url_matcher/url_matcher.h"
 #include "extensions/common/extension.h"
 
 namespace base {
 class Time;
 class Value;
 }
 
+class Profile;
+
 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:
 //
 //   // Arguments passed through from DeclarativeConditionSet::Create.
@@ skipping 97 matching lines @@
 class DeclarativeActionSet {
  public:
   typedef std::vector<linked_ptr<base::Value> > AnyVector;
   typedef std::vector<scoped_refptr<const ActionT> > Actions;
 
   explicit DeclarativeActionSet(const Actions& actions);
 
   // Factory method that instantiates a DeclarativeActionSet for |extension|
   // according to |actions| which represents the array of actions received from
   // the extension API.
-  static scoped_ptr<DeclarativeActionSet> Create(const Extension* extension,
+  static scoped_ptr<DeclarativeActionSet> Create(Profile* profile,
+                                                 const Extension* extension,
                                                  const AnyVector& actions,
                                                  std::string* error,
                                                  bool* bad_message);
 
   // Rules call this method when their conditions are fulfilled.
   void Apply(const std::string& extension_id,
              const base::Time& extension_install_time,
              typename ActionT::ApplyInfo* apply_info) const;
 
   // Rules call this method when they have stateful conditions, and those
   // conditions stop being fulfilled.  Rules with event-based conditions (e.g. a
   // network request happened) will never Revert() an action.
   void Revert(const std::string& extension_id,
               const base::Time& extension_install_time,
               typename ActionT::ApplyInfo* apply_info) const;
 
+  // Rules call this method when their conditions are checked and were already
+  // fulfilled previously.
+  void Reapply(const std::string& extension_id,
+               const base::Time& extension_install_time,
+               typename ActionT::ApplyInfo* apply_info) const;
+
   // Returns the minimum priority of rules that may be evaluated after
   // this rule. Defaults to MIN_INT.
   int GetMinimumPriority() const;
 
   const Actions& actions() const { return actions_; }
 
  private:
   const Actions actions_;
 
   DISALLOW_COPY_AND_ASSIGN(DeclarativeActionSet);
@@ skipping 34 matching lines @@
   // Creates a DeclarativeRule for |extension| given a json definition.  The
   // format of each condition and action's json is up to the specific ConditionT
   // and ActionT.  |extension| may be NULL in tests.
   //
   // Before constructing the final rule, calls check_consistency(conditions,
   // actions, error) and returns NULL if it fails.  Pass NULL if no consistency
   // check is needed.  If |error| is empty, the translation was successful and
   // the returned rule is internally consistent.
   static scoped_ptr<DeclarativeRule> Create(
       url_matcher::URLMatcherConditionFactory* url_matcher_condition_factory,
+      Profile* profile,
       const Extension* extension,
       base::Time extension_installation_time,
       linked_ptr<JsonRule> rule,
       ConsistencyChecker check_consistency,
       std::string* error);
 
   const GlobalRuleId& id() const { return id_; }
   const Tags& tags() const { return tags_; }
   const std::string& extension_id() const { return id_.first; }
   const ConditionSet& conditions() const { return *conditions_; }
@@ skipping 115 matching lines @@
 //
 
 template<typename ActionT>
 DeclarativeActionSet<ActionT>::DeclarativeActionSet(const Actions& actions)
     : actions_(actions) {}
 
 // static
 template<typename ActionT>
 scoped_ptr<DeclarativeActionSet<ActionT> >
 DeclarativeActionSet<ActionT>::Create(
+    Profile* profile,
     const Extension* extension,
     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_refptr<const ActionT> action =
-        ActionT::Create(extension, **i, error, bad_message);
+        ActionT::Create(profile, extension, **i, error, bad_message);
     if (!error->empty() || *bad_message)
       return scoped_ptr<DeclarativeActionSet>();
     result.push_back(action);
   }
 
   return scoped_ptr<DeclarativeActionSet>(new DeclarativeActionSet(result));
 }
 
 template<typename ActionT>
 void DeclarativeActionSet<ActionT>::Apply(
     const std::string& extension_id,
     const base::Time& extension_install_time,
     typename ActionT::ApplyInfo* apply_info) const {
   for (typename Actions::const_iterator i = actions_.begin();
        i != actions_.end(); ++i)
     (*i)->Apply(extension_id, extension_install_time, apply_info);
 }
 
 template<typename ActionT>
 void DeclarativeActionSet<ActionT>::Revert(
     const std::string& extension_id,
     const base::Time& extension_install_time,
     typename ActionT::ApplyInfo* apply_info) const {
   for (typename Actions::const_iterator i = actions_.begin();
        i != actions_.end(); ++i)
     (*i)->Revert(extension_id, extension_install_time, apply_info);
 }
 
 template<typename ActionT>
+void DeclarativeActionSet<ActionT>::Reapply(
+    const std::string& extension_id,
+    const base::Time& extension_install_time,
+    typename ActionT::ApplyInfo* apply_info) const {
+  for (typename Actions::const_iterator i = actions_.begin();
+       i != actions_.end(); ++i)
+    (*i)->Reapply(extension_id, extension_install_time, apply_info);
+}
+
+template<typename ActionT>
 int DeclarativeActionSet<ActionT>::GetMinimumPriority() const {
   int minimum_priority = std::numeric_limits<int>::min();
   for (typename Actions::const_iterator i = actions_.begin();
        i != actions_.end(); ++i) {
     minimum_priority = std::max(minimum_priority, (*i)->minimum_priority());
   }
   return minimum_priority;
 }
 
 //
@@ skipping 16 matching lines @@
       priority_(priority) {
   CHECK(conditions_.get());
   CHECK(actions_.get());
 }
 
 // static
 template<typename ConditionT, typename ActionT>
 scoped_ptr<DeclarativeRule<ConditionT, ActionT> >
 DeclarativeRule<ConditionT, ActionT>::Create(
     url_matcher::URLMatcherConditionFactory* url_matcher_condition_factory,
+    Profile* profile,
     const Extension* extension,
     base::Time extension_installation_time,
     linked_ptr<JsonRule> rule,
     ConsistencyChecker check_consistency,
     std::string* error) {
   scoped_ptr<DeclarativeRule> error_result;
 
   scoped_ptr<ConditionSet> conditions = ConditionSet::Create(
       extension, url_matcher_condition_factory, rule->conditions, error);
   if (!error->empty())
     return error_result.Pass();
   CHECK(conditions.get());
 
   bool bad_message = false;
   scoped_ptr<ActionSet> actions =
-      ActionSet::Create(extension, rule->actions, error, &bad_message);
+      ActionSet::Create(profile, extension, rule->actions, error, &bad_message);
   if (bad_message) {
     // TODO(battre) Export concept of bad_message to caller, the extension
     // should be killed in case it is true.
     *error = "An action of a rule set had an invalid "
         "structure that should have been caught by the JSON validator.";
     return error_result.Pass();
   }
   if (!error->empty() || bad_message)
     return error_result.Pass();
   CHECK(actions.get());
@@ skipping 23 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__