Declarative Web Request: firstPartyForCookiesUrl

chrome/browser/extensions/api/declarative_webrequest/webrequest_rules_registry_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_rules_registry.h"
 
 #include <vector>
 
 #include "base/json/json_reader.h"
 #include "base/memory/linked_ptr.h"
@@ skipping 256 matching lines @@
 
   error = registry->AddRules(kExtensionId, rules);
   EXPECT_EQ("", error);
   EXPECT_EQ(1, registry->num_clear_cache_calls());
 
   std::set<const WebRequestRule*> matches;
 
   GURL http_url("http://www.example.com");
   net::TestURLRequestContext context;
   net::TestURLRequest http_request(http_url, NULL, &context);
-  matches = registry->GetMatches(
-      DeclarativeWebRequestData(&http_request, ON_BEFORE_REQUEST));
+  DeclarativeWebRequestData request_data(&http_request, ON_BEFORE_REQUEST);
+  matches = registry->GetMatches(&request_data);
   EXPECT_EQ(2u, matches.size());
 
   std::set<WebRequestRule::GlobalRuleId> matches_ids;
   for (std::set<const WebRequestRule*>::const_iterator it = matches.begin();
        it != matches.end(); ++it)
     matches_ids.insert((*it)->id());
   EXPECT_TRUE(ContainsKey(matches_ids, std::make_pair(kExtensionId, kRuleId1)));
   EXPECT_TRUE(ContainsKey(matches_ids, std::make_pair(kExtensionId, kRuleId2)));
 
   GURL foobar_url("http://www.foobar.com");
   net::TestURLRequest foobar_request(foobar_url, NULL, &context);
-  matches = registry->GetMatches(
-      DeclarativeWebRequestData(&foobar_request, ON_BEFORE_REQUEST));
+  request_data.request = &foobar_request;
+  matches = registry->GetMatches(&request_data);
   EXPECT_EQ(1u, matches.size());
   WebRequestRule::GlobalRuleId expected_pair =
       std::make_pair(kExtensionId, kRuleId2);
   EXPECT_EQ(expected_pair, (*matches.begin())->id());
 }
 
 TEST_F(WebRequestRulesRegistryTest, RemoveRulesImpl) {
   scoped_refptr<TestWebRequestRulesRegistry> registry(
       new TestWebRequestRulesRegistry());
   std::string error;
@@ skipping 104 matching lines @@
   EXPECT_EQ("", error);
 
   std::vector<linked_ptr<RulesRegistry::Rule> > rules_to_add_2(1);
   rules_to_add_2[0] = CreateRedirectRule("http://www.bar.com");
   error = registry->AddRules(kExtensionId2, rules_to_add_2);
   EXPECT_EQ("", error);
 
   GURL url("http://www.google.com");
   net::TestURLRequestContext context;
   net::TestURLRequest request(url, NULL, &context);
+  DeclarativeWebRequestData request_data(&request, ON_BEFORE_REQUEST);
   std::list<LinkedPtrEventResponseDelta> deltas =
-      registry->CreateDeltas(
-          NULL,
-          DeclarativeWebRequestData(&request, ON_BEFORE_REQUEST),
-          false);
+      registry->CreateDeltas(NULL, &request_data, false);
 
   // The second extension is installed later and will win for this reason
   // in conflict resolution.
   ASSERT_EQ(2u, deltas.size());
   deltas.sort(&helpers::InDecreasingExtensionInstallationTimeOrder);
 
   std::list<LinkedPtrEventResponseDelta>::iterator i = deltas.begin();
   LinkedPtrEventResponseDelta winner = *i++;
   LinkedPtrEventResponseDelta loser = *i;
 
@@ skipping 25 matching lines @@
   EXPECT_EQ("", error);
 
   std::vector<linked_ptr<RulesRegistry::Rule> > rules_to_add_3(1);
   rules_to_add_3[0] = CreateIgnoreRule();
   error = registry->AddRules(kExtensionId, rules_to_add_3);
   EXPECT_EQ("", error);
 
   GURL url("http://www.google.com/index.html");
   net::TestURLRequestContext context;
   net::TestURLRequest request(url, NULL, &context);
+  DeclarativeWebRequestData request_data(&request, ON_BEFORE_REQUEST);
   std::list<LinkedPtrEventResponseDelta> deltas =
-      registry->CreateDeltas(
-          NULL,
-          DeclarativeWebRequestData(&request, ON_BEFORE_REQUEST),
-          false);
+      registry->CreateDeltas(NULL, &request_data, false);
 
   // The redirect by the first extension is ignored due to the ignore rule.
   ASSERT_EQ(1u, deltas.size());
   LinkedPtrEventResponseDelta effective_rule = *(deltas.begin());
 
   EXPECT_EQ(kExtensionId2, effective_rule->extension_id);
   EXPECT_EQ(base::Time() + base::TimeDelta::FromDays(2),
             effective_rule->extension_install_time);
   EXPECT_EQ(GURL("http://www.bar.com"), effective_rule->new_url);
 }
@@ skipping 19 matching lines @@
 
   error = registry->AddRules(kExtensionId, rules);
   EXPECT_EQ("", error);
   EXPECT_EQ(1, registry->num_clear_cache_calls());
 
   std::set<const WebRequestRule*> matches;
 
   GURL http_url("http://www.example.com");
   net::TestURLRequestContext context;
   net::TestURLRequest http_request(http_url, NULL, &context);
-  matches = registry->GetMatches(
-      DeclarativeWebRequestData(&http_request, ON_BEFORE_REQUEST));
+  DeclarativeWebRequestData request_data(&http_request, ON_BEFORE_REQUEST);
+  matches = registry->GetMatches(&request_data);
   EXPECT_EQ(1u, matches.size());
   WebRequestRule::GlobalRuleId expected_pair = std::make_pair(kExtensionId,
                                                               kRuleId3);
   EXPECT_EQ(expected_pair, (*matches.begin())->id());
 }
 
 TEST_F(WebRequestRulesRegistryTest, CheckConsistency) {
   // The contentType condition can only be evaluated during ON_HEADERS_RECEIVED
   // but the redirect action can only be executed during ON_BEFORE_REQUEST.
   // Therefore, this is an inconsistent rule that needs to be flagged.
@@ skipping 27 matching lines @@
       new TestWebRequestRulesRegistry());
 
   URLMatcher matcher;
   std::string error = registry->AddRulesImpl(kExtensionId, rules);
   EXPECT_THAT(error, HasSubstr("no time in the request life-cycle"));
   EXPECT_TRUE(registry->IsEmpty());
 }
 
 
 }  // namespace extensions