Allow URLRequests from one context to have different NetworkDelegates.

chrome/browser/extensions/api/web_request/web_request_api_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 <map>
 #include <queue>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_string_value_serializer.h"
+#include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/prefs/pref_member.h"
 #include "base/stl_util.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "chrome/browser/content_settings/cookie_settings.h"
@@ skipping 207 matching lines @@
       ipc_sender_factory.GetWeakPtr());
 
   net::URLRequestJobFactoryImpl job_factory;
   job_factory.SetProtocolHandler(
       url::kAboutScheme, new chrome_browser_net::AboutProtocolHandler());
   context_->set_job_factory(&job_factory);
 
   GURL redirect_url("about:redirected");
   GURL not_chosen_redirect_url("about:not_chosen");
 
-  net::URLRequest request(
-      GURL("about:blank"), net::DEFAULT_PRIORITY, &delegate_, context_.get());
+  scoped_ptr<net::URLRequest> request(context_->CreateRequest(
+      GURL("about:blank"), net::DEFAULT_PRIORITY, &delegate_, NULL));
   {
     // onBeforeRequest will be dispatched twice initially. The second response -
     // the redirect - should win, since it has a later |install_time|. The
     // redirect will dispatch another pair of onBeforeRequest. There, the first
     // response should win (later |install_time|).
     ExtensionWebRequestEventRouter::EventResponse* response = NULL;
 
     // Extension1 response. Arrives first, but ignored due to install_time.
     response = new ExtensionWebRequestEventRouter::EventResponse(
         extension1_id, base::Time::FromDoubleT(1));
     response->new_url = not_chosen_redirect_url;
     ipc_sender_.PushTask(
         base::Bind(&EventHandledOnIOThread,
             &profile_, extension1_id, kEventName, kEventName + "/1",
-            request.identifier(), response));
+            request->identifier(), response));
 
     // Extension2 response. Arrives second, and chosen because of install_time.
     response = new ExtensionWebRequestEventRouter::EventResponse(
         extension2_id, base::Time::FromDoubleT(2));
     response->new_url = redirect_url;
     ipc_sender_.PushTask(
         base::Bind(&EventHandledOnIOThread,
             &profile_, extension2_id, kEventName, kEventName + "/2",
-            request.identifier(), response));
+            request->identifier(), response));
 
     // Extension2 response to the redirected URL. Arrives first, and chosen.
     response = new ExtensionWebRequestEventRouter::EventResponse(
         extension2_id, base::Time::FromDoubleT(2));
     ipc_sender_.PushTask(
         base::Bind(&EventHandledOnIOThread,
             &profile_, extension2_id, kEventName, kEventName + "/2",
-            request.identifier(), response));
+            request->identifier(), response));
 
     // Extension1 response to the redirected URL. Arrives second, and ignored.
     response = new ExtensionWebRequestEventRouter::EventResponse(
         extension1_id, base::Time::FromDoubleT(1));
     ipc_sender_.PushTask(
         base::Bind(&EventHandledOnIOThread,
             &profile_, extension1_id, kEventName, kEventName + "/1",
-            request.identifier(), response));
+            request->identifier(), response));
 
-    request.Start();
+    request->Start();
     base::MessageLoop::current()->Run();
 
-    EXPECT_TRUE(!request.is_pending());
-    EXPECT_EQ(net::URLRequestStatus::SUCCESS, request.status().status());
-    EXPECT_EQ(0, request.status().error());
-    EXPECT_EQ(redirect_url, request.url());
-    EXPECT_EQ(2U, request.url_chain().size());
+    EXPECT_TRUE(!request->is_pending());
+    EXPECT_EQ(net::URLRequestStatus::SUCCESS, request->status().status());
+    EXPECT_EQ(0, request->status().error());
+    EXPECT_EQ(redirect_url, request->url());
+    EXPECT_EQ(2U, request->url_chain().size());
     EXPECT_EQ(0U, ipc_sender_.GetNumTasks());
   }
 
   // Now test the same thing but the extensions answer in reverse order.
-  net::URLRequest request2(
-      GURL("about:blank"), net::DEFAULT_PRIORITY, &delegate_, context_.get());
+  scoped_ptr<net::URLRequest> request2(context_->CreateRequest(
+      GURL("about:blank"), net::DEFAULT_PRIORITY, &delegate_, NULL));
   {
     ExtensionWebRequestEventRouter::EventResponse* response = NULL;
 
     // Extension2 response. Arrives first, and chosen because of install_time.
     response = new ExtensionWebRequestEventRouter::EventResponse(
         extension2_id, base::Time::FromDoubleT(2));
     response->new_url = redirect_url;
     ipc_sender_.PushTask(
         base::Bind(&EventHandledOnIOThread,
             &profile_, extension2_id, kEventName, kEventName + "/2",
-            request2.identifier(), response));
+            request2->identifier(), response));
 
     // Extension1 response. Arrives second, but ignored due to install_time.
     response = new ExtensionWebRequestEventRouter::EventResponse(
         extension1_id, base::Time::FromDoubleT(1));
     response->new_url = not_chosen_redirect_url;
     ipc_sender_.PushTask(
         base::Bind(&EventHandledOnIOThread,
             &profile_, extension1_id, kEventName, kEventName + "/1",
-            request2.identifier(), response));
+            request2->identifier(), response));
 
     // Extension2 response to the redirected URL. Arrives first, and chosen.
     response = new ExtensionWebRequestEventRouter::EventResponse(
         extension2_id, base::Time::FromDoubleT(2));
     ipc_sender_.PushTask(
         base::Bind(&EventHandledOnIOThread,
             &profile_, extension2_id, kEventName, kEventName + "/2",
-            request2.identifier(), response));
+            request2->identifier(), response));
 
     // Extension1 response to the redirected URL. Arrives second, and ignored.
     response = new ExtensionWebRequestEventRouter::EventResponse(
         extension1_id, base::Time::FromDoubleT(1));
     ipc_sender_.PushTask(
         base::Bind(&EventHandledOnIOThread,
             &profile_, extension1_id, kEventName, kEventName + "/1",
-            request2.identifier(), response));
+            request2->identifier(), response));
 
-    request2.Start();
+    request2->Start();
     base::MessageLoop::current()->Run();
 
-    EXPECT_TRUE(!request2.is_pending());
-    EXPECT_EQ(net::URLRequestStatus::SUCCESS, request2.status().status());
-    EXPECT_EQ(0, request2.status().error());
-    EXPECT_EQ(redirect_url, request2.url());
-    EXPECT_EQ(2U, request2.url_chain().size());
+    EXPECT_TRUE(!request2->is_pending());
+    EXPECT_EQ(net::URLRequestStatus::SUCCESS, request2->status().status());
+    EXPECT_EQ(0, request2->status().error());
+    EXPECT_EQ(redirect_url, request2->url());
+    EXPECT_EQ(2U, request2->url_chain().size());
     EXPECT_EQ(0U, ipc_sender_.GetNumTasks());
   }
 
   ExtensionWebRequestEventRouter::GetInstance()->RemoveEventListener(
       &profile_, extension1_id, kEventName + "/1");
   ExtensionWebRequestEventRouter::GetInstance()->RemoveEventListener(
       &profile_, extension2_id, kEventName + "/2");
 }
 
 // Test that a request is canceled if this is requested by any extension
 // regardless whether it is the extension with the highest precedence.
 TEST_F(ExtensionWebRequestTest, BlockingEventPrecedenceCancel) {
   std::string extension1_id("1");
   std::string extension2_id("2");
   ExtensionWebRequestEventRouter::RequestFilter filter;
   const std::string kEventName(web_request::OnBeforeRequest::kEventName);
   base::WeakPtrFactory<TestIPCSender> ipc_sender_factory(&ipc_sender_);
   ExtensionWebRequestEventRouter::GetInstance()->AddEventListener(
     &profile_, extension1_id, extension1_id, kEventName, kEventName + "/1",
     filter, ExtensionWebRequestEventRouter::ExtraInfoSpec::BLOCKING, -1, -1,
     ipc_sender_factory.GetWeakPtr());
   ExtensionWebRequestEventRouter::GetInstance()->AddEventListener(
     &profile_, extension2_id, extension2_id, kEventName, kEventName + "/2",
     filter, ExtensionWebRequestEventRouter::ExtraInfoSpec::BLOCKING, -1, -1,
     ipc_sender_factory.GetWeakPtr());
 
   GURL request_url("about:blank");
-  net::URLRequest request(
-      request_url, net::DEFAULT_PRIORITY, &delegate_, context_.get());
+  scoped_ptr<net::URLRequest> request(context_->CreateRequest(
+      request_url, net::DEFAULT_PRIORITY, &delegate_, NULL));
 
   // onBeforeRequest will be dispatched twice. The second response -
   // the redirect - would win, since it has a later |install_time|, but
   // the first response takes precedence because cancel >> redirect.
   GURL redirect_url("about:redirected");
   ExtensionWebRequestEventRouter::EventResponse* response = NULL;
 
   // Extension1 response. Arrives first, would be ignored in principle due to
   // install_time but "cancel" always wins.
   response = new ExtensionWebRequestEventRouter::EventResponse(
       extension1_id, base::Time::FromDoubleT(1));
   response->cancel = true;
   ipc_sender_.PushTask(
       base::Bind(&EventHandledOnIOThread,
           &profile_, extension1_id, kEventName, kEventName + "/1",
-          request.identifier(), response));
+          request->identifier(), response));
 
   // Extension2 response. Arrives second, but has higher precedence
   // due to its later install_time.
   response = new ExtensionWebRequestEventRouter::EventResponse(
       extension2_id, base::Time::FromDoubleT(2));
   response->new_url = redirect_url;
   ipc_sender_.PushTask(
       base::Bind(&EventHandledOnIOThread,
           &profile_, extension2_id, kEventName, kEventName + "/2",
-          request.identifier(), response));
+          request->identifier(), response));
 
-  request.Start();
+  request->Start();
 
   base::MessageLoop::current()->Run();
 
-  EXPECT_TRUE(!request.is_pending());
-  EXPECT_EQ(net::URLRequestStatus::FAILED, request.status().status());
-  EXPECT_EQ(net::ERR_BLOCKED_BY_CLIENT, request.status().error());
-  EXPECT_EQ(request_url, request.url());
-  EXPECT_EQ(1U, request.url_chain().size());
+  EXPECT_TRUE(!request->is_pending());
+  EXPECT_EQ(net::URLRequestStatus::FAILED, request->status().status());
+  EXPECT_EQ(net::ERR_BLOCKED_BY_CLIENT, request->status().error());
+  EXPECT_EQ(request_url, request->url());
+  EXPECT_EQ(1U, request->url_chain().size());
   EXPECT_EQ(0U, ipc_sender_.GetNumTasks());
 
   ExtensionWebRequestEventRouter::GetInstance()->RemoveEventListener(
       &profile_, extension1_id, kEventName + "/1");
   ExtensionWebRequestEventRouter::GetInstance()->RemoveEventListener(
       &profile_, extension2_id, kEventName + "/2");
 }
 
 TEST_F(ExtensionWebRequestTest, SimulateChancelWhileBlocked) {
   // We subscribe to OnBeforeRequest and OnErrorOccurred.
@@ skipping 10 matching lines @@
   base::WeakPtrFactory<TestIPCSender> ipc_sender_factory(&ipc_sender_);
   ExtensionWebRequestEventRouter::GetInstance()->AddEventListener(
     &profile_, extension_id, extension_id, kEventName, kEventName + "/1",
     filter, ExtensionWebRequestEventRouter::ExtraInfoSpec::BLOCKING, -1, -1,
     ipc_sender_factory.GetWeakPtr());
   ExtensionWebRequestEventRouter::GetInstance()->AddEventListener(
     &profile_, extension_id, extension_id, kEventName2, kEventName2 + "/1",
     filter, 0, -1, -1, ipc_sender_factory.GetWeakPtr());
 
   GURL request_url("about:blank");
-  net::URLRequest request(
-      request_url, net::DEFAULT_PRIORITY, &delegate_, context_.get());
+  scoped_ptr<net::URLRequest> request(context_->CreateRequest(
+      request_url, net::DEFAULT_PRIORITY, &delegate_, NULL));
 
   ExtensionWebRequestEventRouter::EventResponse* response = NULL;
 
   // Extension response for the OnBeforeRequest handler. This should not be
   // processed because request is canceled before the handler responds.
   response = new ExtensionWebRequestEventRouter::EventResponse(
       extension_id, base::Time::FromDoubleT(1));
   GURL redirect_url("about:redirected");
   response->new_url = redirect_url;
   ipc_sender_.PushTask(
       base::Bind(&EventHandledOnIOThread,
           &profile_, extension_id, kEventName, kEventName + "/1",
-          request.identifier(), response));
+          request->identifier(), response));
 
   // Extension response for OnErrorOccurred: Terminate the message loop.
   ipc_sender_.PushTask(
       base::Bind(&base::MessageLoop::PostTask,
                  base::Unretained(base::MessageLoop::current()),
                  FROM_HERE, base::MessageLoop::QuitClosure()));
 
-  request.Start();
-  // request.Start() will have submitted OnBeforeRequest by the time we cancel.
-  request.Cancel();
+  request->Start();
+  // request->Start() will have submitted OnBeforeRequest by the time we cancel.
+  request->Cancel();
   base::MessageLoop::current()->Run();
 
-  EXPECT_TRUE(!request.is_pending());
-  EXPECT_EQ(net::URLRequestStatus::CANCELED, request.status().status());
-  EXPECT_EQ(net::ERR_ABORTED, request.status().error());
-  EXPECT_EQ(request_url, request.url());
-  EXPECT_EQ(1U, request.url_chain().size());
+  EXPECT_TRUE(!request->is_pending());
+  EXPECT_EQ(net::URLRequestStatus::CANCELED, request->status().status());
+  EXPECT_EQ(net::ERR_ABORTED, request->status().error());
+  EXPECT_EQ(request_url, request->url());
+  EXPECT_EQ(1U, request->url_chain().size());
   EXPECT_EQ(0U, ipc_sender_.GetNumTasks());
 
   ExtensionWebRequestEventRouter::GetInstance()->RemoveEventListener(
       &profile_, extension_id, kEventName + "/1");
   ExtensionWebRequestEventRouter::GetInstance()->RemoveEventListener(
       &profile_, extension_id, kEventName2 + "/1");
 }
 
 namespace {
 
@@ skipping 12 matching lines @@
 
 }  // namespace
 
 void ExtensionWebRequestTest::FireURLRequestWithData(
     const std::string& method,
     const char* content_type,
     const std::vector<char>& bytes_1,
     const std::vector<char>& bytes_2) {
   // The request URL can be arbitrary but must have an HTTP or HTTPS scheme.
   GURL request_url("http://www.example.com");
-  net::URLRequest request(
-      request_url, net::DEFAULT_PRIORITY, &delegate_, context_.get());
-  request.set_method(method);
-  if (content_type != NULL)
-    request.SetExtraRequestHeaderByName(net::HttpRequestHeaders::kContentType,
-                                        content_type,
-                                        true /* overwrite */);
+  scoped_ptr<net::URLRequest> request(context_->CreateRequest(
+      request_url, net::DEFAULT_PRIORITY, &delegate_, NULL));
+  request->set_method(method);
+  if (content_type != NULL) {
+    request->SetExtraRequestHeaderByName(net::HttpRequestHeaders::kContentType,
+                                         content_type,
+                                         true /* overwrite */);
+  }
   ScopedVector<net::UploadElementReader> element_readers;
   element_readers.push_back(new net::UploadBytesElementReader(
       &(bytes_1[0]), bytes_1.size()));
   element_readers.push_back(
       new net::UploadFileElementReader(base::MessageLoopProxy::current().get(),
                                        base::FilePath(),
                                        0,
                                        0,
                                        base::Time()));
   element_readers.push_back(
       new net::UploadBytesElementReader(&(bytes_2[0]), bytes_2.size()));
-  request.set_upload(make_scoped_ptr(
+  request->set_upload(make_scoped_ptr(
       new net::UploadDataStream(element_readers.Pass(), 0)));
   ipc_sender_.PushTask(base::Bind(&base::DoNothing));
-  request.Start();
+  request->Start();
 }
 
 TEST_F(ExtensionWebRequestTest, AccessRequestBodyData) {
   // We verify that URLRequest body is accessible to OnBeforeRequest listeners.
   // These testing steps are repeated twice in a row:
   // 1. Register an extension requesting "requestBody" in ExtraInfoSpec and
   //    file a POST URLRequest with a multipart-encoded form. See it getting
   //    parsed.
   // 2. Do the same, but without requesting "requestBody". Nothing should be
   //    parsed.
@@ skipping 172 matching lines @@
 
   // Subscribe to OnBeforeRequest with requestBody requirement.
   ExtensionWebRequestEventRouter::GetInstance()->AddEventListener(
       &profile_, extension_id, extension_id, kEventName, kEventName + "/1",
       filter, extra_info_spec, -1, -1, ipc_sender_factory.GetWeakPtr());
 
   // The request URL can be arbitrary but must have an HTTP or HTTPS scheme.
   const GURL request_url("http://www.example.com");
 
   for (size_t i = 0; i < arraysize(kMethods); ++i) {
-    net::URLRequest request(
-        request_url, net::DEFAULT_PRIORITY, &delegate_, context_.get());
-    request.set_method(kMethods[i]);
+    scoped_ptr<net::URLRequest> request(context_->CreateRequest(
+        request_url, net::DEFAULT_PRIORITY, &delegate_, NULL));
+    request->set_method(kMethods[i]);
     ipc_sender_.PushTask(base::Bind(&base::DoNothing));
-    request.Start();
+    request->Start();
   }
 
   // We inspect the result in the message list of |ipc_sender_| later.
   base::MessageLoop::current()->RunUntilIdle();
 
   ExtensionWebRequestEventRouter::GetInstance()->RemoveEventListener(
       &profile_, extension_id, kEventName + "/1");
 
   TestIPCSender::SentMessages::const_iterator i = ipc_sender_.sent_begin();
   for (size_t test = 0; test < arraysize(kMethods); ++test, ++i) {
@@ skipping 95 matching lines @@
       ipc_sender_factory.GetWeakPtr());
 
   // Install one extension that observes the final headers.
   ExtensionWebRequestEventRouter::GetInstance()->AddEventListener(
       &profile_, extension3_id, extension3_id, keys::kOnSendHeadersEvent,
       std::string(keys::kOnSendHeadersEvent) + "/3", filter,
       ExtensionWebRequestEventRouter::ExtraInfoSpec::REQUEST_HEADERS, -1, -1,
       ipc_sender_factory.GetWeakPtr());
 
   GURL request_url("http://doesnotexist/does_not_exist.html");
-  net::URLRequest request(
-      request_url, net::DEFAULT_PRIORITY, &delegate_, context_.get());
+  scoped_ptr<net::URLRequest> request(context_->CreateRequest(
+      request_url, net::DEFAULT_PRIORITY, &delegate_, NULL));
 
   // Initialize headers available before extensions are notified of the
   // onBeforeSendHeaders event.
   HeaderModificationTest test = GetParam();
   net::HttpRequestHeaders before_headers;
   for (int i = 0; i < test.before_size; ++i)
     before_headers.SetHeader(test.before[i].name, test.before[i].value);
-  request.SetExtraRequestHeaders(before_headers);
+  request->SetExtraRequestHeaders(before_headers);
 
   // Gather the modifications to the headers for the respective extensions.
   // We assume here that all modifications of one extension are listed
   // in a continuous block of |test.modifications_|.
   ExtensionWebRequestEventRouter::EventResponse* response = NULL;
   for (int i = 0; i < test.modification_size; ++i) {
     const HeaderModificationTest_Modification& mod = test.modification[i];
     if (response == NULL) {
       response = new ExtensionWebRequestEventRouter::EventResponse(
           mod.extension_id == 1 ? extension1_id : extension2_id,
           base::Time::FromDoubleT(mod.extension_id));
       response->request_headers.reset(new net::HttpRequestHeaders());
-      response->request_headers->MergeFrom(request.extra_request_headers());
+      response->request_headers->MergeFrom(request->extra_request_headers());
     }
 
     switch (mod.type) {
       case HeaderModificationTest_Modification::SET:
         response->request_headers->SetHeader(mod.key, mod.value);
         break;
       case HeaderModificationTest_Modification::REMOVE:
         response->request_headers->RemoveHeader(mod.key);
         break;
     }
 
     // Trigger the result when this is the last modification statement or
     // the block of modifications for the next extension starts.
     if (i+1 == test.modification_size ||
         mod.extension_id != test.modification[i+1].extension_id) {
       ipc_sender_.PushTask(
           base::Bind(&EventHandledOnIOThread,
               &profile_, mod.extension_id == 1 ? extension1_id : extension2_id,
               kEventName, kEventName + (mod.extension_id == 1 ? "/1" : "/2"),
-              request.identifier(), response));
+              request->identifier(), response));
       response = NULL;
     }
   }
 
   // Don't do anything for the onSendHeaders message.
   ipc_sender_.PushTask(base::Bind(&base::DoNothing));
 
   // Note that we mess up the headers slightly:
-  // request.Start() will first add additional headers (e.g. the User-Agent)
+  // request->Start() will first add additional headers (e.g. the User-Agent)
   // and then send an event to the extension. When we have prepared our
   // answers to the onBeforeSendHeaders events above, these headers did not
   // exists and are therefore not listed in the responses. This makes
   // them seem deleted.
-  request.Start();
+  request->Start();
   base::MessageLoop::current()->Run();
 
-  EXPECT_TRUE(!request.is_pending());
+  EXPECT_TRUE(!request->is_pending());
   // This cannot succeed as we send the request to a server that does not exist.
-  EXPECT_EQ(net::URLRequestStatus::FAILED, request.status().status());
-  EXPECT_EQ(request_url, request.url());
-  EXPECT_EQ(1U, request.url_chain().size());
+  EXPECT_EQ(net::URLRequestStatus::FAILED, request->status().status());
+  EXPECT_EQ(request_url, request->url());
+  EXPECT_EQ(1U, request->url_chain().size());
   EXPECT_EQ(0U, ipc_sender_.GetNumTasks());
 
   // Calculate the expected headers.
   net::HttpRequestHeaders expected_headers;
   for (int i = 0; i < test.after_size; ++i) {
     expected_headers.SetHeader(test.after[i].name,
                                test.after[i].value);
   }
 
   // Counter for the number of observed onSendHeaders events.
@@ skipping 1313 matching lines @@
   EXPECT_TRUE(credentials_set);
   EXPECT_FALSE(auth3.Empty());
   EXPECT_EQ(username, auth1.username());
   EXPECT_EQ(password, auth1.password());
   EXPECT_EQ(1u, warning_set.size());
   EXPECT_TRUE(HasWarning(warning_set, "extid2"));
   EXPECT_EQ(3u, capturing_net_log.GetSize());
 }
 
 }  // namespace extensions