Revert of Revert of Introduce HostID and de-couple Extensions from "script injection System" [browser side]

extensions/browser/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 EXTENSIONS_BROWSER_API_DECLARATIVE_DECLARATIVE_RULE_H__
 #define EXTENSIONS_BROWSER_API_DECLARATIVE_DECLARATIVE_RULE_H__
 
 #include <limits>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/stl_util.h"
 #include "base/time/time.h"
 #include "components/url_matcher/url_matcher.h"
 #include "extensions/common/api/events.h"
 #include "extensions/common/extension.h"
+#include "extensions/common/host_id.h"
 
 namespace base {
 class Time;
 class Value;
 }
 
 namespace content {
 class BrowserContext;
 }
 
@@ skipping 109 matching lines @@
   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(
       content::BrowserContext* browser_context,
+      const HostID& host_id,
       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;
 
@@ skipping 58 matching lines @@
   // 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,
       content::BrowserContext* browser_context,
+      const HostID& host_id,
       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 116 matching lines @@
 
 template<typename ActionT>
 DeclarativeActionSet<ActionT>::DeclarativeActionSet(const Actions& actions)
     : actions_(actions) {}
 
 // static
 template<typename ActionT>
 scoped_ptr<DeclarativeActionSet<ActionT> >
 DeclarativeActionSet<ActionT>::Create(
     content::BrowserContext* browser_context,
+    const HostID& host_id,
     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(browser_context, extension, **i, error, bad_message);
+        ActionT::Create(
+            browser_context, host_id, 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(
@@ skipping 56 matching lines @@
   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,
     content::BrowserContext* browser_context,
+    const HostID& host_id,
     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(
-          browser_context, extension, rule->actions, error, &bad_message);
+      ActionSet::Create(browser_context, host_id, 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  // EXTENSIONS_BROWSER_API_DECLARATIVE_DECLARATIVE_RULE_H__