Implement QUIC-based net::BidirectionalStream

net/http/http_stream_factory_impl.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/http/http_stream_factory_impl.h"
 
 #include <string>
 
 #include "base/logging.h"
 #include "base/stl_util.h"
@@ skipping 36 matching lines @@
 }
 
 HttpStreamRequest* HttpStreamFactoryImpl::RequestStream(
     const HttpRequestInfo& request_info,
     RequestPriority priority,
     const SSLConfig& server_ssl_config,
     const SSLConfig& proxy_ssl_config,
     HttpStreamRequest::Delegate* delegate,
     const BoundNetLog& net_log) {
   DCHECK(!for_websockets_);
-  return RequestStreamInternal(request_info,
-                               priority,
-                               server_ssl_config,
-                               proxy_ssl_config,
-                               delegate,
-                               NULL,
+  return RequestStreamInternal(request_info, priority, server_ssl_config,
+                               proxy_ssl_config, delegate, nullptr, false,

[Ryan Hamilton, 2016/02/27 00:21:14]

"false" is not super readable here ("what is false?") How about:

/*for_bidirecitonal=*/false

(and elsewhere)

[xunjieli, 2016/02/29 15:21:37]

Done.

                                net_log);
 }
 
 HttpStreamRequest* HttpStreamFactoryImpl::RequestWebSocketHandshakeStream(
     const HttpRequestInfo& request_info,
     RequestPriority priority,
     const SSLConfig& server_ssl_config,
     const SSLConfig& proxy_ssl_config,
     HttpStreamRequest::Delegate* delegate,
     WebSocketHandshakeStreamBase::CreateHelper* create_helper,
     const BoundNetLog& net_log) {
   DCHECK(for_websockets_);
   DCHECK(create_helper);
-  return RequestStreamInternal(request_info,
-                               priority,
-                               server_ssl_config,
-                               proxy_ssl_config,
-                               delegate,
-                               create_helper,
+  return RequestStreamInternal(request_info, priority, server_ssl_config,
+                               proxy_ssl_config, delegate, create_helper, false,
                                net_log);
 }
 
 HttpStreamRequest* HttpStreamFactoryImpl::RequestBidirectionalStreamJob(
     const HttpRequestInfo& request_info,
     RequestPriority priority,
     const SSLConfig& server_ssl_config,
     const SSLConfig& proxy_ssl_config,
     HttpStreamRequest::Delegate* delegate,
     const BoundNetLog& net_log) {
   DCHECK(!for_websockets_);
   DCHECK(request_info.url.SchemeIs(url::kHttpsScheme));
 
-// TODO(xunjieli): Create QUIC's version of BidirectionalStreamJob.
-#if BUILDFLAG(ENABLE_BIDIRECTIONAL_STREAM)
-  HostPortPair server = HostPortPair::FromURL(request_info.url);
-  GURL origin_url = ApplyHostMappingRules(request_info.url, &server);
-  Request* request =
-      new Request(request_info.url, this, delegate, nullptr, net_log,
-                  Request::BIDIRECTIONAL_STREAM_SPDY_JOB);
-  Job* job = new Job(this, session_, request_info, priority, server_ssl_config,
-                     proxy_ssl_config, server, origin_url, net_log.net_log());
-  request->AttachJob(job);
-
-  job->Start(request);
-  return request;
-
-#else
-  DCHECK(false);
-  return nullptr;
-#endif
+  return RequestStreamInternal(request_info, priority, server_ssl_config,
+                               proxy_ssl_config, delegate, nullptr,
+                               /*for_bidirectional=*/true, net_log);
 }
 
 HttpStreamRequest* HttpStreamFactoryImpl::RequestStreamInternal(
     const HttpRequestInfo& request_info,
     RequestPriority priority,
     const SSLConfig& server_ssl_config,
     const SSLConfig& proxy_ssl_config,
     HttpStreamRequest::Delegate* delegate,
     WebSocketHandshakeStreamBase::CreateHelper*
         websocket_handshake_stream_create_helper,
+    bool for_bidirectional,
     const BoundNetLog& net_log) {
-  Request* request = new Request(request_info.url, this, delegate,
-                                 websocket_handshake_stream_create_helper,
-                                 net_log, Request::HTTP_STREAM);
+  Request* request =
+      new Request(request_info.url, this, delegate,
+                  websocket_handshake_stream_create_helper, net_log,
+                  for_bidirectional ? Request::BIDIRECTIONAL_STREAM_SPDY_JOB
+                                    : Request::HTTP_STREAM);

[Ryan Hamilton, 2016/02/27 00:21:14]

oh, since you already have an enum, just do that instead of the bool. That'll
make the literals easy to read.

[xunjieli, 2016/02/29 15:21:37]

Done. Great idea!

   HostPortPair server = HostPortPair::FromURL(request_info.url);
   GURL origin_url = ApplyHostMappingRules(request_info.url, &server);
 
   Job* job = new Job(this, session_, request_info, priority, server_ssl_config,
                      proxy_ssl_config, server, origin_url, net_log.net_log());
   request->AttachJob(job);
 
   const AlternativeService alternative_service =
       GetAlternativeServiceFor(request_info, delegate);
 
@@ skipping 232 matching lines @@
 
 bool HttpStreamFactoryImpl::IsQuicWhitelistedForHost(const std::string& host) {
   if (session_->params().transport_security_state->IsGooglePinnedHost(host))
     return true;
 
   return ContainsKey(session_->params().quic_host_whitelist,
                      base::ToLowerASCII(host));
 }
 
 }  // namespace net