Implement QUIC-based net::BidirectionalStream

net/http/http_stream_factory_impl_request.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_request.h"
 
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "net/http/http_stream_factory_impl_job.h"
@@ skipping 17 matching lines @@
     : url_(url),
       factory_(factory),
       websocket_handshake_stream_create_helper_(
           websocket_handshake_stream_create_helper),
       delegate_(delegate),
       net_log_(net_log),
       completed_(false),
       was_npn_negotiated_(false),
       protocol_negotiated_(kProtoUnknown),
       using_spdy_(false),
-      for_bidirectional_(stream_type == BIDIRECTIONAL_STREAM_SPDY_JOB) {
+      stream_type_(stream_type) {
   DCHECK(factory_);
   DCHECK(delegate_);
 
   net_log_.BeginEvent(NetLog::TYPE_HTTP_STREAM_REQUEST);
 }
 
 HttpStreamFactoryImpl::Request::~Request() {
   if (bound_job_.get())
     DCHECK(jobs_.empty());
 
@@ skipping 27 matching lines @@
   protocol_negotiated_ = protocol_negotiated;
   using_spdy_ = using_spdy;
 }
 
 void HttpStreamFactoryImpl::Request::OnStreamReady(
     Job* job,
     const SSLConfig& used_ssl_config,
     const ProxyInfo& used_proxy_info,
     HttpStream* stream) {
   DCHECK(!factory_->for_websockets_);
-  DCHECK(!for_bidirectional_);
+  DCHECK_EQ(HttpStreamRequest::HTTP_STREAM, stream_type_);
   DCHECK(stream);
   DCHECK(completed_);
 
   OnJobSucceeded(job);
   delegate_->OnStreamReady(used_ssl_config, used_proxy_info, stream);
 }
 
 void HttpStreamFactoryImpl::Request::OnBidirectionalStreamJobReady(
     Job* job,
     const SSLConfig& used_ssl_config,
     const ProxyInfo& used_proxy_info,
     BidirectionalStreamJob* stream_job) {
   DCHECK(!factory_->for_websockets_);
-  DCHECK(for_bidirectional_);
+  DCHECK_EQ(HttpStreamRequest::BIDIRECTIONAL_STREAM, stream_type_);
   DCHECK(stream_job);
   DCHECK(completed_);
 
   OnJobSucceeded(job);
   delegate_->OnBidirectionalStreamJobReady(used_ssl_config, used_proxy_info,
                                            stream_job);
 }
 
 void HttpStreamFactoryImpl::Request::OnWebSocketHandshakeStreamReady(
     Job* job,
     const SSLConfig& used_ssl_config,
     const ProxyInfo& used_proxy_info,
     WebSocketHandshakeStreamBase* stream) {
   DCHECK(factory_->for_websockets_);
-  DCHECK(!for_bidirectional_);
+  DCHECK_EQ(HttpStreamRequest::HTTP_STREAM, stream_type_);
   DCHECK(stream);
   DCHECK(completed_);
 
   OnJobSucceeded(job);
   delegate_->OnWebSocketHandshakeStreamReady(
       used_ssl_config, used_proxy_info, stream);
 }
 
 void HttpStreamFactoryImpl::Request::OnStreamFailed(
     Job* job,
@@ skipping 181 matching lines @@
   const BoundNetLog net_log = job->net_log();
 
   Complete(was_npn_negotiated, protocol_negotiated, using_spdy);
 
   // Cache this so we can still use it if the request is deleted.
   HttpStreamFactoryImpl* factory = factory_;
   if (factory->for_websockets_) {
     // TODO(ricea): Re-instate this code when WebSockets over SPDY is
     // implemented.
     NOTREACHED();
-  } else if (for_bidirectional_) {
+  } else if (stream_type_ == HttpStreamRequest::BIDIRECTIONAL_STREAM) {
     DCHECK(bidirectional_stream_job);
     DCHECK(!stream);
 #if BUILDFLAG(ENABLE_BIDIRECTIONAL_STREAM)
     delegate_->OnBidirectionalStreamJobReady(
         job->server_ssl_config(), job->proxy_info(),
         bidirectional_stream_job.release());
 #else
     NOTREACHED();
 #endif
   } else {
@@ skipping 87 matching lines @@
     }
     // We may have other jobs in |jobs_|. For example, if we start multiple jobs
     // for Alternate-Protocol.
     BindJob(job);
     return;
   }
   DCHECK(jobs_.empty());
 }
 
 }  // namespace net