Implement QUIC-based net::BidirectionalStream

net/quic/quic_stream_factory.cc

Index: net/quic/quic_stream_factory.cc
diff --git a/net/quic/quic_stream_factory.cc b/net/quic/quic_stream_factory.cc
index 61af6c27e2248687a9380c61ebbd3f98671ffcad..8b72643e810edabfe100c24659dd9e6b20c81e2d 100644
--- a/net/quic/quic_stream_factory.cc
+++ b/net/quic/quic_stream_factory.cc
@@ -59,6 +59,11 @@
 #include "base/cpu.h"
 #endif
 
+#if BUILDFLAG(ENABLE_BIDIRECTIONAL_STREAM)
+#include "net/http/bidirectional_stream_job.h"
+#include "net/quic/bidirectional_stream_quic_impl.h"
+#endif
+
 using std::min;
 using NetworkHandle = net::NetworkChangeNotifier::NetworkHandle;
 
@@ -496,7 +501,7 @@ int QuicStreamFactory::Job::DoConnectComplete(int rv) {
 }
 
 QuicStreamRequest::QuicStreamRequest(QuicStreamFactory* factory)
-    : factory_(factory) {}
+    : factory_(factory), for_bidirectional_(false) {}
 
 QuicStreamRequest::~QuicStreamRequest() {
   if (factory_ && !callback_.is_null())
@@ -509,12 +514,18 @@ int QuicStreamRequest::Request(const HostPortPair& host_port_pair,
                                base::StringPiece origin_host,
                                base::StringPiece method,
                                const BoundNetLog& net_log,
-                               const CompletionCallback& callback) {
+                               const CompletionCallback& callback,
+                               bool for_bidirectional) {
   DCHECK(!stream_);
+#if BUILDFLAG(ENABLE_BIDIRECTIONAL_STREAM)
+  DCHECK(!bidirectional_stream_job_);
+#endif
   DCHECK(callback_.is_null());
   DCHECK(factory_);
   origin_host_ = origin_host.as_string();
   privacy_mode_ = privacy_mode;
+  for_bidirectional_ = for_bidirectional;
+
   int rv = factory_->Create(host_port_pair, privacy_mode, cert_verify_flags,
                             origin_host, method, net_log, this);
   if (rv == ERR_IO_PENDING) {
@@ -524,14 +535,29 @@ int QuicStreamRequest::Request(const HostPortPair& host_port_pair,
   } else {
     factory_ = nullptr;
   }
-  if (rv == OK)
+  if (rv == OK) {
+#if BUILDFLAG(ENABLE_BIDIRECTIONAL_STREAM)
+    DCHECK(stream_ || (for_bidirectional_ && bidirectional_stream_job_));
+#else
     DCHECK(stream_);
+#endif
+  }
   return rv;
 }
 
-void QuicStreamRequest::set_stream(scoped_ptr<QuicHttpStream> stream) {
-  DCHECK(stream);
-  stream_ = std::move(stream);
+void QuicStreamRequest::InitializeStreamFromSession(
+    QuicChromiumClientSession* session) {
+  DCHECK(session);
+  if (for_bidirectional_) {
+#if BUILDFLAG(ENABLE_BIDIRECTIONAL_STREAM)
+    bidirectional_stream_job_.reset(
+        new BidirectionalStreamQuicImpl(session->GetWeakPtr()));
+#else
+    DCHECK(false);
+#endif
+  } else {
+    stream_.reset(new QuicHttpStream(session->GetWeakPtr()));
+  }
 }
 
 void QuicStreamRequest::OnRequestComplete(int rv) {
@@ -548,9 +574,20 @@ base::TimeDelta QuicStreamRequest::GetTimeDelayForWaitingJob() const {
 
 scoped_ptr<QuicHttpStream> QuicStreamRequest::ReleaseStream() {
   DCHECK(stream_);
+  DCHECK(!for_bidirectional_);
   return std::move(stream_);
 }
 
+#if BUILDFLAG(ENABLE_BIDIRECTIONAL_STREAM)
+scoped_ptr<BidirectionalStreamJob>
+QuicStreamRequest::ReleaseBidirectionalStreamJob() {
+  DCHECK(bidirectional_stream_job_);
+  DCHECK(for_bidirectional_);
+
+  return std::move(bidirectional_stream_job_);
+}
+#endif
+
 QuicStreamFactory::QuicStreamFactory(
     HostResolver* host_resolver,
     ClientSocketFactory* client_socket_factory,
@@ -772,7 +809,7 @@ int QuicStreamFactory::Create(const HostPortPair& host_port_pair,
       QuicChromiumClientSession* session = it->second;
       if (!session->CanPool(origin_host.as_string(), privacy_mode))
         return ERR_ALTERNATIVE_CERT_NOT_VALID_FOR_ORIGIN;
-      request->set_stream(CreateFromSession(session));
+      request->InitializeStreamFromSession(session);
       return OK;
     }
   }
@@ -828,7 +865,7 @@ int QuicStreamFactory::Create(const HostPortPair& host_port_pair,
     QuicChromiumClientSession* session = it->second;
     if (!session->CanPool(origin_host.as_string(), privacy_mode))
       return ERR_ALTERNATIVE_CERT_NOT_VALID_FOR_ORIGIN;
-    request->set_stream(CreateFromSession(session));
+    request->InitializeStreamFromSession(session);
   }
   return rv;
 }
@@ -906,7 +943,7 @@ void QuicStreamFactory::OnJobComplete(Job* job, int rv) {
         request->OnRequestComplete(ERR_ALTERNATIVE_CERT_NOT_VALID_FOR_ORIGIN);
         continue;
       }
-      request->set_stream(CreateFromSession(session));
+      request->InitializeStreamFromSession(session);
       ++request_it;
     }
   }