Added URLRequestContext to constructor for URLRequest.

webkit/appcache/appcache_url_request_job_unittest.cc

 // Copyright (c) 2011 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 <stack>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/pickle.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request.h"
+#include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_error_job.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/appcache/appcache_response.h"
 #include "webkit/appcache/appcache_url_request_job.h"
 #include "webkit/appcache/mock_appcache_service.h"
 
 using net::IOBuffer;
 using net::WrappedIOBuffer;
 
 namespace appcache {
@@ skipping 333 matching lines @@
     return true;
   }
 
   // Individual Tests ---------------------------------------------------------
   // Some of the individual tests involve multiple async steps. Each test
   // is delineated with a section header.
 
   // Basic -------------------------------------------------------------------
   void Basic() {
     AppCacheStorage* storage = service_->storage();
-    net::URLRequest request(GURL("http://blah/"), NULL);
+    net::URLRequest request(GURL("http://blah/"), NULL, &empty_context_);
     scoped_refptr<AppCacheURLRequestJob> job;
 
     // Create an instance and see that it looks as expected.
 
     job = new AppCacheURLRequestJob(&request, storage);
     EXPECT_TRUE(job->is_waiting());
     EXPECT_FALSE(job->is_delivering_appcache_response());
     EXPECT_FALSE(job->is_delivering_network_response());
     EXPECT_FALSE(job->is_delivering_error_response());
     EXPECT_FALSE(job->has_been_started());
     EXPECT_FALSE(job->has_been_killed());
     EXPECT_EQ(GURL(), job->manifest_url());
     EXPECT_EQ(kNoCacheId, job->cache_id());
     EXPECT_FALSE(job->entry().has_response_id());
 
     TestFinished();
   }
 
   // DeliveryOrders -----------------------------------------------------
   void DeliveryOrders() {
     AppCacheStorage* storage = service_->storage();
-    net::URLRequest request(GURL("http://blah/"), NULL);
+    net::URLRequest request(GURL("http://blah/"), NULL, &empty_context_);
     scoped_refptr<AppCacheURLRequestJob> job;
 
     // Create an instance, give it a delivery order and see that
     // it looks as expected.
 
     job = new AppCacheURLRequestJob(&request, storage);
     job->DeliverErrorResponse();
     EXPECT_TRUE(job->is_delivering_error_response());
     EXPECT_FALSE(job->has_been_started());
 
@@ skipping 24 matching lines @@
   // DeliverNetworkResponse --------------------------------------------------
 
   void DeliverNetworkResponse() {
     // This test has async steps.
     PushNextTask(
         base::Bind(&AppCacheURLRequestJobTest::VerifyDeliverNetworkResponse,
                    base::Unretained(this)));
 
     AppCacheStorage* storage = service_->storage();
     request_.reset(
-        new net::URLRequest(GURL("http://blah/"), url_request_delegate_.get()));
+        new net::URLRequest(GURL("http://blah/"),
+                            url_request_delegate_.get(),
+                            &empty_context_));
 
     // Setup to create an AppCacheURLRequestJob with orders to deliver
     // a network response.
     mock_factory_job_ = new AppCacheURLRequestJob(request_.get(), storage);
     mock_factory_job_->DeliverNetworkResponse();
     EXPECT_TRUE(mock_factory_job_->is_delivering_network_response());
     EXPECT_FALSE(mock_factory_job_->has_been_started());
 
     // Start the request.
     request_->Start();
@@ skipping 12 matching lines @@
   // DeliverErrorResponse --------------------------------------------------
 
   void DeliverErrorResponse() {
     // This test has async steps.
     PushNextTask(
         base::Bind(&AppCacheURLRequestJobTest::VerifyDeliverErrorResponse,
                    base::Unretained(this)));
 
     AppCacheStorage* storage = service_->storage();
     request_.reset(
-        new net::URLRequest(GURL("http://blah/"), url_request_delegate_.get()));
+        new net::URLRequest(GURL("http://blah/"),
+                            url_request_delegate_.get(),
+                            &empty_context_));
 
     // Setup to create an AppCacheURLRequestJob with orders to deliver
     // a network response.
     mock_factory_job_ = new AppCacheURLRequestJob(request_.get(), storage);
     mock_factory_job_->DeliverErrorResponse();
     EXPECT_TRUE(mock_factory_job_->is_delivering_error_response());
     EXPECT_FALSE(mock_factory_job_->has_been_started());
 
     // Start the request.
     request_->Start();
@@ skipping 27 matching lines @@
 
     writer_.reset(service_->storage()->CreateResponseWriter(GURL(), 0));
     written_response_id_ = writer_->response_id();
     WriteBasicResponse();
     // Continues async
   }
 
   void RequestAppCachedResource(bool start_after_delivery_orders) {
     AppCacheStorage* storage = service_->storage();
     request_.reset(
-        new net::URLRequest(GURL("http://blah/"), url_request_delegate_.get()));
+        new net::URLRequest(GURL("http://blah/"),
+                            url_request_delegate_.get(),
+                            &empty_context_));
 
     // Setup to create an AppCacheURLRequestJob with orders to deliver
     // a network response.
     scoped_refptr<AppCacheURLRequestJob> job(
         new AppCacheURLRequestJob(request_.get(), storage));
 
     if (start_after_delivery_orders) {
       job->DeliverAppCachedResponse(
           GURL(), 0, 111,
           AppCacheEntry(AppCacheEntry::EXPLICIT, written_response_id_),
@@ skipping 91 matching lines @@
        &AppCacheURLRequestJobTest::MakeRangeRequest, base::Unretained(this)));
     writer_.reset(service_->storage()->CreateResponseWriter(GURL(), 0));
     written_response_id_ = writer_->response_id();
     WriteBasicResponse();
     // Continues async
   }
 
   void MakeRangeRequest() {
     AppCacheStorage* storage = service_->storage();
     request_.reset(
-        new net::URLRequest(GURL("http://blah/"), url_request_delegate_.get()));
+        new net::URLRequest(GURL("http://blah/"),
+                            url_request_delegate_.get(),
+                            &empty_context_));
 
     // Request a range, the 3 middle chars out of 'Hello'
     net::HttpRequestHeaders extra_headers;
     extra_headers.SetHeader("Range", "bytes= 1-3");
     request_->SetExtraRequestHeaders(extra_headers);
 
     // Create job with orders to deliver an appcached entry.
     scoped_refptr<AppCacheURLRequestJob> job(
         new AppCacheURLRequestJob(request_.get(), storage));
     job->DeliverAppCachedResponse(
@@ skipping 97 matching lines @@
   int reader_deletion_count_down_;
 
   int64 written_response_id_;
   scoped_ptr<AppCacheResponseWriter> writer_;
   scoped_refptr<HttpResponseInfoIOBuffer> write_info_buffer_;
   scoped_refptr<IOBuffer> write_buffer_;
   int expected_write_result_;
   int writer_deletion_count_down_;
 
   net::URLRequest::ProtocolFactory* orig_http_factory_;
+  net::URLRequestContext empty_context_;
   scoped_ptr<net::URLRequest> request_;
   scoped_ptr<MockURLRequestDelegate> url_request_delegate_;
 
   static scoped_ptr<base::Thread> io_thread_;
   static AppCacheURLRequestJob* mock_factory_job_;
 };
 
 // static
 scoped_ptr<base::Thread> AppCacheURLRequestJobTest::io_thread_;
 AppCacheURLRequestJob* AppCacheURLRequestJobTest::mock_factory_job_ = NULL;
@@ skipping 28 matching lines @@
 
 TEST_F(AppCacheURLRequestJobTest, CancelRequest) {
   RunTestOnIOThread(&AppCacheURLRequestJobTest::CancelRequest);
 }
 
 TEST_F(AppCacheURLRequestJobTest, CancelRequestWithIOPending) {
   RunTestOnIOThread(&AppCacheURLRequestJobTest::CancelRequestWithIOPending);
 }
 
 }  // namespace appcache