Create DeclarativeConditionSet, DeclarativeActionSet, and DeclarativeRule templates

chrome/browser/extensions/api/declarative_webrequest/webrequest_condition_unittest.cc

 // Copyright (c) 2012 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_webrequest/webrequest_condition.h"
 
 #include <set>
 
 #include "base/message_loop.h"
 #include "base/test/values_test_util.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/declarative_webrequest/webrequest_constants.h"
-#include "chrome/browser/extensions/api/declarative_webrequest/webrequest_rule.h"
 #include "chrome/common/extensions/matcher/url_matcher_constants.h"
 #include "content/public/browser/resource_request_info.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace extensions {
 
 namespace keys = declarative_webrequest_constants;
 namespace keys2 = url_matcher_constants;
 
@@ skipping 41 matching lines @@
           "  \"url\": { \"hostSuffix\": \"example.com\" }, \n"
           "  \"instanceType\": \"declarativeWebRequest.RequestMatcher\", \n"
           "}"),
       &error);
   EXPECT_EQ("", error);
   ASSERT_TRUE(result.get());
 
   net::TestURLRequestContext context;
   net::TestURLRequest match_request(
       GURL("http://www.example.com"), NULL, &context);
+  URLMatcherConditionSet::Vector condition_sets;
+  result->GetURLMatcherConditionSets(&condition_sets);
+  ASSERT_EQ(1U, condition_sets.size());
   std::set<URLMatcherConditionSet::ID> url_matches;
-  url_matches.insert(result->url_matcher_condition_set_id());
+  url_matches.insert(condition_sets[0]->id());
 
   content::ResourceRequestInfo::AllocateForTesting(&match_request,
       ResourceType::MAIN_FRAME, NULL, -1, -1);
-  EXPECT_TRUE(result->IsFulfilled(
-      url_matches,
-      WebRequestRule::RequestData(&match_request, ON_BEFORE_REQUEST)));
+  DeclarativeWebRequestData request_data(&match_request, ON_BEFORE_REQUEST);
+  request_data.url_matches = &url_matches;
+  EXPECT_TRUE(result->IsFulfilled(request_data));
 
   net::TestURLRequest wrong_resource_type(
       GURL("https://www.example.com"), NULL, &context);
   content::ResourceRequestInfo::AllocateForTesting(&wrong_resource_type,
       ResourceType::SUB_FRAME, NULL, -1, -1);
-  EXPECT_FALSE(result->IsFulfilled(
-      url_matches,
-      WebRequestRule::RequestData(&wrong_resource_type, ON_BEFORE_REQUEST)));
+  request_data.request = &wrong_resource_type;
+  EXPECT_FALSE(result->IsFulfilled(request_data));
 }
 
 // The IsFulfilledIndependentlyOfURL method tests that a condition has no
 // UrlFilter attributes, and all its (non-UrlFilter) attributes are satisfied.
 // We test here that:
 //   1. A non-empty condition without UrlFilter attributes is fulfilled iff its
 //      attributes are fulfilled.
 //   2. An empty condition (in particular, without UrlFilter attributes) is
 //      always fulfilled.
 //   3. A condition with a UrlFilter and a non-UrlFilter attribute is never
@@ skipping 81 matching lines @@
           "  \"thirdPartyForCookies\": false, \n"
           "}"),
       &error);
   EXPECT_EQ("", error);
   ASSERT_TRUE(condition_both.get());
 #undef MATCHING_URL_FILTER
 
   net::TestURLRequestContext context;
   net::TestURLRequest https_request(GURL(kUrl), NULL, &context);
   std::set<URLMatcherConditionSet::ID> empty_url_matches;
+  DeclarativeWebRequestData request_data(NULL, ON_BEFORE_REQUEST);
+  request_data.url_matches = &empty_url_matches;

[Jeffrey Yasskin, 2012/12/19 08:23:06]

These assignments into request_data are somewhat awful. I'd like to try to clean
them up after Vaclav's second CL is in so we know what the extra data looks like
and can design good constructors.

[Jeffrey Yasskin, 2012/12/20 01:27:35]

And I've reverted them since ConditionSet needed to be aware of url_matches
anyway. Vaclav will need to put them back for his first-party-url change, but
I'll let him figure out the readable way to do that. :)

 
   // 1. A non-empty condition without UrlFilter attributes is fulfilled iff its
   //    attributes are fulfilled.
-  EXPECT_FALSE(condition_no_url_false->IsFulfilled(
-      empty_url_matches,
-      WebRequestRule::RequestData(&https_request, ON_BEFORE_REQUEST)));
+  request_data.request = &https_request;
+  EXPECT_FALSE(condition_no_url_false->IsFulfilled(request_data));
 
-  EXPECT_TRUE(condition_no_url_true->IsFulfilled(
-      empty_url_matches,
-      WebRequestRule::RequestData(&https_request, ON_BEFORE_REQUEST)));
+  EXPECT_TRUE(condition_no_url_true->IsFulfilled(request_data));
 
   // 2. An empty condition (in particular, without UrlFilter attributes) is
   //    always fulfilled.
-  EXPECT_TRUE(condition_empty->IsFulfilled(
-      empty_url_matches,
-      WebRequestRule::RequestData(&https_request, ON_BEFORE_REQUEST)));
+  EXPECT_TRUE(condition_empty->IsFulfilled(request_data));
 
   // 3. A condition with a UrlFilter and a non-UrlFilter attribute is never
   //    fulfilled.
-  EXPECT_FALSE(condition_both->IsFulfilled(
-      empty_url_matches,
-      WebRequestRule::RequestData(&https_request, ON_BEFORE_REQUEST)));
+  EXPECT_FALSE(condition_both->IsFulfilled(request_data));
 
   // 4. A condition with only a UrlFilter attribute is never fulfilled.
-  EXPECT_FALSE(condition_url->IsFulfilled(
-      empty_url_matches,
-      WebRequestRule::RequestData(&https_request, ON_BEFORE_REQUEST)));
+  EXPECT_FALSE(condition_url->IsFulfilled(request_data));
 }
 
 TEST(WebRequestConditionTest, CreateConditionSet) {
   // Necessary for TestURLRequest.
   MessageLoop message_loop(MessageLoop::TYPE_IO);
   URLMatcher matcher;
 
   WebRequestConditionSet::AnyVector conditions;
 
   linked_ptr<json_schema_compiler::any::Any> condition1 = make_linked_ptr(
@@ skipping 36 matching lines @@
   matcher.AddConditionSets(url_matcher_condition_set);
 
   std::set<URLMatcherConditionSet::ID> url_match_ids;
 
   // Test that the result is correct and matches http://www.example.com and
   // https://www.example.com
   GURL http_url("http://www.example.com");
   net::TestURLRequestContext context;
   net::TestURLRequest http_request(http_url, NULL, &context);
   url_match_ids = matcher.MatchURL(http_url);
-  EXPECT_TRUE(result->IsFulfilled(
-      url_match_ids,
-      WebRequestRule::RequestData(&http_request, ON_BEFORE_REQUEST)));
+  DeclarativeWebRequestData request_data(NULL, ON_BEFORE_REQUEST);
+
+  request_data.request = &http_request;
+  request_data.url_matches = &url_match_ids;
+  EXPECT_TRUE(result->IsFulfilled(request_data));
 
   GURL https_url("https://www.example.com");
   url_match_ids = matcher.MatchURL(https_url);
   net::TestURLRequest https_request(https_url, NULL, &context);
-  EXPECT_TRUE(result->IsFulfilled(
-      url_match_ids,
-      WebRequestRule::RequestData(&https_request, ON_BEFORE_REQUEST)));
+  request_data.request = &https_request;
+  request_data.url_matches = &url_match_ids;
+  EXPECT_TRUE(result->IsFulfilled(request_data));
 
   // Check that both, hostPrefix and hostSuffix are evaluated.
   GURL https_foo_url("https://foo.example.com");
   url_match_ids = matcher.MatchURL(https_foo_url);
   net::TestURLRequest https_foo_request(https_foo_url, NULL, &context);
-  EXPECT_FALSE(result->IsFulfilled(
-      url_match_ids,
-      WebRequestRule::RequestData(&https_foo_request, ON_BEFORE_REQUEST)));
+  request_data.request = &https_foo_request;
+  request_data.url_matches = &url_match_ids;
+  EXPECT_FALSE(result->IsFulfilled(request_data));
 }
 
 TEST(WebRequestConditionTest, TestPortFilter) {
   // Necessary for TestURLRequest.
   MessageLoop message_loop(MessageLoop::TYPE_IO);
   URLMatcher matcher;
 
   linked_ptr<json_schema_compiler::any::Any> any_condition =
       make_linked_ptr(new json_schema_compiler::any::Any);
   any_condition->Init(*base::test::ParseJson(
@@ skipping 72 matching lines @@
           // filters.
           "  \"requestHeaders\": [{}], \n"
           "  \"responseHeaders\": [{}], \n"
           "}"),
       &error);
   EXPECT_FALSE(error.empty());
   EXPECT_FALSE(result.get());
 }
 
 }  // namespace extensions