Implement QUIC-based net::BidirectionalStream

net/http/http_stream_factory_impl_job.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_job.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 
@@ skipping 997 matching lines @@
       if (session_->quic_stream_factory()->IsQuicDisabled(destination.port()))
         return ERR_QUIC_PROTOCOL_ERROR;
     } else {
       DCHECK(using_ssl_);
       // The certificate of a QUIC alternative server is expected to be valid
       // for the origin of the request (in addition to being valid for the
       // server itself).
       destination = server_;
       ssl_config = &server_ssl_config_;
     }
-
-    int rv =
-        quic_request_.Request(destination, request_info_.privacy_mode,
-                              ssl_config->GetCertVerifyFlags(), url,
-                              request_info_.method, net_log_, io_callback_);
+    int rv = quic_request_.Request(destination, request_info_.privacy_mode,
+                                   ssl_config->GetCertVerifyFlags(), url,
+                                   request_info_.method, net_log_, io_callback_,
+                                   for_bidirectional_);

[Ryan Hamilton, 2016/03/03 04:14:57]

Let's use HttpStreamRequest::StreamType stream_type instead off bool
for_bidirectional.

[xunjieli, 2016/03/03 16:54:19]

Done.

     if (rv == OK) {
       using_existing_quic_session_ = true;
     } else {
       // OK, there's no available QUIC session. Let |waiting_job_| resume
       // if it's paused.
       if (waiting_job_) {
         if (rv == ERR_IO_PENDING) {
           // Start the |waiting_job_| after the delay returned by
           // GetTimeDelayForWaitingJob().
           //
@@ skipping 217 matching lines @@
     MaybeMarkAlternativeServiceBroken();
     return result;
   }
 
   if (using_quic_) {
     if (result < 0) {
       job_status_ = STATUS_BROKEN;
       MaybeMarkAlternativeServiceBroken();
       return result;
     }
-    stream_ = quic_request_.ReleaseStream();
+    if (for_bidirectional_) {
+#if BUILDFLAG(ENABLE_BIDIRECTIONAL_STREAM)
+      bidirectional_stream_job_ = quic_request_.ReleaseBidirectionalStreamJob();
+#else
+      NOTREACHED();
+#endif

[Ryan Hamilton, 2016/03/03 04:14:57]

I don't want to keep harping on this, but this is SO ugly. Here we have a mix of
an always-compiled boolean, which triggers an ifdef-only codepath. This just
feels so gross. Who can we talk to about revisiting the decision to ifdef this?

[xunjieli, 2016/03/03 16:54:19]

After changing for_bidirectional_ to the enum, is this slightly better?

+    } else {
+      stream_ = quic_request_.ReleaseStream();
+    }
     next_state_ = STATE_NONE;
     return OK;
   }
 
   if (result < 0 && !ssl_started)
     return ReconsiderProxyAfterError(result);
   establishing_tunnel_ = false;
 
   if (connection_->socket()) {
     // We officially have a new connection.  Record the type.
@@ skipping 527 matching lines @@
   if (connection_->socket()) {
     ConnectionAttempts socket_attempts;
     connection_->socket()->GetConnectionAttempts(&socket_attempts);
     request_->AddConnectionAttempts(socket_attempts);
   } else {
     request_->AddConnectionAttempts(connection_->connection_attempts());
   }
 }
 
 }  // namespace net