Added URLRequestContext to constructor for URLRequest.

webkit/appcache/appcache_request_handler_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 <stack>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/message_loop.h"
 #include "base/threading/thread.h"
 #include "base/synchronization/waitable_event.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.h"
 #include "webkit/appcache/appcache_backend_impl.h"
 #include "webkit/appcache/appcache_request_handler.h"
 #include "webkit/appcache/appcache_url_request_job.h"
 #include "webkit/appcache/mock_appcache_policy.h"
 #include "webkit/appcache/mock_appcache_service.h"
 
 namespace appcache {
@@ skipping 72 matching lines @@
     }
 
   private:
     int response_code_;
     bool has_response_info_;
     net::HttpResponseInfo response_info_;
   };
 
   class MockURLRequest : public net::URLRequest {
    public:
-    explicit MockURLRequest(const GURL& url) : net::URLRequest(url, NULL) {}
+    explicit MockURLRequest(const GURL& url, net::URLRequestContext* context) :
+        net::URLRequest(url, NULL, context) {
+    }
 
     void SimulateResponseCode(int http_response_code) {
       mock_factory_job_ = new MockURLRequestJob(this, http_response_code);
       Start();
       DCHECK(!mock_factory_job_);
       // All our simulation needs  to satisfy are the following two DCHECKs
       DCHECK(status().is_success());
       DCHECK_EQ(http_response_code, GetResponseCode());
     }
 
@@ skipping 45 matching lines @@
         base::Bind(&AppCacheRequestHandlerTest::MethodWrapper<Method>,
                    base::Unretained(this), method));
     test_finished_event_->Wait();
   }
 
   void SetUpTest() {
     DCHECK(MessageLoop::current() == io_thread_->message_loop());
     orig_http_factory_ = net::URLRequest::Deprecated::RegisterProtocolFactory(
         "http", MockHttpJobFactory);
     mock_service_.reset(new MockAppCacheService);
+    mock_service_->set_request_context(&empty_context_);
     mock_policy_.reset(new MockAppCachePolicy);
     mock_service_->set_appcache_policy(mock_policy_.get());
     mock_frontend_.reset(new MockFrontend);
     backend_impl_.reset(new AppCacheBackendImpl);
     backend_impl_->Initialize(mock_service_.get(), mock_frontend_.get(),
                               kMockProcessId);
     const int kHostId = 1;
     backend_impl_->RegisterHost(kHostId);
     host_ = backend_impl_->GetHost(kHostId);
   }
@@ skipping 43 matching lines @@
     task_stack_.pop();
   }
 
   // MainResource_Miss --------------------------------------------------
 
   void MainResource_Miss() {
     PushNextTask(
         base::Bind(&AppCacheRequestHandlerTest::Verify_MainResource_Miss,
                    base::Unretained(this)));
 
-    request_.reset(new MockURLRequest(GURL("http://blah/")));
+    request_.reset(new MockURLRequest(GURL("http://blah/"), &empty_context_));
     handler_.reset(host_->CreateRequestHandler(request_.get(),
                                                ResourceType::MAIN_FRAME));
     EXPECT_TRUE(handler_.get());
 
     job_ = handler_->MaybeLoadResource(request_.get());
     EXPECT_TRUE(job_.get());
     EXPECT_TRUE(job_->is_waiting());
 
     // We have to wait for completion of storage->FindResponseForMainRequest.
     ScheduleNextTask();
@@ skipping 22 matching lines @@
     TestFinished();
   }
 
   // MainResource_Hit --------------------------------------------------
 
   void MainResource_Hit() {
     PushNextTask(
         base::Bind(&AppCacheRequestHandlerTest::Verify_MainResource_Hit,
                    base::Unretained(this)));
 
-    request_.reset(new MockURLRequest(GURL("http://blah/")));
+    request_.reset(new MockURLRequest(GURL("http://blah/"), &empty_context_));
     handler_.reset(host_->CreateRequestHandler(request_.get(),
                                                ResourceType::MAIN_FRAME));
     EXPECT_TRUE(handler_.get());
 
     mock_storage()->SimulateFindMainResource(
         AppCacheEntry(AppCacheEntry::EXPLICIT, 1),
         GURL(), AppCacheEntry(),
         1, 2, GURL("http://blah/manifest/"));
 
     job_ = handler_->MaybeLoadResource(request_.get());
@@ skipping 25 matching lines @@
     TestFinished();
   }
 
   // MainResource_Fallback --------------------------------------------------
 
   void MainResource_Fallback() {
     PushNextTask(
         base::Bind(&AppCacheRequestHandlerTest::Verify_MainResource_Fallback,
                    base::Unretained(this)));
 
-    request_.reset(new MockURLRequest(GURL("http://blah/")));
+    request_.reset(new MockURLRequest(GURL("http://blah/"), &empty_context_));
     handler_.reset(host_->CreateRequestHandler(request_.get(),
                                                ResourceType::MAIN_FRAME));
     EXPECT_TRUE(handler_.get());
 
     mock_storage()->SimulateFindMainResource(
         AppCacheEntry(),
         GURL("http://blah/fallbackurl"),
         AppCacheEntry(AppCacheEntry::EXPLICIT, 1),
         1, 2, GURL("http://blah/manifest/"));
 
@@ skipping 36 matching lines @@
     TestFinished();
   }
 
   // MainResource_FallbackOverride --------------------------------------------
 
   void MainResource_FallbackOverride() {
     PushNextTask(base::Bind(
         &AppCacheRequestHandlerTest::Verify_MainResource_FallbackOverride,
         base::Unretained(this)));
 
-    request_.reset(new MockURLRequest(GURL("http://blah/fallback-override")));
+    request_.reset(new MockURLRequest(GURL("http://blah/fallback-override"),
+                                      &empty_context_));
     handler_.reset(host_->CreateRequestHandler(request_.get(),
                                                ResourceType::MAIN_FRAME));
     EXPECT_TRUE(handler_.get());
 
     mock_storage()->SimulateFindMainResource(
         AppCacheEntry(),
         GURL("http://blah/fallbackurl"),
         AppCacheEntry(AppCacheEntry::EXPLICIT, 1),
         1, 2, GURL("http://blah/manifest/"));
 
@@ skipping 28 matching lines @@
 
     job_ = handler_->MaybeLoadFallbackForResponse(request_.get());
     EXPECT_FALSE(job_);
 
     TestFinished();
   }
 
   // SubResource_Miss_WithNoCacheSelected ----------------------------------
 
   void SubResource_Miss_WithNoCacheSelected() {
-    request_.reset(new MockURLRequest(GURL("http://blah/")));
+    request_.reset(new MockURLRequest(GURL("http://blah/"), &empty_context_));
     handler_.reset(host_->CreateRequestHandler(request_.get(),
                                                ResourceType::SUB_RESOURCE));
 
     // We avoid creating handler when possible, sub-resource requests are not
     // subject to retrieval from an appcache when there's no associated cache.
     EXPECT_FALSE(handler_.get());
 
     TestFinished();
   }
 
   // SubResource_Miss_WithCacheSelected ----------------------------------
 
   void SubResource_Miss_WithCacheSelected() {
     // A sub-resource load where the resource is not in an appcache, or
     // in a network or fallback namespace, should result in a failed request.
     host_->AssociateCompleteCache(MakeNewCache());
 
-    request_.reset(new MockURLRequest(GURL("http://blah/")));
+    request_.reset(new MockURLRequest(GURL("http://blah/"), &empty_context_));
     handler_.reset(host_->CreateRequestHandler(request_.get(),
                                                ResourceType::SUB_RESOURCE));
     EXPECT_TRUE(handler_.get());
 
     job_ = handler_->MaybeLoadResource(request_.get());
     EXPECT_TRUE(job_.get());
     EXPECT_TRUE(job_->is_delivering_error_response());
 
     AppCacheURLRequestJob* fallback_job;
     fallback_job = handler_->MaybeLoadFallbackForRedirect(
         request_.get(), GURL("http://blah/redirect"));
     EXPECT_FALSE(fallback_job);
     fallback_job = handler_->MaybeLoadFallbackForResponse(request_.get());
     EXPECT_FALSE(fallback_job);
 
     TestFinished();
   }
 
   // SubResource_Miss_WithWaitForCacheSelection -----------------------------
 
   void SubResource_Miss_WithWaitForCacheSelection() {
     // Precondition, the host is waiting on cache selection.
     scoped_refptr<AppCache> cache(MakeNewCache());
     host_->pending_selected_cache_id_ = cache->cache_id();
     host_->set_preferred_manifest_url(cache->owning_group()->manifest_url());
 
-    request_.reset(new MockURLRequest(GURL("http://blah/")));
+    request_.reset(new MockURLRequest(GURL("http://blah/"), &empty_context_));
     handler_.reset(host_->CreateRequestHandler(request_.get(),
                                                ResourceType::SUB_RESOURCE));
     EXPECT_TRUE(handler_.get());
     job_ = handler_->MaybeLoadResource(request_.get());
     EXPECT_TRUE(job_.get());
     EXPECT_TRUE(job_->is_waiting());
 
     host_->FinishCacheSelection(cache, NULL);
     EXPECT_FALSE(job_->is_waiting());
     EXPECT_TRUE(job_->is_delivering_error_response());
 
     AppCacheURLRequestJob* fallback_job;
     fallback_job = handler_->MaybeLoadFallbackForRedirect(
         request_.get(), GURL("http://blah/redirect"));
     EXPECT_FALSE(fallback_job);
     fallback_job = handler_->MaybeLoadFallbackForResponse(request_.get());
     EXPECT_FALSE(fallback_job);
 
     TestFinished();
   }
 
   // SubResource_Hit -----------------------------
 
   void SubResource_Hit() {
     host_->AssociateCompleteCache(MakeNewCache());
 
     mock_storage()->SimulateFindSubResource(
         AppCacheEntry(AppCacheEntry::EXPLICIT, 1), AppCacheEntry(), false);
 
-    request_.reset(new MockURLRequest(GURL("http://blah/")));
+    request_.reset(new MockURLRequest(GURL("http://blah/"), &empty_context_));
     handler_.reset(host_->CreateRequestHandler(request_.get(),
                                                ResourceType::SUB_RESOURCE));
     EXPECT_TRUE(handler_.get());
     job_ = handler_->MaybeLoadResource(request_.get());
     EXPECT_TRUE(job_.get());
     EXPECT_TRUE(job_->is_delivering_appcache_response());
 
     AppCacheURLRequestJob* fallback_job;
     fallback_job = handler_->MaybeLoadFallbackForRedirect(
         request_.get(), GURL("http://blah/redirect"));
     EXPECT_FALSE(fallback_job);
     fallback_job = handler_->MaybeLoadFallbackForResponse(request_.get());
     EXPECT_FALSE(fallback_job);
 
     TestFinished();
   }
 
   // SubResource_RedirectFallback -----------------------------
 
   void SubResource_RedirectFallback() {
     // Redirects to resources in the a different origin are subject to
     // fallback namespaces.
     host_->AssociateCompleteCache(MakeNewCache());
 
     mock_storage()->SimulateFindSubResource(
         AppCacheEntry(), AppCacheEntry(AppCacheEntry::EXPLICIT, 1), false);
 
-    request_.reset(new MockURLRequest(GURL("http://blah/")));
+    request_.reset(new MockURLRequest(GURL("http://blah/"), &empty_context_));
     handler_.reset(host_->CreateRequestHandler(request_.get(),
                                                ResourceType::SUB_RESOURCE));
     EXPECT_TRUE(handler_.get());
     job_ = handler_->MaybeLoadResource(request_.get());
     EXPECT_FALSE(job_.get());
 
     job_ = handler_->MaybeLoadFallbackForRedirect(
         request_.get(), GURL("http://not_blah/redirect"));
     EXPECT_TRUE(job_.get());
     EXPECT_TRUE(job_->is_delivering_appcache_response());
 
     AppCacheURLRequestJob* fallback_job;
     fallback_job = handler_->MaybeLoadFallbackForResponse(request_.get());
     EXPECT_FALSE(fallback_job);
 
     TestFinished();
   }
 
   // SubResource_NoRedirectFallback -----------------------------
 
   void SubResource_NoRedirectFallback() {
     // Redirects to resources in the same-origin are not subject to
     // fallback namespaces.
     host_->AssociateCompleteCache(MakeNewCache());
 
     mock_storage()->SimulateFindSubResource(
         AppCacheEntry(), AppCacheEntry(AppCacheEntry::EXPLICIT, 1), false);
 
-    request_.reset(new MockURLRequest(GURL("http://blah/")));
+    request_.reset(new MockURLRequest(GURL("http://blah/"), &empty_context_));
     handler_.reset(host_->CreateRequestHandler(request_.get(),
                                                ResourceType::SUB_RESOURCE));
     EXPECT_TRUE(handler_.get());
     job_ = handler_->MaybeLoadResource(request_.get());
     EXPECT_FALSE(job_.get());
 
     AppCacheURLRequestJob* fallback_job;
     fallback_job = handler_->MaybeLoadFallbackForRedirect(
         request_.get(), GURL("http://blah/redirect"));
     EXPECT_FALSE(fallback_job);
 
     request_->SimulateResponseCode(200);
     fallback_job = handler_->MaybeLoadFallbackForResponse(request_.get());
     EXPECT_FALSE(fallback_job);
 
     TestFinished();
   }
 
   // SubResource_Network -----------------------------
 
   void SubResource_Network() {
     // A sub-resource load where the resource is in a network namespace,
     // should result in the system using a 'real' job to do the network
     // retrieval.
     host_->AssociateCompleteCache(MakeNewCache());
 
     mock_storage()->SimulateFindSubResource(
         AppCacheEntry(), AppCacheEntry(), true);
 
-    request_.reset(new MockURLRequest(GURL("http://blah/")));
+    request_.reset(new MockURLRequest(GURL("http://blah/"), &empty_context_));
     handler_.reset(host_->CreateRequestHandler(request_.get(),
                                                ResourceType::SUB_RESOURCE));
     EXPECT_TRUE(handler_.get());
     job_ = handler_->MaybeLoadResource(request_.get());
     EXPECT_FALSE(job_.get());
 
     AppCacheURLRequestJob* fallback_job;
     fallback_job = handler_->MaybeLoadFallbackForRedirect(
         request_.get(), GURL("http://blah/redirect"));
     EXPECT_FALSE(fallback_job);
     fallback_job = handler_->MaybeLoadFallbackForResponse(request_.get());
     EXPECT_FALSE(fallback_job);
 
     TestFinished();
   }
 
   // DestroyedHost -----------------------------
 
   void DestroyedHost() {
     host_->AssociateCompleteCache(MakeNewCache());
 
     mock_storage()->SimulateFindSubResource(
         AppCacheEntry(AppCacheEntry::EXPLICIT, 1), AppCacheEntry(), false);
 
-    request_.reset(new MockURLRequest(GURL("http://blah/")));
+    request_.reset(new MockURLRequest(GURL("http://blah/"), &empty_context_));
     handler_.reset(host_->CreateRequestHandler(request_.get(),
                                                ResourceType::SUB_RESOURCE));
     EXPECT_TRUE(handler_.get());
 
     backend_impl_->UnregisterHost(1);
     host_ = NULL;
 
     EXPECT_FALSE(handler_->MaybeLoadResource(request_.get()));
     EXPECT_FALSE(handler_->MaybeLoadFallbackForRedirect(
         request_.get(), GURL("http://blah/redirect")));
     EXPECT_FALSE(handler_->MaybeLoadFallbackForResponse(request_.get()));
 
     TestFinished();
   }
 
   // DestroyedHostWithWaitingJob -----------------------------
 
   void DestroyedHostWithWaitingJob() {
     // Precondition, the host is waiting on cache selection.
     host_->pending_selected_cache_id_ = 1;
 
-    request_.reset(new MockURLRequest(GURL("http://blah/")));
+    request_.reset(new MockURLRequest(GURL("http://blah/"), &empty_context_));
     handler_.reset(host_->CreateRequestHandler(request_.get(),
                                                ResourceType::SUB_RESOURCE));
     EXPECT_TRUE(handler_.get());
 
     job_ = handler_->MaybeLoadResource(request_.get());
     EXPECT_TRUE(job_.get());
     EXPECT_TRUE(job_->is_waiting());
 
     backend_impl_->UnregisterHost(1);
     host_ = NULL;
     EXPECT_TRUE(job_->has_been_killed());
 
     EXPECT_FALSE(handler_->MaybeLoadResource(request_.get()));
     EXPECT_FALSE(handler_->MaybeLoadFallbackForRedirect(
         request_.get(), GURL("http://blah/redirect")));
     EXPECT_FALSE(handler_->MaybeLoadFallbackForResponse(request_.get()));
 
     TestFinished();
   }
 
   // UnsupportedScheme -----------------------------
 
   void UnsupportedScheme() {
     // Precondition, the host is waiting on cache selection.
     host_->pending_selected_cache_id_ = 1;
 
-    request_.reset(new MockURLRequest(GURL("ftp://blah/")));
+    request_.reset(new MockURLRequest(GURL("ftp://blah/"), &empty_context_));
     handler_.reset(host_->CreateRequestHandler(request_.get(),
                                                ResourceType::SUB_RESOURCE));
     EXPECT_TRUE(handler_.get());  // we could redirect to http (conceivably)
 
     EXPECT_FALSE(handler_->MaybeLoadResource(request_.get()));
     EXPECT_FALSE(handler_->MaybeLoadFallbackForRedirect(
         request_.get(), GURL("ftp://blah/redirect")));
     EXPECT_FALSE(handler_->MaybeLoadFallbackForResponse(request_.get()));
 
     TestFinished();
   }
 
   // CanceledRequest -----------------------------
 
   void CanceledRequest() {
-    request_.reset(new MockURLRequest(GURL("http://blah/")));
+    request_.reset(new MockURLRequest(GURL("http://blah/"), &empty_context_));
     handler_.reset(host_->CreateRequestHandler(request_.get(),
                                                ResourceType::MAIN_FRAME));
     EXPECT_TRUE(handler_.get());
 
     job_ = handler_->MaybeLoadResource(request_.get());
     EXPECT_TRUE(job_.get());
     EXPECT_TRUE(job_->is_waiting());
     EXPECT_FALSE(job_->has_been_started());
 
     mock_factory_job_ = job_.get();
@@ skipping 13 matching lines @@
   void WorkerRequest() {
     EXPECT_TRUE(AppCacheRequestHandler::IsMainResourceType(
         ResourceType::MAIN_FRAME));
     EXPECT_TRUE(AppCacheRequestHandler::IsMainResourceType(
         ResourceType::SUB_FRAME));
     EXPECT_TRUE(AppCacheRequestHandler::IsMainResourceType(
         ResourceType::SHARED_WORKER));
     EXPECT_FALSE(AppCacheRequestHandler::IsMainResourceType(
         ResourceType::WORKER));
 
-    request_.reset(new MockURLRequest(GURL("http://blah/")));
+    request_.reset(new MockURLRequest(GURL("http://blah/"), &empty_context_));
 
     const int kParentHostId = host_->host_id();
     const int kWorkerHostId = 2;
     const int kAbandonedWorkerHostId = 3;
     const int kNonExsitingHostId = 700;
 
     backend_impl_->RegisterHost(kWorkerHostId);
     AppCacheHost* worker_host = backend_impl_->GetHost(kWorkerHostId);
     worker_host->SelectCacheForWorker(kParentHostId, kMockProcessId);
     handler_.reset(worker_host->CreateRequestHandler(
@@ skipping 16 matching lines @@
     TestFinished();
   }
 
   // MainResource_Blocked --------------------------------------------------
 
   void MainResource_Blocked() {
     PushNextTask(
         base::Bind(&AppCacheRequestHandlerTest::Verify_MainResource_Blocked,
                    base::Unretained(this)));
 
-    request_.reset(new MockURLRequest(GURL("http://blah/")));
+    request_.reset(new MockURLRequest(GURL("http://blah/"), &empty_context_));
     handler_.reset(host_->CreateRequestHandler(request_.get(),
                                                ResourceType::MAIN_FRAME));
     EXPECT_TRUE(handler_.get());
 
     mock_policy_->can_load_return_value_ = false;
     mock_storage()->SimulateFindMainResource(
         AppCacheEntry(AppCacheEntry::EXPLICIT, 1),
         GURL(), AppCacheEntry(),
         1, 2, GURL("http://blah/manifest/"));
 
@@ skipping 38 matching lines @@
 
   // Data members --------------------------------------------------
 
   scoped_ptr<base::WaitableEvent> test_finished_event_;
   std::stack<base::Closure> task_stack_;
   scoped_ptr<MockAppCacheService> mock_service_;
   scoped_ptr<AppCacheBackendImpl> backend_impl_;
   scoped_ptr<MockFrontend> mock_frontend_;
   scoped_ptr<MockAppCachePolicy> mock_policy_;
   AppCacheHost* host_;
+  net::URLRequestContext empty_context_;
   scoped_ptr<MockURLRequest> request_;
   scoped_ptr<AppCacheRequestHandler> handler_;
   scoped_refptr<AppCacheURLRequestJob> job_;
   net::URLRequest::ProtocolFactory* orig_http_factory_;
 
   static scoped_ptr<base::Thread> io_thread_;
   static net::URLRequestJob* mock_factory_job_;
 };
 
 // static
@@ skipping 68 matching lines @@
 
 TEST_F(AppCacheRequestHandlerTest, WorkerRequest) {
   RunTestOnIOThread(&AppCacheRequestHandlerTest::WorkerRequest);
 }
 
 TEST_F(AppCacheRequestHandlerTest, MainResource_Blocked) {
   RunTestOnIOThread(&AppCacheRequestHandlerTest::MainResource_Blocked);
 }
 
 }  // namespace appcache