Add HttpProtocolHandler and convert everything to use it

net/url_request/url_request_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 <memory>
 #include <utility>
 
 #include "base/memory/ptr_util.h"
 #include "build/build_config.h"
 
@@ skipping 78 matching lines @@
 #include "net/ssl/ssl_connection_status_flags.h"
 #include "net/ssl/ssl_server_config.h"
 #include "net/ssl/token_binding.h"
 #include "net/test/cert_test_util.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "net/test/embedded_test_server/http_request.h"
 #include "net/test/embedded_test_server/http_response.h"
 #include "net/test/spawned_test_server/spawned_test_server.h"
 #include "net/test/url_request/url_request_failed_job.h"
 #include "net/url_request/data_protocol_handler.h"
+#include "net/url_request/http_protocol_handler.h"
 #include "net/url_request/static_http_user_agent_settings.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_filter.h"
 #include "net/url_request/url_request_http_job.h"
 #include "net/url_request/url_request_intercepting_job_factory.h"
 #include "net/url_request/url_request_interceptor.h"
 #include "net/url_request/url_request_job_factory_impl.h"
 #include "net/url_request/url_request_redirect_job.h"
 #include "net/url_request/url_request_test_job.h"
 #include "net/url_request/url_request_test_util.h"
@@ skipping 599 matching lines @@
 };
 
 }  // namespace
 
 // Inherit PlatformTest since we require the autorelease pool on Mac OS X.
 class URLRequestTest : public PlatformTest {
  public:
   URLRequestTest() : default_context_(true) {
     default_context_.set_network_delegate(&default_network_delegate_);
     default_context_.set_net_log(&net_log_);
-    job_factory_impl_ = new URLRequestJobFactoryImpl();
-    job_factory_.reset(job_factory_impl_);
+    std::unique_ptr<URLRequestJobFactoryImpl> job_factory =
+        URLRequestJobFactoryImpl::CreateWithHttpProtocolHandlers();
+    job_factory_impl_ = job_factory.get();
+    job_factory_ = std::move(job_factory);
   }
 
   ~URLRequestTest() override {
     // URLRequestJobs may post clean-up tasks on destruction.
     base::RunLoop().RunUntilIdle();
   }
 
   void SetUp() override {
     SetUpFactory();
+    test_job_interceptor_ = new TestJobInterceptor;
+    job_factory_.reset(new URLRequestInterceptingJobFactory(
+        std::move(job_factory_), base::WrapUnique(test_job_interceptor_)));
     default_context_.set_job_factory(job_factory_.get());
     default_context_.Init();
     PlatformTest::SetUp();
   }
 
   virtual void SetUpFactory() {
     job_factory_impl_->SetProtocolHandler(
         "data", base::WrapUnique(new DataProtocolHandler));
+
 #if !defined(DISABLE_FILE_SUPPORT)
     job_factory_impl_->SetProtocolHandler(
         "file", base::WrapUnique(new FileProtocolHandler(
                     base::ThreadTaskRunnerHandle::Get())));
 #endif
   }
 
   TestNetworkDelegate* default_network_delegate() {
     return &default_network_delegate_;
   }
 
   const TestURLRequestContext& default_context() const {
     return default_context_;
   }
 
-
-  // Adds the TestJobInterceptor to the default context.
-  TestJobInterceptor* AddTestInterceptor() {
-    TestJobInterceptor* protocol_handler_ = new TestJobInterceptor();
-    job_factory_impl_->SetProtocolHandler("http", nullptr);
-    job_factory_impl_->SetProtocolHandler("http",
-                                          base::WrapUnique(protocol_handler_));
-    return protocol_handler_;
-  }
-
  protected:
   TestNetLog net_log_;
   TestNetworkDelegate default_network_delegate_;  // Must outlive URLRequest.
   URLRequestJobFactoryImpl* job_factory_impl_;
   std::unique_ptr<URLRequestJobFactory> job_factory_;
   TestURLRequestContext default_context_;
+  TestJobInterceptor* test_job_interceptor_;
 };
 
 TEST_F(URLRequestTest, AboutBlankTest) {
   TestDelegate d;
   {
     std::unique_ptr<URLRequest> r(default_context_.CreateRequest(
         GURL("about:blank"), DEFAULT_PRIORITY, &d));
 
     r->Start();
     EXPECT_TRUE(r->is_pending());
@@ skipping 551 matching lines @@
     }
     if (cancel_then_restart_main_request_) {
       cancel_then_restart_main_request_ = false;
       did_cancel_then_restart_main_ = true;
       return new CancelThenRestartTestJob(request, network_delegate);
     }
     if (simulate_main_network_error_) {
       simulate_main_network_error_ = false;
       did_simulate_error_main_ = true;
       if (use_url_request_http_job_) {
-        return URLRequestHttpJob::Factory(request, network_delegate, "http");
+        return new URLRequestHttpJob(
+            request, network_delegate,
+            request->context()->http_user_agent_settings());
       }
       // This job will result in error since the requested URL is not one of the
       // URLs supported by these tests.
       return new URLRequestTestJob(request, network_delegate, true);
     }
     if (!intercept_main_request_)
       return nullptr;
     intercept_main_request_ = false;
     did_intercept_main_ = true;
     URLRequestTestJob* job =  new URLRequestTestJob(request,
@@ skipping 11 matching lines @@
     if (cancel_redirect_request_) {
       cancel_redirect_request_ = false;
       did_cancel_redirect_ = true;
       return new CancelTestJob(request, network_delegate);
     }
     if (!intercept_redirect_)
       return nullptr;
     intercept_redirect_ = false;
     did_intercept_redirect_ = true;
     if (use_url_request_http_job_) {
-      return URLRequestHttpJob::Factory(request, network_delegate, "http");
+      return new URLRequestHttpJob(
+          request, network_delegate,
+          request->context()->http_user_agent_settings());
     }
     return new URLRequestTestJob(request,
                                  network_delegate,
                                  redirect_headers_,
                                  redirect_data_,
                                  true);
   }
 
   URLRequestJob* MaybeInterceptResponse(
       URLRequest* request,
       NetworkDelegate* network_delegate) const override {
     if (cancel_final_request_) {
       cancel_final_request_ = false;
       did_cancel_final_ = true;
       return new CancelTestJob(request, network_delegate);
     }
     if (!intercept_final_response_)
       return nullptr;
     intercept_final_response_ = false;
     did_intercept_final_ = true;
     if (use_url_request_http_job_) {
-      return URLRequestHttpJob::Factory(request, network_delegate, "http");
+      return new URLRequestHttpJob(
+          request, network_delegate,
+          request->context()->http_user_agent_settings());
     }
     return new URLRequestTestJob(request,
                                  network_delegate,
                                  final_headers_,
                                  final_data_,
                                  true);
   }
 
   void set_intercept_main_request(bool intercept_main_request) {
     intercept_main_request_ = intercept_main_request;
@@ skipping 780 matching lines @@
 // Start on it.
 TEST_F(URLRequestTest, SetJobPriorityBeforeJobStart) {
   TestDelegate d;
   std::unique_ptr<URLRequest> req(default_context_.CreateRequest(
       GURL("http://test_intercept/foo"), DEFAULT_PRIORITY, &d));
   EXPECT_EQ(DEFAULT_PRIORITY, req->priority());
 
   RequestPriority job_priority;
   std::unique_ptr<URLRequestJob> job(new PriorityMonitoringURLRequestJob(
       req.get(), &default_network_delegate_, &job_priority));
-  AddTestInterceptor()->set_main_intercept_job(std::move(job));
+  test_job_interceptor_->set_main_intercept_job(std::move(job));
   EXPECT_EQ(DEFAULT_PRIORITY, job_priority);
 
   req->SetPriority(LOW);
 
   req->Start();
   EXPECT_EQ(LOW, job_priority);
 }
 
 // Make sure that URLRequest passes on its priority updates to its
 // job.
 TEST_F(URLRequestTest, SetJobPriority) {
   TestDelegate d;
   std::unique_ptr<URLRequest> req(default_context_.CreateRequest(
       GURL("http://test_intercept/foo"), DEFAULT_PRIORITY, &d));
 
   RequestPriority job_priority;
   std::unique_ptr<URLRequestJob> job(new PriorityMonitoringURLRequestJob(
       req.get(), &default_network_delegate_, &job_priority));
-  AddTestInterceptor()->set_main_intercept_job(std::move(job));
+  test_job_interceptor_->set_main_intercept_job(std::move(job));
 
   req->SetPriority(LOW);
   req->Start();
   EXPECT_EQ(LOW, job_priority);
 
   req->SetPriority(MEDIUM);
   EXPECT_EQ(MEDIUM, req->priority());
   EXPECT_EQ(MEDIUM, job_priority);
 }
 
 // Setting the IGNORE_LIMITS load flag should be okay if the priority
 // is MAXIMUM_PRIORITY.
 TEST_F(URLRequestTest, PriorityIgnoreLimits) {
   TestDelegate d;
   std::unique_ptr<URLRequest> req(default_context_.CreateRequest(
       GURL("http://test_intercept/foo"), MAXIMUM_PRIORITY, &d));
   EXPECT_EQ(MAXIMUM_PRIORITY, req->priority());
 
   RequestPriority job_priority;
   std::unique_ptr<URLRequestJob> job(new PriorityMonitoringURLRequestJob(
       req.get(), &default_network_delegate_, &job_priority));
-  AddTestInterceptor()->set_main_intercept_job(std::move(job));
+  test_job_interceptor_->set_main_intercept_job(std::move(job));
 
   req->SetLoadFlags(LOAD_IGNORE_LIMITS);
   EXPECT_EQ(MAXIMUM_PRIORITY, req->priority());
 
   req->SetPriority(MAXIMUM_PRIORITY);
   EXPECT_EQ(MAXIMUM_PRIORITY, req->priority());
 
   req->Start();
   EXPECT_EQ(MAXIMUM_PRIORITY, req->priority());
   EXPECT_EQ(MAXIMUM_PRIORITY, job_priority);
@@ skipping 4523 matching lines @@
       http_test_server()->GetURL("/original#should-not-be-appended"));
   GURL redirect_url(http_test_server()->GetURL("/echo"));
 
   TestDelegate d;
   std::unique_ptr<URLRequest> r(
       default_context_.CreateRequest(original_url, DEFAULT_PRIORITY, &d));
 
   std::unique_ptr<URLRequestRedirectJob> job(new URLRequestRedirectJob(
       r.get(), &default_network_delegate_, redirect_url,
       URLRequestRedirectJob::REDIRECT_302_FOUND, "Very Good Reason"));
-  AddTestInterceptor()->set_main_intercept_job(std::move(job));
+  test_job_interceptor_->set_main_intercept_job(std::move(job));
 
   r->Start();
   base::RunLoop().Run();
 
   EXPECT_EQ(URLRequestStatus::SUCCESS, r->status().status());
   EXPECT_EQ(OK, r->status().error());
   EXPECT_EQ(original_url, r->original_url());
   EXPECT_EQ(redirect_url, r->url());
 }
 
@@ skipping 721 matching lines @@
   req->set_upload(CreateSimpleUploadData(kData));
   HttpRequestHeaders headers;
   headers.SetHeader(HttpRequestHeaders::kContentLength,
                     base::SizeTToString(arraysize(kData) - 1));
   req->SetExtraRequestHeaders(headers);
 
   std::unique_ptr<URLRequestRedirectJob> job(new URLRequestRedirectJob(
       req.get(), &default_network_delegate_,
       http_test_server()->GetURL("/echo"),
       URLRequestRedirectJob::REDIRECT_302_FOUND, "Very Good Reason"));
-  AddTestInterceptor()->set_main_intercept_job(std::move(job));
+  test_job_interceptor_->set_main_intercept_job(std::move(job));
 
   req->Start();
   base::RunLoop().Run();
   EXPECT_EQ("GET", req->method());
 }
 
 TEST_F(URLRequestTestHTTP, InterceptPost307RedirectPost) {
   ASSERT_TRUE(http_test_server()->Start());
 
   const char kData[] = "hello world";
 
   TestDelegate d;
   std::unique_ptr<URLRequest> req(default_context_.CreateRequest(
       http_test_server()->GetURL("/defaultresponse"), DEFAULT_PRIORITY, &d));
   req->set_method("POST");
   req->set_upload(CreateSimpleUploadData(kData));
   HttpRequestHeaders headers;
   headers.SetHeader(HttpRequestHeaders::kContentLength,
                     base::SizeTToString(arraysize(kData) - 1));
   req->SetExtraRequestHeaders(headers);
 
   std::unique_ptr<URLRequestRedirectJob> job(new URLRequestRedirectJob(
       req.get(), &default_network_delegate_,
       http_test_server()->GetURL("/echo"),
       URLRequestRedirectJob::REDIRECT_307_TEMPORARY_REDIRECT,
       "Very Good Reason"));
-  AddTestInterceptor()->set_main_intercept_job(std::move(job));
+  test_job_interceptor_->set_main_intercept_job(std::move(job));
 
   req->Start();
   base::RunLoop().Run();
   EXPECT_EQ("POST", req->method());
   EXPECT_EQ(kData, d.data_received());
 }
 
 // Check that default A-L header is sent.
 TEST_F(URLRequestTestHTTP, DefaultAcceptLanguage) {
   ASSERT_TRUE(http_test_server()->Start());
@@ skipping 179 matching lines @@
 
   TestDelegate d;
   std::unique_ptr<URLRequest> req(default_context_.CreateRequest(
       http_test_server()->GetURL("/defaultresponse"), DEFAULT_PRIORITY, &d));
   EXPECT_EQ(DEFAULT_PRIORITY, req->priority());
 
   std::unique_ptr<URLRequestRedirectJob> redirect_job(new URLRequestRedirectJob(
       req.get(), &default_network_delegate_,
       http_test_server()->GetURL("/echo"),
       URLRequestRedirectJob::REDIRECT_302_FOUND, "Very Good Reason"));
-  AddTestInterceptor()->set_main_intercept_job(std::move(redirect_job));
+  test_job_interceptor_->set_main_intercept_job(std::move(redirect_job));
 
   req->SetPriority(LOW);
   req->Start();
   EXPECT_TRUE(req->is_pending());
 
   RequestPriority job_priority;
   std::unique_ptr<URLRequestJob> job(new PriorityMonitoringURLRequestJob(
       req.get(), &default_network_delegate_, &job_priority));
-  AddTestInterceptor()->set_main_intercept_job(std::move(job));
+  test_job_interceptor_->set_main_intercept_job(std::move(job));
 
   // Should trigger |job| to be started.
   base::RunLoop().Run();
   EXPECT_EQ(LOW, job_priority);
 }
 
 // Check that creating a network request while entering/exiting suspend mode
 // fails as it should.  This is the only case where an HttpTransactionFactory
 // does not return an HttpTransaction.
 TEST_F(URLRequestTestHTTP, NetworkSuspendTest) {
@@ skipping 2336 matching lines @@
 // See http://crbug.com/508900
 TEST_F(URLRequestTest, URLRequestRedirectJobCancelRequest) {
   TestDelegate d;
   std::unique_ptr<URLRequest> req(default_context_.CreateRequest(
       GURL("http://not-a-real-domain/"), DEFAULT_PRIORITY, &d));
 
   std::unique_ptr<URLRequestRedirectJob> job(new URLRequestRedirectJob(
       req.get(), &default_network_delegate_,
       GURL("http://this-should-never-be-navigated-to/"),
       URLRequestRedirectJob::REDIRECT_307_TEMPORARY_REDIRECT, "Jumbo shrimp"));
-  AddTestInterceptor()->set_main_intercept_job(std::move(job));
+  test_job_interceptor_->set_main_intercept_job(std::move(job));
 
   req->Start();
   req->Cancel();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(URLRequestStatus::CANCELED, req->status().status());
   EXPECT_EQ(0, d.received_redirect_count());
 }
 
 }  // namespace net