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

net/http/http_stream_factory.h

Index: net/http/http_stream_factory.h
diff --git a/net/http/http_stream_factory.h b/net/http/http_stream_factory.h
index 231271dffe70cef2ab1c119b64e20d82bf8e8782..b1919b815608397e44a7953675e5027f2a647083 100644
--- a/net/http/http_stream_factory.h
+++ b/net/http/http_stream_factory.h
@@ -15,6 +15,7 @@
 #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"
@@ -84,6 +85,10 @@ class NET_EXPORT_PRIVATE HttpStreamRequest {
         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
@@ -222,6 +227,16 @@ class NET_EXPORT HttpStreamFactory {
       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,