Make URLRequest's constructor private, and make URLRequestContext a friend class.

chrome/browser/extensions/api/declarative_webrequest/webrequest_condition_attribute_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_attribute.h"
 
 #include "base/basictypes.h"
 #include "base/files/file_path.h"
+#include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/declarative_webrequest/webrequest_condition.h"
 #include "content/public/browser/resource_request_info.h"
 #include "extensions/browser/api/declarative_webrequest/webrequest_constants.h"
 #include "net/base/request_priority.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
+#include "net/url_request/url_request.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::DictionaryValue;
 using base::FundamentalValue;
 using base::ListValue;
 using base::StringValue;
 using base::Value;
 using content::ResourceType;
 
@@ skipping 62 matching lines @@
   resource_types.Append(new base::StringValue("sub_frame"));
 
   scoped_refptr<const WebRequestConditionAttribute> attribute =
       WebRequestConditionAttribute::Create(
           keys::kResourceTypeKey, &resource_types, &error);
   EXPECT_EQ("", error);
   ASSERT_TRUE(attribute.get());
   EXPECT_EQ(std::string(keys::kResourceTypeKey), attribute->GetName());
 
   net::TestURLRequestContext context;
-  net::TestURLRequest url_request_ok(
-      GURL("http://www.example.com"), net::DEFAULT_PRIORITY, NULL, &context);
+  scoped_ptr<net::URLRequest> url_request_ok(context.CreateRequest(
+      GURL("http://www.example.com"), net::DEFAULT_PRIORITY, NULL, NULL));
   content::ResourceRequestInfo::AllocateForTesting(
-      &url_request_ok,
+      url_request_ok.get(),
       content::RESOURCE_TYPE_SUB_FRAME,
       NULL,
       -1,
       -1,
       -1,
       false);
-  EXPECT_TRUE(attribute->IsFulfilled(WebRequestData(&url_request_ok,
+  EXPECT_TRUE(attribute->IsFulfilled(WebRequestData(url_request_ok.get(),
                                                     ON_BEFORE_REQUEST)));
 
-  net::TestURLRequest url_request_fail(
-      GURL("http://www.example.com"), net::DEFAULT_PRIORITY, NULL, &context);
+  scoped_ptr<net::URLRequest> url_request_fail(context.CreateRequest(
+      GURL("http://www.example.com"), net::DEFAULT_PRIORITY, NULL, NULL));
   content::ResourceRequestInfo::AllocateForTesting(
-      &url_request_fail,
+      url_request_fail.get(),
       content::RESOURCE_TYPE_MAIN_FRAME,
       NULL,
       -1,
       -1,
       -1,
       false);
-  EXPECT_FALSE(attribute->IsFulfilled(WebRequestData(&url_request_fail,
+  EXPECT_FALSE(attribute->IsFulfilled(WebRequestData(url_request_fail.get(),
                                                      ON_BEFORE_REQUEST)));
 }
 
 TEST(WebRequestConditionAttributeTest, ContentType) {
   // Necessary for TestURLRequest.
   base::MessageLoopForIO message_loop;
 
   std::string error;
   scoped_refptr<const WebRequestConditionAttribute> result;
 
   net::test_server::EmbeddedTestServer test_server;
   test_server.ServeFilesFromDirectory(TestDataPath(
       "chrome/test/data/extensions/api_test/webrequest/declarative"));
   ASSERT_TRUE(test_server.InitializeAndWaitUntilReady());
 
   net::TestURLRequestContext context;
   net::TestDelegate delegate;
-  net::TestURLRequest url_request(test_server.GetURL("/headers.html"),
-                                  net::DEFAULT_PRIORITY,
-                                  &delegate,
-                                  &context);
-  url_request.Start();
+  scoped_ptr<net::URLRequest> url_request(
+      context.CreateRequest(test_server.GetURL("/headers.html"),
+                            net::DEFAULT_PRIORITY,
+                            &delegate,
+                            NULL));
+  url_request->Start();
   base::MessageLoop::current()->Run();
 
   base::ListValue content_types;
   content_types.Append(new base::StringValue("text/plain"));
   scoped_refptr<const WebRequestConditionAttribute> attribute_include =
       WebRequestConditionAttribute::Create(
           keys::kContentTypeKey, &content_types, &error);
   EXPECT_EQ("", error);
   ASSERT_TRUE(attribute_include.get());
   EXPECT_FALSE(attribute_include->IsFulfilled(
-      WebRequestData(&url_request, ON_BEFORE_REQUEST,
-                     url_request.response_headers())));
+      WebRequestData(url_request.get(), ON_BEFORE_REQUEST,
+                     url_request->response_headers())));
   EXPECT_TRUE(attribute_include->IsFulfilled(
-      WebRequestData(&url_request, ON_HEADERS_RECEIVED,
-                     url_request.response_headers())));
+      WebRequestData(url_request.get(), ON_HEADERS_RECEIVED,
+                     url_request->response_headers())));
   EXPECT_EQ(std::string(keys::kContentTypeKey), attribute_include->GetName());
 
   scoped_refptr<const WebRequestConditionAttribute> attribute_exclude =
       WebRequestConditionAttribute::Create(
           keys::kExcludeContentTypeKey, &content_types, &error);
   EXPECT_EQ("", error);
   ASSERT_TRUE(attribute_exclude.get());
   EXPECT_FALSE(attribute_exclude->IsFulfilled(
-      WebRequestData(&url_request, ON_HEADERS_RECEIVED,
-                     url_request.response_headers())));
+      WebRequestData(url_request.get(), ON_HEADERS_RECEIVED,
+                     url_request->response_headers())));
 
   content_types.Clear();
   content_types.Append(new base::StringValue("something/invalid"));
   scoped_refptr<const WebRequestConditionAttribute> attribute_unincluded =
       WebRequestConditionAttribute::Create(
           keys::kContentTypeKey, &content_types, &error);
   EXPECT_EQ("", error);
   ASSERT_TRUE(attribute_unincluded.get());
   EXPECT_FALSE(attribute_unincluded->IsFulfilled(
-      WebRequestData(&url_request, ON_HEADERS_RECEIVED,
-                     url_request.response_headers())));
+      WebRequestData(url_request.get(), ON_HEADERS_RECEIVED,
+                     url_request->response_headers())));
 
   scoped_refptr<const WebRequestConditionAttribute> attribute_unexcluded =
       WebRequestConditionAttribute::Create(
           keys::kExcludeContentTypeKey, &content_types, &error);
   EXPECT_EQ("", error);
   ASSERT_TRUE(attribute_unexcluded.get());
   EXPECT_TRUE(attribute_unexcluded->IsFulfilled(
-      WebRequestData(&url_request, ON_HEADERS_RECEIVED,
-                     url_request.response_headers())));
+      WebRequestData(url_request.get(), ON_HEADERS_RECEIVED,
+                     url_request->response_headers())));
   EXPECT_EQ(std::string(keys::kExcludeContentTypeKey),
             attribute_unexcluded->GetName());
 }
 
 // Testing WebRequestConditionAttributeThirdParty.
 TEST(WebRequestConditionAttributeTest, ThirdParty) {
   // Necessary for TestURLRequest.
   base::MessageLoopForIO message_loop;
 
   std::string error;
@@ skipping 16 matching lines @@
   ASSERT_EQ("", error);
   ASSERT_TRUE(first_party_attribute.get());
   EXPECT_EQ(std::string(keys::kThirdPartyKey),
             first_party_attribute->GetName());
 
   const GURL url_empty;
   const GURL url_a("http://a.com");
   const GURL url_b("http://b.com");
   net::TestURLRequestContext context;
   net::TestDelegate delegate;
-  net::TestURLRequest url_request(
-      url_a, net::DEFAULT_PRIORITY, &delegate, &context);
+  scoped_ptr<net::URLRequest> url_request(
+      context.CreateRequest(url_a, net::DEFAULT_PRIORITY, &delegate, NULL));
 
   for (unsigned int i = 1; i <= kLastActiveStage; i <<= 1) {
     if (!(kActiveStages & i))
       continue;
     const RequestStage stage = static_cast<RequestStage>(i);
-    url_request.set_first_party_for_cookies(url_empty);
-    EXPECT_FALSE(third_party_attribute->IsFulfilled(WebRequestData(&url_request,
-                                                                   stage)));
-    EXPECT_TRUE(first_party_attribute->IsFulfilled(WebRequestData(&url_request,
-                                                                  stage)));
+    url_request->set_first_party_for_cookies(url_empty);
+    EXPECT_FALSE(third_party_attribute->IsFulfilled(
+        WebRequestData(url_request.get(), stage)));
+    EXPECT_TRUE(first_party_attribute->IsFulfilled(
+        WebRequestData(url_request.get(), stage)));
 
-    url_request.set_first_party_for_cookies(url_b);
-    EXPECT_TRUE(third_party_attribute->IsFulfilled(WebRequestData(&url_request,
-                                                                  stage)));
-    EXPECT_FALSE(first_party_attribute->IsFulfilled(WebRequestData(&url_request,
-                                                                   stage)));
+    url_request->set_first_party_for_cookies(url_b);
+    EXPECT_TRUE(third_party_attribute->IsFulfilled(
+        WebRequestData(url_request.get(), stage)));
+    EXPECT_FALSE(first_party_attribute->IsFulfilled(
+        WebRequestData(url_request.get(), stage)));
 
-    url_request.set_first_party_for_cookies(url_a);
-    EXPECT_FALSE(third_party_attribute->IsFulfilled(WebRequestData(&url_request,
-                                                                   stage)));
-    EXPECT_TRUE(first_party_attribute->IsFulfilled(WebRequestData(&url_request,
-                                                                  stage)));
+    url_request->set_first_party_for_cookies(url_a);
+    EXPECT_FALSE(third_party_attribute->IsFulfilled(
+        WebRequestData(url_request.get(), stage)));
+    EXPECT_TRUE(first_party_attribute->IsFulfilled(
+        WebRequestData(url_request.get(), stage)));
   }
 }
 
 // Testing WebRequestConditionAttributeStages. This iterates over all stages,
 // and tests a couple of "stage" attributes -- one created with an empty set of
 // applicable stages, one for each stage applicable for that stage, and one
 // applicable in all stages.
 TEST(WebRequestConditionAttributeTest, Stages) {
   // Necessary for TestURLRequest.
   base::MessageLoopForIO message_loop;
@@ skipping 47 matching lines @@
         WebRequestConditionAttribute::Create(keys::kStagesKey,
                                              &single_stage_list,
                                              &error));
     EXPECT_EQ("", error);
     ASSERT_TRUE(one_stage_attributes.back().get() != NULL);
   }
 
   const GURL url_empty;
   net::TestURLRequestContext context;
   net::TestDelegate delegate;
-  net::TestURLRequest url_request(
-      url_empty, net::DEFAULT_PRIORITY, &delegate, &context);
+  scoped_ptr<net::URLRequest> url_request(
+      context.CreateRequest(url_empty, net::DEFAULT_PRIORITY, &delegate, NULL));
 
   for (size_t i = 0; i < arraysize(active_stages); ++i) {
     EXPECT_FALSE(empty_attribute->IsFulfilled(
-        WebRequestData(&url_request, active_stages[i].first)));
+        WebRequestData(url_request.get(), active_stages[i].first)));
 
     for (size_t j = 0; j < one_stage_attributes.size(); ++j) {
       EXPECT_EQ(i == j,
                 one_stage_attributes[j]->IsFulfilled(
-                    WebRequestData(&url_request, active_stages[i].first)));
+                    WebRequestData(url_request.get(), active_stages[i].first)));
     }
 
     EXPECT_TRUE(attribute_with_all->IsFulfilled(
-        WebRequestData(&url_request, active_stages[i].first)));
+        WebRequestData(url_request.get(), active_stages[i].first)));
   }
 }
 
 namespace {
 
 // Builds a vector of vectors of string pointers from an array of strings.
 // |array| is in fact a sequence of arrays. The array |sizes| captures the sizes
 // of all parts of |array|, and |size| is the length of |sizes| itself.
 // Example (this is pseudo-code, not C++):
 // array = { "a", "b", "c", "d", "e", "f" }
@@ skipping 90 matching lines @@
 // Here we test WebRequestConditionAttributeRequestHeaders for matching
 // correctly against request headers. This test is not as extensive as
 // "ResponseHeaders" (below), because the header-matching code is shared
 // by both types of condition attributes, so it is enough to test it once.
 TEST(WebRequestConditionAttributeTest, RequestHeaders) {
   // Necessary for TestURLRequest.
   base::MessageLoopForIO message_loop;
 
   net::TestURLRequestContext context;
   net::TestDelegate delegate;
-  net::TestURLRequest url_request(GURL("http://example.com"),  // Dummy URL.
-                                  net::DEFAULT_PRIORITY,
-                                  &delegate,
-                                  &context);
-  url_request.SetExtraRequestHeaderByName(
+  scoped_ptr<net::URLRequest> url_request(
+      context.CreateRequest(GURL("http://example.com"),  // Dummy URL.
+                            net::DEFAULT_PRIORITY,
+                            &delegate,
+                            NULL));
+  url_request->SetExtraRequestHeaderByName(
       "Custom-header", "custom/value", true /* overwrite */);
-  url_request.Start();
+  url_request->Start();
   base::MessageLoop::current()->Run();
 
   std::vector<std::vector<const std::string*> > tests;
   bool result = false;
 
   const RequestStage stage = ON_BEFORE_SEND_HEADERS;
 
   // First set of test data -- passing conjunction.
   const std::string kPassingCondition[] = {
     keys::kNameContainsKey, "CuStOm",  // Header names are case insensitive.
     keys::kNameEqualsKey, "custom-header",
     keys::kValueSuffixKey, "alue",
     keys::kValuePrefixKey, "custom/value"
   };
   const size_t kPassingConditionSizes[] = { arraysize(kPassingCondition) };
   GetArrayAsVector(kPassingCondition, kPassingConditionSizes, 1u, &tests);
   // Positive filter, passing (conjunction of tests).
-  MatchAndCheck(tests, keys::kRequestHeadersKey, stage, &url_request, &result);
+  MatchAndCheck(
+      tests, keys::kRequestHeadersKey, stage, url_request.get(), &result);
   EXPECT_TRUE(result);
   // Negative filter, failing (conjunction of tests).
-  MatchAndCheck(
-      tests, keys::kExcludeRequestHeadersKey, stage, &url_request, &result);
+  MatchAndCheck(tests, keys::kExcludeRequestHeadersKey, stage,
+                url_request.get(), &result);
   EXPECT_FALSE(result);
 
   // Second set of test data -- failing disjunction.
   const std::string kFailCondition[] = {
     keys::kNameSuffixKey, "Custom",      // Test 1.
     keys::kNameEqualsKey, "ustom-valu",  // Test 2.
     keys::kValuePrefixKey, "custom ",    // Test 3.
     keys::kValueContainsKey, " value"    // Test 4.
   };
   const size_t kFailConditionSizes[] = { 2u, 2u, 2u, 2u };
   GetArrayAsVector(kFailCondition, kFailConditionSizes, 4u, &tests);
   // Positive filter, failing (disjunction of tests).
-  MatchAndCheck(tests, keys::kRequestHeadersKey, stage, &url_request, &result);
+  MatchAndCheck(tests, keys::kRequestHeadersKey, stage, url_request.get(),
+                &result);
   EXPECT_FALSE(result);
   // Negative filter, passing (disjunction of tests).
-  MatchAndCheck(
-      tests, keys::kExcludeRequestHeadersKey, stage, &url_request, &result);
+  MatchAndCheck(tests, keys::kExcludeRequestHeadersKey, stage,
+                url_request.get(), &result);
   EXPECT_TRUE(result);
 
   // Third set of test data, corner case -- empty disjunction.
   GetArrayAsVector(NULL, NULL, 0u, &tests);
   // Positive filter, failing (no test to pass).
-  MatchAndCheck(tests, keys::kRequestHeadersKey, stage, &url_request, &result);
+  MatchAndCheck(tests, keys::kRequestHeadersKey, stage, url_request.get(),
+                &result);
   EXPECT_FALSE(result);
   // Negative filter, passing (no test to fail).
-  MatchAndCheck(
-      tests, keys::kExcludeRequestHeadersKey, stage, &url_request, &result);
+  MatchAndCheck(tests, keys::kExcludeRequestHeadersKey, stage,
+                url_request.get(), &result);
   EXPECT_TRUE(result);
 
   // Fourth set of test data, corner case -- empty conjunction.
   const size_t kEmptyConjunctionSizes[] = { 0u };
   GetArrayAsVector(NULL, kEmptyConjunctionSizes, 1u, &tests);
   // Positive filter, passing (trivial test).
-  MatchAndCheck(tests, keys::kRequestHeadersKey, stage, &url_request, &result);
+  MatchAndCheck(tests, keys::kRequestHeadersKey, stage, url_request.get(),
+                &result);
   EXPECT_TRUE(result);
   // Negative filter, failing.
-  MatchAndCheck(
-      tests, keys::kExcludeRequestHeadersKey, stage, &url_request, &result);
+  MatchAndCheck(tests, keys::kExcludeRequestHeadersKey, stage,
+                url_request.get(), &result);
   EXPECT_FALSE(result);
 }
 
 // Here we test WebRequestConditionAttributeResponseHeaders for:
 // 1. Correct implementation of prefix/suffix/contains/equals matching.
 // 2. Performing logical disjunction (||) between multiple specifications.
 // 3. Negating the match in case of 'doesNotContainHeaders'.
 TEST(WebRequestConditionAttributeTest, ResponseHeaders) {
   // Necessary for TestURLRequest.
   base::MessageLoopForIO message_loop;
 
   net::test_server::EmbeddedTestServer test_server;
   test_server.ServeFilesFromDirectory(TestDataPath(
       "chrome/test/data/extensions/api_test/webrequest/declarative"));
   ASSERT_TRUE(test_server.InitializeAndWaitUntilReady());
 
   net::TestURLRequestContext context;
   net::TestDelegate delegate;
-  net::TestURLRequest url_request(test_server.GetURL("/headers.html"),
-                                  net::DEFAULT_PRIORITY,
-                                  &delegate,
-                                  &context);
-  url_request.Start();
+  scoped_ptr<net::URLRequest> url_request(
+      context.CreateRequest(test_server.GetURL("/headers.html"),
+                            net::DEFAULT_PRIORITY,
+                            &delegate,
+                            NULL));
+  url_request->Start();
   base::MessageLoop::current()->Run();
 
   // In all the tests below we assume that the server includes the headers
   // Custom-Header: custom/value
   // Custom-Header-B: valueA
   // Custom-Header-B: valueB
   // Custom-Header-C: valueC, valueD
   // Custom-Header-D:
   // in the response, but does not include "Non-existing: void".
 
   std::vector< std::vector<const std::string*> > tests;
   bool result;
 
   const RequestStage stage = ON_HEADERS_RECEIVED;
 
   // 1.a. -- All these tests should pass.
   const std::string kPassingCondition[] = {
     keys::kNamePrefixKey, "Custom",
     keys::kNameSuffixKey, "m-header",  // Header names are case insensitive.
     keys::kValueContainsKey, "alu",
     keys::kValueEqualsKey, "custom/value"
   };
   const size_t kPassingConditionSizes[] = { arraysize(kPassingCondition) };
   GetArrayAsVector(kPassingCondition, kPassingConditionSizes, 1u, &tests);
-  MatchAndCheck(tests, keys::kResponseHeadersKey, stage, &url_request, &result);
+  MatchAndCheck(tests, keys::kResponseHeadersKey, stage, url_request.get(),
+                &result);
   EXPECT_TRUE(result);
 
   // 1.b. -- None of the following tests in the discjunction should pass.
   const std::string kFailCondition[] = {
     keys::kNamePrefixKey, " Custom",  // Test 1.
     keys::kNameContainsKey, " -",     // Test 2.
     keys::kValueSuffixKey, "alu",     // Test 3.
     keys::kValueEqualsKey, "custom"   // Test 4.
   };
   const size_t kFailConditionSizes[] = { 2u, 2u, 2u, 2u };
   GetArrayAsVector(kFailCondition, kFailConditionSizes, 4u, &tests);
-  MatchAndCheck(tests, keys::kResponseHeadersKey, stage, &url_request, &result);
+  MatchAndCheck(tests, keys::kResponseHeadersKey, stage, url_request.get(),
+                &result);
   EXPECT_FALSE(result);
 
   // 1.c. -- This should fail (mixing name and value from different headers)
   const std::string kMixingCondition[] = {
     keys::kNameSuffixKey, "Header-B",
     keys::kValueEqualsKey, "custom/value"
   };
   const size_t kMixingConditionSizes[] = { arraysize(kMixingCondition) };
   GetArrayAsVector(kMixingCondition, kMixingConditionSizes, 1u, &tests);
-  MatchAndCheck(tests, keys::kResponseHeadersKey, stage, &url_request, &result);
+  MatchAndCheck(tests, keys::kResponseHeadersKey, stage, url_request.get(),
+                &result);
   EXPECT_FALSE(result);
 
   // 1.d. -- Test handling multiple values for one header (both should pass).
   const std::string kMoreValues1[] = {
     keys::kNameEqualsKey, "Custom-header-b",
     keys::kValueEqualsKey, "valueA"
   };
   const size_t kMoreValues1Sizes[] = { arraysize(kMoreValues1) };
   GetArrayAsVector(kMoreValues1, kMoreValues1Sizes, 1u, &tests);
-  MatchAndCheck(tests, keys::kResponseHeadersKey, stage, &url_request, &result);
+  MatchAndCheck(tests, keys::kResponseHeadersKey, stage, url_request.get(),
+                &result);
   EXPECT_TRUE(result);
   const std::string kMoreValues2[] = {
     keys::kNameEqualsKey, "Custom-header-b",
     keys::kValueEqualsKey, "valueB"
   };
   const size_t kMoreValues2Sizes[] = { arraysize(kMoreValues2) };
   GetArrayAsVector(kMoreValues2, kMoreValues2Sizes, 1u, &tests);
-  MatchAndCheck(tests, keys::kResponseHeadersKey, stage, &url_request, &result);
+  MatchAndCheck(tests, keys::kResponseHeadersKey, stage, url_request.get(),
+                &result);
   EXPECT_TRUE(result);
 
   // 1.e. -- This should fail as conjunction but pass as disjunction.
   const std::string kConflict[] = {
     keys::kNameSuffixKey, "Header",      // True for some header.
     keys::kNameContainsKey, "Header-B"   // True for a different header.
   };
   // First disjunction, no conflict.
   const size_t kNoConflictSizes[] = { 2u, 2u };
   GetArrayAsVector(kConflict, kNoConflictSizes, 2u, &tests);
-  MatchAndCheck(tests, keys::kResponseHeadersKey, stage, &url_request, &result);
+  MatchAndCheck(tests, keys::kResponseHeadersKey, stage, url_request.get(),
+                &result);
   EXPECT_TRUE(result);
   // Then conjunction, conflict.
   const size_t kConflictSizes[] = { arraysize(kConflict) };
   GetArrayAsVector(kConflict, kConflictSizes, 1u, &tests);
-  MatchAndCheck(tests, keys::kResponseHeadersKey, stage, &url_request, &result);
+  MatchAndCheck(tests, keys::kResponseHeadersKey, stage, url_request.get(),
+                &result);
   EXPECT_FALSE(result);
 
   // 1.f. -- This should pass, checking for correct treatment of ',' in values.
   const std::string kComma[] = {
     keys::kNameSuffixKey, "Header-C",
     keys::kValueEqualsKey, "valueC, valueD"
   };
   const size_t kCommaSizes[] = { arraysize(kComma) };
   GetArrayAsVector(kComma, kCommaSizes, 1u, &tests);
-  MatchAndCheck(tests, keys::kResponseHeadersKey, stage, &url_request, &result);
+  MatchAndCheck(tests, keys::kResponseHeadersKey, stage, url_request.get(),
+                &result);
   EXPECT_TRUE(result);
 
   // 1.g. -- This should pass, empty values are values as well.
   const std::string kEmpty[] = {
     keys::kNameEqualsKey, "custom-header-d",
     keys::kValueEqualsKey, ""
   };
   const size_t kEmptySizes[] = { arraysize(kEmpty) };
   GetArrayAsVector(kEmpty, kEmptySizes, 1u, &tests);
-  MatchAndCheck(tests, keys::kResponseHeadersKey, stage, &url_request, &result);
+  MatchAndCheck(tests, keys::kResponseHeadersKey, stage, url_request.get(),
+                &result);
   EXPECT_TRUE(result);
 
   // 1.h. -- Values are case-sensitive, this should fail.
   const std::string kLowercase[] = {
     keys::kNameEqualsKey, "Custom-header-b",
     keys::kValuePrefixKey, "valueb",  // valueb != valueB
     keys::kNameEqualsKey, "Custom-header-b",
     keys::kValueSuffixKey, "valueb",
     keys::kNameEqualsKey, "Custom-header-b",
     keys::kValueContainsKey, "valueb",
     keys::kNameEqualsKey, "Custom-header-b",
     keys::kValueEqualsKey, "valueb"
   };
   const size_t kLowercaseSizes[] = { 4u, 4u, 4u, 4u };  // As disjunction.
   GetArrayAsVector(kLowercase, kLowercaseSizes, 4u, &tests);
-  MatchAndCheck(tests, keys::kResponseHeadersKey, stage, &url_request, &result);
+  MatchAndCheck(tests, keys::kResponseHeadersKey, stage, url_request.get(),
+                &result);
   EXPECT_FALSE(result);
 
   // 1.i. -- Names are case-insensitive, this should pass.
   const std::string kUppercase[] = {
     keys::kNamePrefixKey, "CUSTOM-HEADER-B",
     keys::kNameSuffixKey, "CUSTOM-HEADER-B",
     keys::kNameEqualsKey, "CUSTOM-HEADER-B",
     keys::kNameContainsKey, "CUSTOM-HEADER-B"
   };
   const size_t kUppercaseSizes[] = { arraysize(kUppercase) };  // Conjunction.
   GetArrayAsVector(kUppercase, kUppercaseSizes, 1u, &tests);
-  MatchAndCheck(tests, keys::kResponseHeadersKey, stage, &url_request, &result);
+  MatchAndCheck(tests, keys::kResponseHeadersKey, stage, url_request.get(),
+                &result);
   EXPECT_TRUE(result);
 
   // 2.a. -- This should pass as disjunction, because one of the tests passes.
   const std::string kDisjunction[] = {
     keys::kNamePrefixKey, "Non-existing",  // This one fails.
     keys::kNameSuffixKey, "Non-existing",  // This one fails.
     keys::kValueEqualsKey, "void",         // This one fails.
     keys::kValueContainsKey, "alu"         // This passes.
   };
   const size_t kDisjunctionSizes[] = { 2u, 2u, 2u, 2u };
   GetArrayAsVector(kDisjunction, kDisjunctionSizes, 4u, &tests);
-  MatchAndCheck(tests, keys::kResponseHeadersKey, stage, &url_request, &result);
+  MatchAndCheck(tests, keys::kResponseHeadersKey, stage, url_request.get(),
+                &result);
   EXPECT_TRUE(result);
 
   // 3.a. -- This should pass.
   const std::string kNonExistent[] = {
     keys::kNameEqualsKey, "Non-existing",
     keys::kValueEqualsKey, "void"
   };
   const size_t kNonExistentSizes[] = { arraysize(kNonExistent) };
   GetArrayAsVector(kNonExistent, kNonExistentSizes, 1u, &tests);
-  MatchAndCheck(
-      tests, keys::kExcludeResponseHeadersKey, stage, &url_request, &result);
+  MatchAndCheck(tests, keys::kExcludeResponseHeadersKey, stage,
+                url_request.get(), &result);
   EXPECT_TRUE(result);
 
   // 3.b. -- This should fail.
   const std::string kExisting[] = {
     keys::kNameEqualsKey, "custom-header-b",
     keys::kValueEqualsKey, "valueB"
   };
   const size_t kExistingSize[] = { arraysize(kExisting) };
   GetArrayAsVector(kExisting, kExistingSize, 1u, &tests);
-  MatchAndCheck(
-      tests, keys::kExcludeResponseHeadersKey, stage, &url_request, &result);
+  MatchAndCheck(tests, keys::kExcludeResponseHeadersKey, stage,
+                url_request.get(), &result);
   EXPECT_FALSE(result);
 }
 
 }  // namespace
 }  // namespace extensions