Added a net::BidirectionalStream to expose a bidirectional streaming interface

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"
 #include "net/base/net_util.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_server_properties.h"
 #include "net/http/http_stream_factory_impl_job.h"
 #include "net/http/http_stream_factory_impl_request.h"
 #include "net/log/net_log.h"
+#include "net/spdy/bidirectional_spdy_stream.h"
 #include "net/spdy/spdy_http_stream.h"
 #include "url/gurl.h"
 
 namespace net {
 
 HttpStreamFactoryImpl::HttpStreamFactoryImpl(HttpNetworkSession* session,
                                              bool for_websockets)
     : session_(session),
       for_websockets_(for_websockets) {}
 
@@ skipping 41 matching lines @@
   DCHECK(create_helper);
   return RequestStreamInternal(request_info,
                                priority,
                                server_ssl_config,
                                proxy_ssl_config,
                                delegate,
                                create_helper,
                                net_log);
 }
 
+HttpStreamRequest* HttpStreamFactoryImpl::RequestBidirectionalStream(
+    const HttpRequestInfo& request_info,
+    RequestPriority priority,
+    const SSLConfig& server_ssl_config,
+    const SSLConfig& proxy_ssl_config,
+    HttpStreamRequest::Delegate* delegate,
+    const BoundNetLog& net_log) {

[mmenke, 2015/10/08 19:31:53]

DCHECK the scheme is HTTPS?

[xunjieli, 2015/10/19 21:07:46]

Done.

+  DCHECK(!for_websockets_);
+  Request* request = new Request(request_info.url, this, delegate, nullptr,
+                                 net_log, true /** for_bidirectional */);

[mmenke, 2015/10/08 19:31:53]

I'm no HTTP2 expert, but it's my understanding that an HTTP/1.x server to
advertise another server for HTTP2, in which case, the alternative job in
HttpStreamFactoryImpl::RequestStreamInternal will actually produce an HTTP2
session, while the main job may (?) produce an HTTP/1.x one.  The life of a
URLRequest doc gets this wrong (Been meaning to fix it, but I don't have a great
understanding of this code).

[xunjieli, 2015/10/19 21:07:46]

Acknowledged. Here we don't use RequestStreamInternal. I was assuming that gRPC
will issue the request directly to a HTTP/2 server.

+  Job* job = new Job(this, session_, request_info, priority, server_ssl_config,
+                     proxy_ssl_config, net_log.net_log());
+  request->AttachJob(job);
+
+  job->Start(request);
+  return request;
+}
+
 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,
     const BoundNetLog& net_log) {
-  Request* request = new Request(request_info.url,
-                                 this,
-                                 delegate,
+  Request* request = new Request(request_info.url, this, delegate,
                                  websocket_handshake_stream_create_helper,
-                                 net_log);
+                                 net_log, false /** for_bidirectional */);
   Job* job = new Job(this, session_, request_info, priority, server_ssl_config,
                      proxy_ssl_config, net_log.net_log());
   request->AttachJob(job);
 
   const AlternativeServiceVector alternative_service_vector =
       GetAlternativeServicesFor(request_info.url);
   if (!alternative_service_vector.empty()) {
     // TODO(bnc): Pass on multiple alternative services to Job.
     const AlternativeService& alternative_service =
         alternative_service_vector[0];
@@ skipping 151 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->for_bidirectional()) {
+      // TODO(xunjieli): Enable creation of QUIC's version of
+      // BidirectionalStream.

[mmenke, 2015/10/08 19:31:53]

This seems the wrong place for this comment.  Maybe in
RequestBidirectionalStream above?

[xunjieli, 2015/10/19 21:07:46]

Done.

+      request->OnBidirectionalStreamReady(
+          nullptr, used_ssl_config, used_proxy_info,
+          new BidirectionalSpdyStream(spdy_session));
     } else {
       bool use_relative_url = direct || request->url().SchemeIs("https");
       request->OnStreamReady(
-          NULL,
-          used_ssl_config,
-          used_proxy_info,
+          nullptr, used_ssl_config, used_proxy_info,
           new SpdyHttpStream(spdy_session, use_relative_url));
     }
   }
   // TODO(mbelshe): Alert other valid requests.
 }
 
 void HttpStreamFactoryImpl::OnOrphanedJobComplete(const Job* job) {
   orphaned_job_set_.erase(job);
   delete job;
 }
 
 void HttpStreamFactoryImpl::OnPreconnectsComplete(const Job* job) {
   preconnect_job_set_.erase(job);
   delete job;
   OnPreconnectsCompleteInternal();
 }
 
 }  // namespace net