Declarative Web Request: firstPartyForCookiesUrl

chrome/browser/extensions/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 "chrome/browser/extensions/api/declarative/declarative_rule.h"
 
+#include "base/basictypes.h"
 #include "base/message_loop.h"
 #include "base/test/values_test_util.h"
 #include "base/values.h"
 #include "chrome/common/extensions/matcher/url_matcher_constants.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace extensions {
 
 using base::test::ParseJson;
 
 namespace {
 
 template<typename T>
 linked_ptr<T> ScopedToLinkedPtr(scoped_ptr<T> ptr) {
   return linked_ptr<T>(ptr.release());
 }
 
 }  // namespace
 
+struct MultipleFactoriesCondition {

[vabr (Chromium), 2013/01/22 08:34:53]

I don't think that the layout of this struct conforms to the style guide, but it
is consistent with other similar structs in this file (including the missing
DISALLOW_COP_AND_ASSIGN). Let me know if you want me to change it.

+  typedef int MatchData;
+
+  static const char* kKey;
+
+  int number_of_factories_to_consider;
+
+  int GetURLMatcherConditionSets(
+      URLMatcherConditionSet::Vector* /*condition_sets*/,
+      int index) const {
+    if (0 <= index && index < number_of_factories_to_consider)
+      return index + 1;
+    return -1;
+  }
+
+  static scoped_ptr<MultipleFactoriesCondition> Create(
+      const std::vector<URLMatcherConditionFactory*>& /*factories*/,
+      const base::Value& condition,
+      std::string* error) {
+    const base::DictionaryValue* dict = NULL;
+    int value;
+    if (!condition.GetAsDictionary(&dict) || !dict->HasKey(kKey) ||
+        !dict->GetInteger(kKey, &value)) {
+      *error = "Invalid condition description.";
+      return scoped_ptr<MultipleFactoriesCondition>();
+    }
+
+    scoped_ptr<MultipleFactoriesCondition> result(
+        new MultipleFactoriesCondition());
+    result->number_of_factories_to_consider = value;
+    return result.Pass();
+  }
+};
+const char* MultipleFactoriesCondition::kKey = "numberOfFactoriesToConsider";
+typedef DeclarativeConditionSet<MultipleFactoriesCondition>
+    MultipleFactoriesConditionSet;
+
+namespace {
+
+void TestCorrectIndexHandling(int number_of_factories) {
+  MultipleFactoriesConditionSet::AnyVector conditions;
+  for (int i = 0; i <= number_of_factories; ++i) {
+    scoped_ptr<DictionaryValue> dict(new DictionaryValue);
+    dict->SetInteger(MultipleFactoriesCondition::kKey, i);
+    conditions.push_back(ScopedToLinkedPtr(dict.Pass()));
+  }
+  std::string error;
+  std::vector<URLMatcherConditionFactory*> null_factories(number_of_factories);
+  scoped_ptr<MultipleFactoriesConditionSet> result =
+      MultipleFactoriesConditionSet::Create(null_factories, conditions, &error);
+  EXPECT_TRUE(error.empty());
+  ASSERT_TRUE(result);
+
+  for (int i = 0; i < number_of_factories; ++i) {
+    EXPECT_EQ(i + 1, result->GetURLMatcherConditionSets(NULL, i));
+  }
+  EXPECT_EQ(-1, result->GetURLMatcherConditionSets(NULL, number_of_factories));
+}
+
+}  // namespace
+
+TEST(DeclarativeConditionTest, GetURLMatcherConditionSets) {
+  static const int numbers_of_factories[] = { 0, 1, 2, 5, 20 };
+  for (size_t i = 0; i < arraysize(numbers_of_factories); ++i) {
+    TestCorrectIndexHandling(numbers_of_factories[i]);
+  }
+}
+
 struct RecordingCondition {
   typedef int MatchData;
 
-  URLMatcherConditionFactory* factory;
+  std::vector<URLMatcherConditionFactory*> factories;
   scoped_ptr<base::Value> value;
 
-  void GetURLMatcherConditionSets(
-      URLMatcherConditionSet::Vector* condition_sets) const {
+  int GetURLMatcherConditionSets(
+      URLMatcherConditionSet::Vector* condition_sets,
+      int index) const {
     // No condition sets.
-  }
-
-  bool has_url_matcher_condition_set() const {
-    return false;
+    return -1;
   }
 
   static scoped_ptr<RecordingCondition> Create(
-      URLMatcherConditionFactory* url_matcher_condition_factory,
+      const std::vector<URLMatcherConditionFactory*>&
+          url_matcher_condition_factories,
       const base::Value& condition,
       std::string* error) {
     const base::DictionaryValue* dict = NULL;
     if (condition.GetAsDictionary(&dict) && dict->HasKey("bad_key")) {
       *error = "Found error key";
       return scoped_ptr<RecordingCondition>();
     }
 
     scoped_ptr<RecordingCondition> result(new RecordingCondition());
-    result->factory = url_matcher_condition_factory;
+    result->factories = url_matcher_condition_factories;
     result->value.reset(condition.DeepCopy());
     return result.Pass();
   }
 };
 typedef DeclarativeConditionSet<RecordingCondition> RecordingConditionSet;
 
 TEST(DeclarativeConditionTest, ErrorConditionSet) {
   URLMatcher matcher;
   RecordingConditionSet::AnyVector conditions;
   conditions.push_back(ScopedToLinkedPtr(ParseJson("{\"key\": 1}")));
   conditions.push_back(ScopedToLinkedPtr(ParseJson("{\"bad_key\": 2}")));
 
   std::string error;
+  std::vector<URLMatcherConditionFactory*> factories;
+  factories.push_back(matcher.condition_factory());
   scoped_ptr<RecordingConditionSet> result =
-      RecordingConditionSet::Create(matcher.condition_factory(),
-                                    conditions, &error);
+      RecordingConditionSet::Create(factories, conditions, &error);
   EXPECT_EQ("Found error key", error);
   ASSERT_FALSE(result);
 }
 
 TEST(DeclarativeConditionTest, CreateConditionSet) {
   URLMatcher matcher;
   RecordingConditionSet::AnyVector conditions;
   conditions.push_back(ScopedToLinkedPtr(ParseJson("{\"key\": 1}")));
   conditions.push_back(ScopedToLinkedPtr(ParseJson("[\"val1\", 2]")));
 
   // Test insertion
   std::string error;
+  std::vector<URLMatcherConditionFactory*> factories;
+  factories.push_back(matcher.condition_factory());
   scoped_ptr<RecordingConditionSet> result =
-      RecordingConditionSet::Create(matcher.condition_factory(),
-                                    conditions, &error);
+      RecordingConditionSet::Create(factories, conditions, &error);
   EXPECT_EQ("", error);
   ASSERT_TRUE(result);
   EXPECT_EQ(2u, result->conditions().size());
 
-  EXPECT_EQ(matcher.condition_factory(), result->conditions()[0]->factory);
+  EXPECT_EQ(1u, result->conditions()[0]->factories.size());
+  EXPECT_EQ(matcher.condition_factory(), result->conditions()[0]->factories[0]);
   EXPECT_TRUE(ParseJson("{\"key\": 1}")->Equals(
       result->conditions()[0]->value.get()));
 }
 
 struct FulfillableCondition {
   typedef int MatchData;
 
   scoped_refptr<URLMatcherConditionSet> condition_set;
   int condition_set_id;
   int max_value;
 
   URLMatcherConditionSet::ID url_matcher_condition_set_id() const {
     return condition_set_id;
   }
 
-  bool has_url_matcher_condition_set() const {
-    return true;
-  }
-
   scoped_refptr<URLMatcherConditionSet> url_matcher_condition_set() const {
     return condition_set;
   }
 
-  void GetURLMatcherConditionSets(
-      URLMatcherConditionSet::Vector* condition_sets) const {
-    if (condition_set)
+  int GetURLMatcherConditionSets(
+      URLMatcherConditionSet::Vector* condition_sets,
+      int index) const {
+    if (index == 0 && condition_set)
       condition_sets->push_back(condition_set);
+    return -1;
   }
 
   bool IsFulfilled(const std::set<URLMatcherConditionSet::ID>& url_matches,
                    int match_data) const {
     if (condition_set_id != -1 && !ContainsKey(url_matches, condition_set_id))
       return false;
     return match_data <= max_value;
   }
 
   static scoped_ptr<FulfillableCondition> Create(
-      URLMatcherConditionFactory* url_matcher_condition_factory,
+      const std::vector<URLMatcherConditionFactory*>&
+          url_matcher_condition_factories,
       const base::Value& condition,
       std::string* error) {
     scoped_ptr<FulfillableCondition> result(new FulfillableCondition());
     const base::DictionaryValue* dict;
     if (!condition.GetAsDictionary(&dict)) {
       *error = "Expected dict";
       return result.Pass();
     }
     if (!dict->GetInteger("url_id", &result->condition_set_id))
       result->condition_set_id = -1;
@@ skipping 15 matching lines @@
       "{\"url_id\": 1, \"max\": 3}")));
   conditions.push_back(ScopedToLinkedPtr(ParseJson(
       "{\"url_id\": 2, \"max\": 5}")));
   conditions.push_back(ScopedToLinkedPtr(ParseJson(
       "{\"url_id\": 3, \"max\": 1}")));
   conditions.push_back(ScopedToLinkedPtr(ParseJson(
       "{\"max\": -5}")));  // No url.
 
   // Test insertion
   std::string error;
+  std::vector<URLMatcherConditionFactory*> factories;
   scoped_ptr<FulfillableConditionSet> result =
-      FulfillableConditionSet::Create(NULL, conditions, &error);
+      FulfillableConditionSet::Create(factories, conditions, &error);
   ASSERT_EQ("", error);
   ASSERT_TRUE(result);
   EXPECT_EQ(4u, result->conditions().size());
 
   std::set<URLMatcherConditionSet::ID> url_matches;
   EXPECT_FALSE(result->IsFulfilled(1, url_matches, 0))
       << "Testing an ID that's not in url_matches forwards to the Condition, "
       << "which doesn't match.";
   EXPECT_FALSE(result->IsFulfilled(-1, url_matches, 0))
       << "Testing the 'no ID' value tries to match the 4th condition, but "
       << "its max is too low.";
   EXPECT_TRUE(result->IsFulfilled(-1, url_matches, -5))
       << "Testing the 'no ID' value tries to match the 4th condition, and "
       << "this value is low enough.";
 
   url_matches.insert(1);
   EXPECT_TRUE(result->IsFulfilled(1, url_matches, 3))
       << "Tests a condition with a url matcher, for a matching value.";
   EXPECT_FALSE(result->IsFulfilled(1, url_matches, 4))
       << "Tests a condition with a url matcher, for a non-matching value "
       << "that would match a different condition.";
   url_matches.insert(2);
   EXPECT_TRUE(result->IsFulfilled(2, url_matches, 4))
       << "Tests with 2 elements in the match set.";
 
   // Check the condition sets:
   URLMatcherConditionSet::Vector condition_sets;
-  result->GetURLMatcherConditionSets(&condition_sets);
+  result->GetURLMatcherConditionSets(&condition_sets, 0);
   ASSERT_EQ(3U, condition_sets.size());
   EXPECT_EQ(1, condition_sets[0]->id());
   EXPECT_EQ(2, condition_sets[1]->id());
   EXPECT_EQ(3, condition_sets[2]->id());
 }
 
 // DeclarativeAction
 
 struct SummingAction {
   typedef int ApplyInfo;
@@ skipping 95 matching lines @@
                  "  ], \n"
                  "  \"priority\": 200 \n"
                  "}"),
       json_rule.get()));
 
   const char kExtensionId[] = "ext1";
 
   base::Time install_time = base::Time::Now();
 
   URLMatcher matcher;
+  std::vector<URLMatcherConditionFactory*> factories;
+  factories.push_back(matcher.condition_factory());
   std::string error;
-  scoped_ptr<Rule> rule(Rule::Create(matcher.condition_factory(), kExtensionId,
+  scoped_ptr<Rule> rule(Rule::Create(factories, kExtensionId,
                                      install_time, json_rule, NULL, &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();
@@ skipping 23 matching lines @@
   }
   return true;
 }
 
 TEST(DeclarativeRuleTest, CheckConsistency) {
   typedef DeclarativeRule<FulfillableCondition, SummingAction> Rule;
   URLMatcher matcher;
   std::string error;
   linked_ptr<Rule::JsonRule> json_rule(new Rule::JsonRule);
   const char kExtensionId[] = "ext1";
+  std::vector<URLMatcherConditionFactory*> factories;
+  factories.push_back(matcher.condition_factory());
 
   ASSERT_TRUE(Rule::JsonRule::Populate(
       *ParseJson("{ \n"
                  "  \"id\": \"rule1\", \n"
                  "  \"conditions\": [ \n"
                  "    {\"url_id\": 1, \"max\": 3}, \n"
                  "    {\"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(), kExtensionId, base::Time(),
-                   json_rule, &AtLeastOneCondition, &error));
+  scoped_ptr<Rule> rule(Rule::Create(factories, kExtensionId, base::Time(),
+                                     json_rule, &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(), kExtensionId, base::Time(),
+  rule = Rule::Create(factories, kExtensionId, base::Time(),
                       json_rule, &AtLeastOneCondition, &error);
   EXPECT_FALSE(rule);
   EXPECT_EQ("No conditions", error);
 }
 
 }  // namespace extensions