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

net/http/http_stream_factory.h

 // 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.
 
 #ifndef NET_HTTP_HTTP_STREAM_FACTORY_H_
 #define NET_HTTP_HTTP_STREAM_FACTORY_H_
 
 #include <list>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
 #include "base/strings/string16.h"
 #include "net/base/completion_callback.h"
 #include "net/base/load_states.h"
 #include "net/base/net_export.h"
 #include "net/base/request_priority.h"
+#include "net/http/bidirectional_stream.h"
 #include "net/http/http_server_properties.h"
 #include "net/socket/connection_attempts.h"
 #include "net/ssl/ssl_failure_state.h"
 // This file can be included from net/http even though
 // it is in net/websockets because it doesn't
 // introduce any link dependency to net/websockets.
 #include "net/websockets/websocket_handshake_stream_base.h"
 
 class GURL;
 
@@ skipping 49 matching lines @@
     // |used_ssl_config| indicates the actual SSL configuration used for this
     // stream, since the HttpStreamRequest may have modified the configuration
     // during stream processing.
     // |used_proxy_info| indicates the actual ProxyInfo used for this stream,
     // since the HttpStreamRequest performs the proxy resolution.
     virtual void OnWebSocketHandshakeStreamReady(
         const SSLConfig& used_ssl_config,
         const ProxyInfo& used_proxy_info,
         WebSocketHandshakeStreamBase* stream) = 0;
 
+    virtual void OnBidirectionalStreamReady(const SSLConfig& used_ssl_config,
+                                            const ProxyInfo& used_proxy_info,
+                                            BidirectionalStream* stream) = 0;
+
     // This is the failure to create a stream case.
     // |used_ssl_config| indicates the actual SSL configuration used for this
     // stream, since the HttpStreamRequest may have modified the configuration
     // during stream processing. If an SSL handshake failed, |ssl_failure_state|
     // is the state the SSLClientSocket was in.
     virtual void OnStreamFailed(int status,
                                 const SSLConfig& used_ssl_config,
                                 SSLFailureState ssl_failure_state) = 0;
 
     // Called when we have a certificate error for the request.
@@ skipping 118 matching lines @@
   // completion.
   virtual HttpStreamRequest* RequestWebSocketHandshakeStream(
       const HttpRequestInfo& info,
       RequestPriority priority,
       const SSLConfig& server_ssl_config,
       const SSLConfig& proxy_ssl_config,
       HttpStreamRequest::Delegate* delegate,
       WebSocketHandshakeStreamBase::CreateHelper* create_helper,
       const BoundNetLog& net_log) = 0;
 
+  // Will call delegate->OnBidirectionalStreamReady on successful
+  // completion.
+  virtual HttpStreamRequest* RequestBidirectionalStream(
+      const HttpRequestInfo& info,
+      RequestPriority priority,
+      const SSLConfig& server_ssl_config,
+      const SSLConfig& proxy_ssl_config,
+      HttpStreamRequest::Delegate* delegate,
+      const BoundNetLog& net_log) = 0;

[mmenke, 2015/10/07 18:43:33]

Unlike the two above methods, BidirectionalStreams are top level objects, which
makes them rather different, from a logging standpoint.  For normal requests,
the BoundNetLog comes from the NetworkTransaction (Actually, the URLRequest
created it).  The HttpStreamFactoryImpl::Job uses the BoundNetLog to associate
the job with the event that created it.  When done, the NetworkTransaction also
passes the same BoundNetLog to the BidirectionalStream.

What's different here is the BidirectionalStreams this method creates are the
top level object.  Note also that this class is "NET_EXPORT_PRIVATE" - it's not
currently used by anything outside net.

So what does that all mean?  We still need to figure out how we want these to be
created.

We could create a higher level class which creates and wraps the
bidirectionalstream, and returns an error if it fails to create one.  This does
need a silly wrapper class, but it has some nice features - if the top level
object is destroyed, we can just cancel the stream request, for instance.

Or we could do something like
"NetworkSession::CreateBidirectionStream(RequestInfo [Or components of it],
priority, callback);" and then make the embedder responsible for starting it. 
The NetworkSession would create the stream and create a BoundNetLog for it.

Or we could do something like
"NetworkSession::CreateBidirectionStream(RequestInfo, priority,
BidirectionalStream::Delegate);" This is kind of weird in that we'd be calling
the stream's delegate's OnFailed callback in the case we didn't even create a
stream.

The latter two methods would also need a way to cancel the request (Maybe create
a BidirecitonalStreamRequest object, which could be destroyed?).  I'm leaning a
little towards the first option - it's more like how URLRequest works, and
discourages playing with the NetworkSession directly, which I think are nice
features.

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

Talked to Matt offline on this. I added a wrapper class to address this issues
brought up in this comment.

+
   // Requests that enough connections for |num_streams| be opened.
   virtual void PreconnectStreams(int num_streams,
                                  const HttpRequestInfo& info,
                                  const SSLConfig& server_ssl_config,
                                  const SSLConfig& proxy_ssl_config) = 0;
 
   virtual const HostMappingRules* GetHostMappingRules() const = 0;
 
   // Static settings
 
@@ skipping 15 matching lines @@
   static bool spdy_enabled_;
 
   HostPortPair RewriteHost(HostPortPair host_port_pair);
 
   DISALLOW_COPY_AND_ASSIGN(HttpStreamFactory);
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_HTTP_STREAM_FACTORY_H_