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..dda420d67fad547130f6ee6d349ab836cd1eaaf0 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_job.h"
+#endif
+
 using std::min;
 using NetworkHandle = net::NetworkChangeNotifier::NetworkHandle;
 
@@ -496,13 +501,12 @@ int QuicStreamFactory::Job::DoConnectComplete(int rv) {
 }
 
 QuicStreamRequest::QuicStreamRequest(QuicStreamFactory* factory)
-    : factory_(factory) {}
+    : factory_(factory), for_bidirectional_(false) {}
 
 QuicStreamRequest::~QuicStreamRequest() {
   if (factory_ && !callback_.is_null())
     factory_->CancelRequest(this);
 }
-
 int QuicStreamRequest::Request(const HostPortPair& host_port_pair,
                                PrivacyMode privacy_mode,
                                int cert_verify_flags,
@@ -510,11 +514,28 @@ int QuicStreamRequest::Request(const HostPortPair& host_port_pair,
                                base::StringPiece method,
                                const BoundNetLog& net_log,
                                const CompletionCallback& callback) {
+  return Request(host_port_pair, privacy_mode, cert_verify_flags, origin_host,
+                 method, net_log, callback, false);
+}
+
+int QuicStreamRequest::Request(const HostPortPair& host_port_pair,
+                               PrivacyMode privacy_mode,
+                               int cert_verify_flags,
+                               base::StringPiece origin_host,
+                               base::StringPiece method,
+                               const BoundNetLog& net_log,
+                               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 +545,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 BidirectionalStreamQuicJob(session->GetWeakPtr()));
+#else
+    DCHECK(false);
+#endif

[Ryan Hamilton, 2016/02/27 00:21:14]

I find this maze of ifdefs exceptionally hard to read. I think we need to back
up and see if we can find a different solution.

[xunjieli, 2016/02/29 15:21:37]

Acknowledged.

+  } else {
+    stream_.reset(new QuicHttpStream(session->GetWeakPtr()));
+  }
 }
 
 void QuicStreamRequest::OnRequestComplete(int rv) {
@@ -548,9 +584,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 +819,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 +875,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 +953,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;
     }
   }