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/quic/quic_server_id.h"
+#include "net/spdy/bidirectional_stream_spdy_job.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::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.
+
+  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, 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, Request::HTTP_STREAM);
   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, delegate);
 
   if (!alternative_service_vector.empty()) {
     // TODO(bnc): Pass on multiple alternative services to Job.
     const AlternativeService& alternative_service =
@@ skipping 165 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()) {
+      request->OnBidirectionalStreamJobReady(
+          nullptr, used_ssl_config, used_proxy_info,
+          new BidirectionalStreamSpdyJob(spdy_session));

[mmenke, 2015/12/16 23:04:37]

While the code this adds isn't huge, can we prevent it from being included in
Chrome binaries?  Compilers aren't nearly smart enough to know this is never
reached.  Maybe an if-def?  If not defined, just have this do nothing (Or be a
DCHECK) and have RequestBidirectionalStreamJob just have a NOTREACHED?  Would
also need to exclude the unit tests based on that define.

[xunjieli, 2015/12/17 18:18:55]

Done.

     } 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