Add HttpProtocolHandler and convert everything to use it

net/url_request/url_request_context_builder.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 "net/url_request/url_request_context_builder.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 22 matching lines @@
 #include "net/http/http_network_layer.h"
 #include "net/http/http_server_properties_impl.h"
 #include "net/http/http_server_properties_manager.h"
 #include "net/http/transport_security_persister.h"
 #include "net/http/transport_security_state.h"
 #include "net/quic/chromium/quic_stream_factory.h"
 #include "net/ssl/channel_id_service.h"
 #include "net/ssl/default_channel_id_store.h"
 #include "net/ssl/ssl_config_service_defaults.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_context.h"
 #include "net/url_request/url_request_context_storage.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_throttler_manager.h"
 
 #if !defined(DISABLE_FILE_SUPPORT)
 #include "net/url_request/file_protocol_handler.h"  // nogncheck
@@ skipping 422 matching lines @@
     }
 
     http_transaction_factory.reset(new HttpCache(
         storage->http_network_session(), std::move(http_cache_backend), true));
   } else {
     http_transaction_factory.reset(
         new HttpNetworkLayer(storage->http_network_session()));
   }
   storage->set_http_transaction_factory(std::move(http_transaction_factory));
 
-  URLRequestJobFactoryImpl* job_factory = new URLRequestJobFactoryImpl;
+  std::unique_ptr<URLRequestJobFactoryImpl> job_factory =
+      base::WrapUnique(new URLRequestJobFactoryImpl);
   // Adds caller-provided protocol handlers first so that these handlers are
-  // used over data/file/ftp handlers below.
+  // used over http/ws/data/file/ftp handlers below.
   for (auto& scheme_handler : protocol_handlers_) {
     job_factory->SetProtocolHandler(scheme_handler.first,
                                     std::move(scheme_handler.second));
   }
   protocol_handlers_.clear();
 
+  job_factory->SetProtocolHandler("http",
+                                  base::WrapUnique(new HttpProtocolHandler));
+  job_factory->SetProtocolHandler("https",
+                                  base::WrapUnique(new HttpProtocolHandler));
+
+#if !defined(OS_IOS)
+  job_factory->SetProtocolHandler("ws",
+                                  base::WrapUnique(new HttpProtocolHandler));
+  job_factory->SetProtocolHandler("wss",
+                                  base::WrapUnique(new HttpProtocolHandler));
+#endif  // !defined(OS_IOS)
+
   if (data_enabled_)
     job_factory->SetProtocolHandler("data",
                                     base::WrapUnique(new DataProtocolHandler));
 
 #if !defined(DISABLE_FILE_SUPPORT)
   if (file_enabled_) {
     job_factory->SetProtocolHandler(
         "file",
         base::MakeUnique<FileProtocolHandler>(context->GetFileTaskRunner()));
   }
 #endif  // !defined(DISABLE_FILE_SUPPORT)
 
 #if !defined(DISABLE_FTP_SUPPORT)
   if (ftp_enabled_) {
     ftp_transaction_factory_.reset(
         new FtpNetworkLayer(context->host_resolver()));
     job_factory->SetProtocolHandler("ftp", base::MakeUnique<FtpProtocolHandler>(
                                                ftp_transaction_factory_.get()));
   }
 #endif  // !defined(DISABLE_FTP_SUPPORT)
 
-  std::unique_ptr<net::URLRequestJobFactory> top_job_factory(job_factory);
+  std::unique_ptr<net::URLRequestJobFactory> top_job_factory =
+      std::move(job_factory);
+
   if (!url_request_interceptors_.empty()) {
     // Set up interceptors in the reverse order.
 
     for (auto i = url_request_interceptors_.rbegin();
          i != url_request_interceptors_.rend(); ++i) {
       top_job_factory.reset(new net::URLRequestInterceptingJobFactory(
           std::move(top_job_factory), std::move(*i)));
     }
     url_request_interceptors_.clear();
   }
   storage->set_job_factory(std::move(top_job_factory));
   // TODO(willchan): Support sdch.
 
   return std::move(context);
 }
 
 }  // namespace net