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

extensions/browser/api/declarative/declarative_rule_unittest.cc

 // 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.
 
 #include "extensions/browser/api/declarative/declarative_rule.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/test/values_test_util.h"
 #include "base/values.h"
@@ skipping 201 matching lines @@
 
 class SummingAction : public base::RefCounted<SummingAction> {
  public:
   typedef int ApplyInfo;
 
   SummingAction(int increment, int min_priority)
       : increment_(increment), min_priority_(min_priority) {}
 
   static scoped_refptr<const SummingAction> Create(
       content::BrowserContext* browser_context,
+      const HostID& host_id,
       const Extension* extension,
       const base::Value& action,
       std::string* error,
       bool* bad_message) {
     int increment = 0;
     int min_priority = 0;
     const base::DictionaryValue* dict = NULL;
     EXPECT_TRUE(action.GetAsDictionary(&dict));
     if (dict->HasKey("error")) {
       EXPECT_TRUE(dict->GetString("error", error));
@@ skipping 31 matching lines @@
 typedef DeclarativeActionSet<SummingAction> SummingActionSet;
 
 TEST(DeclarativeActionTest, ErrorActionSet) {
   SummingActionSet::AnyVector actions;
   actions.push_back(ScopedToLinkedPtr(ParseJson("{\"value\": 1}")));
   actions.push_back(ScopedToLinkedPtr(ParseJson("{\"error\": \"the error\"}")));
 
   std::string error;
   bool bad = false;
   scoped_ptr<SummingActionSet> result =
-      SummingActionSet::Create(NULL, NULL, actions, &error, &bad);
+      SummingActionSet::Create(NULL, HostID(), NULL, actions, &error, &bad);
   EXPECT_EQ("the error", error);
   EXPECT_FALSE(bad);
   EXPECT_FALSE(result);
 
   actions.clear();
   actions.push_back(ScopedToLinkedPtr(ParseJson("{\"value\": 1}")));
   actions.push_back(ScopedToLinkedPtr(ParseJson("{\"bad\": 3}")));
-  result = SummingActionSet::Create(NULL, NULL, actions, &error, &bad);
+  result = SummingActionSet::Create(
+      NULL, HostID(), NULL, actions, &error, &bad);
   EXPECT_EQ("", error);
   EXPECT_TRUE(bad);
   EXPECT_FALSE(result);
 }
 
 TEST(DeclarativeActionTest, ApplyActionSet) {
   SummingActionSet::AnyVector actions;
   actions.push_back(ScopedToLinkedPtr(ParseJson(
       "{\"value\": 1,"
       " \"priority\": 5}")));
   actions.push_back(ScopedToLinkedPtr(ParseJson("{\"value\": 2}")));
 
   // Test insertion
   std::string error;
   bool bad = false;
   scoped_ptr<SummingActionSet> result =
-      SummingActionSet::Create(NULL, NULL, actions, &error, &bad);
+      SummingActionSet::Create(NULL, HostID(), NULL, actions, &error, &bad);
   EXPECT_EQ("", error);
   EXPECT_FALSE(bad);
   ASSERT_TRUE(result);
   EXPECT_EQ(2u, result->actions().size());
 
   int sum = 0;
   result->Apply("ext_id", base::Time(), &sum);
   EXPECT_EQ(3, sum);
   EXPECT_EQ(5, result->GetMinimumPriority());
 }
@@ skipping 20 matching lines @@
   const char kExtensionId[] = "ext1";
   scoped_refptr<Extension> extension = ExtensionBuilder()
                                            .SetManifest(SimpleManifest())
                                            .SetID(kExtensionId)
                                            .Build();
 
   base::Time install_time = base::Time::Now();
 
   URLMatcher matcher;
   std::string error;
-  scoped_ptr<Rule> rule(Rule::Create(matcher.condition_factory(),
-                                     NULL,
-                                     extension.get(),
-                                     install_time,
-                                     json_rule,
-                                     Rule::ConsistencyChecker(),
-                                     &error));
+  scoped_ptr<Rule> rule(
+      Rule::Create(matcher.condition_factory(),
+                   NULL,
+                   HostID(HostID::EXTENSIONS, extension.get()->id()),
+                   extension.get(),
+                   install_time,
+                   json_rule,
+                   Rule::ConsistencyChecker(),
+                   &error));
   EXPECT_EQ("", error);
   ASSERT_TRUE(rule.get());
 
   EXPECT_EQ(kExtensionId, rule->id().first);
   EXPECT_EQ("rule1", rule->id().second);
 
   EXPECT_EQ(200, rule->priority());
 
   const Rule::ConditionSet& condition_set = rule->conditions();
   const Rule::ConditionSet::Conditions& conditions =
@@ skipping 42 matching lines @@
                  "    {\"url_id\": 2, \"max\": 5}, \n"
                  "  ], \n"
                  "  \"actions\": [ \n"
                  "    { \n"
                  "      \"value\": 2 \n"
                  "    } \n"
                  "  ], \n"
                  "  \"priority\": 200 \n"
                  "}"),
       json_rule.get()));
-  scoped_ptr<Rule> rule(Rule::Create(matcher.condition_factory(),
-                                     NULL,
-                                     extension.get(),
-                                     base::Time(),
-                                     json_rule,
-                                     base::Bind(AtLeastOneCondition),
-                                     &error));
+  scoped_ptr<Rule> rule(
+      Rule::Create(matcher.condition_factory(),
+                   NULL,
+                   HostID(HostID::EXTENSIONS, extension.get()->id()),
+                   extension.get(),
+                   base::Time(),
+                   json_rule,
+                   base::Bind(AtLeastOneCondition),
+                   &error));
   EXPECT_TRUE(rule);
   EXPECT_EQ("", error);
 
   ASSERT_TRUE(Rule::JsonRule::Populate(
       *ParseJson("{ \n"
                  "  \"id\": \"rule1\", \n"
                  "  \"conditions\": [ \n"
                  "  ], \n"
                  "  \"actions\": [ \n"
                  "    { \n"
                  "      \"value\": 2 \n"
                  "    } \n"
                  "  ], \n"
                  "  \"priority\": 200 \n"
                  "}"),
       json_rule.get()));
   rule = Rule::Create(matcher.condition_factory(),
                       NULL,
+                      HostID(HostID::EXTENSIONS, extension.get()->id()),
                       extension.get(),
                       base::Time(),
                       json_rule,
                       base::Bind(AtLeastOneCondition),
                       &error);
   EXPECT_FALSE(rule);
   EXPECT_EQ("No conditions", error);
 }
 
 }  // namespace extensions