Revert of 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, nullptr,
-                               HttpStreamRequest::HTTP_STREAM, net_log);
+  return RequestStreamInternal(request_info,
+                               priority,
+                               server_ssl_config,
+                               proxy_ssl_config,
+                               delegate,
+                               NULL,
+                               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,
-                               HttpStreamRequest::HTTP_STREAM, net_log);
+  return RequestStreamInternal(request_info,
+                               priority,
+                               server_ssl_config,
+                               proxy_ssl_config,
+                               delegate,
+                               create_helper,
+                               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));
 
-  return RequestStreamInternal(
-      request_info, priority, server_ssl_config, proxy_ssl_config, delegate,
-      nullptr, HttpStreamRequest::BIDIRECTIONAL_STREAM, net_log);
+// 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
 }
 
 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,
-    HttpStreamRequest::StreamType stream_type,
     const BoundNetLog& net_log) {
   Request* request = new Request(request_info.url, this, delegate,
                                  websocket_handshake_stream_create_helper,
-                                 net_log, stream_type);
+                                 net_log, Request::HTTP_STREAM);
   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 194 matching lines @@
     // queue (Order by priority first, then FIFO within same priority). Unclear
     // that it matters here.
     if (!ContainsKey(spdy_session_request_map_, spdy_session_key))
       break;
     Request* request = *spdy_session_request_map_[spdy_session_key].begin();
     request->Complete(was_npn_negotiated, protocol_negotiated, using_spdy);
     if (for_websockets_) {
       // TODO(ricea): Restore this code path when WebSocket over SPDY
       // implementation is ready.
       NOTREACHED();
-    } else if (request->stream_type() ==
-               HttpStreamRequest::BIDIRECTIONAL_STREAM) {
+    } else if (request->for_bidirectional()) {
 #if BUILDFLAG(ENABLE_BIDIRECTIONAL_STREAM)
       request->OnBidirectionalStreamJobReady(
           nullptr, used_ssl_config, used_proxy_info,
           new BidirectionalStreamSpdyJob(spdy_session));
 #else
       DCHECK(false);
 #endif
     } else {
       bool use_relative_url = direct || request->url().SchemeIs("https");
       request->OnStreamReady(
@@ skipping 29 matching lines @@
     return true;
 
   if (session_->params().transport_security_state->IsGooglePinnedHost(host))
     return true;
 
   return ContainsKey(session_->params().quic_host_whitelist,
                      base::ToLowerASCII(host));
 }
 
 }  // namespace net