Integrating the QuicStreamFactory into the network stack.

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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
@@ skipping 10 matching lines @@
 #include "net/http/http_pipelined_connection.h"
 #include "net/http/http_pipelined_host.h"
 #include "net/http/http_pipelined_host_pool.h"
 #include "net/http/http_pipelined_stream.h"
 #include "net/http/http_proxy_client_socket.h"
 #include "net/http/http_proxy_client_socket_pool.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_server_properties.h"
 #include "net/http/http_stream_factory.h"
 #include "net/http/http_stream_factory_impl_request.h"
+#include "net/quic/quic_http_stream.h"
 #include "net/socket/client_socket_handle.h"
 #include "net/socket/client_socket_pool.h"
 #include "net/socket/client_socket_pool_manager.h"
 #include "net/socket/socks_client_socket_pool.h"
 #include "net/socket/ssl_client_socket.h"
 #include "net/socket/ssl_client_socket_pool.h"
 #include "net/spdy/spdy_http_stream.h"
 #include "net/spdy/spdy_session.h"
 #include "net/spdy/spdy_session_pool.h"
 
@@ skipping 41 matching lines @@
           base::Bind(&Job::OnIOComplete, base::Unretained(this)))),
       connection_(new ClientSocketHandle),
       session_(session),
       stream_factory_(stream_factory),
       next_state_(STATE_NONE),
       pac_request_(NULL),
       blocking_job_(NULL),
       waiting_job_(NULL),
       using_ssl_(false),
       using_spdy_(false),
+      using_quic_(false),
       force_spdy_always_(HttpStreamFactory::force_spdy_always()),
       force_spdy_over_ssl_(HttpStreamFactory::force_spdy_over_ssl()),
+      force_quic_port_(HttpStreamFactory::force_quic_port()),
       spdy_certificate_error_(OK),
       establishing_tunnel_(false),
       was_npn_negotiated_(false),
       protocol_negotiated_(kProtoUnknown),
       num_streams_(0),
       spdy_session_direct_(false),
       existing_available_pipeline_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(ptr_factory_(this)) {
   DCHECK(stream_factory);
   DCHECK(session);
@@ skipping 46 matching lines @@
   next_state_ = STATE_RESTART_TUNNEL_AUTH;
   stream_.reset();
   return RunLoop(OK);
 }
 
 LoadState HttpStreamFactoryImpl::Job::GetLoadState() const {
   switch (next_state_) {
     case STATE_RESOLVE_PROXY_COMPLETE:
       return session_->proxy_service()->GetLoadState(pac_request_);
     case STATE_CREATE_STREAM_COMPLETE:
-      return connection_->GetLoadState();
+      return using_quic_ ? LOAD_STATE_CONNECTING : connection_->GetLoadState();
     case STATE_INIT_CONNECTION_COMPLETE:
       return LOAD_STATE_SENDING_REQUEST;
     default:
       return LOAD_STATE_IDLE;
   }
 }
 
 void HttpStreamFactoryImpl::Job::MarkAsAlternate(const GURL& original_url) {
   DCHECK(!original_url_.get());
   original_url_.reset(new GURL(original_url));
@@ skipping 460 matching lines @@
 bool HttpStreamFactoryImpl::Job::ShouldForceSpdySSL() const {
   bool rv = force_spdy_always_ && force_spdy_over_ssl_;
   return rv && !HttpStreamFactory::HasSpdyExclusion(origin_);
 }
 
 bool HttpStreamFactoryImpl::Job::ShouldForceSpdyWithoutSSL() const {
   bool rv = force_spdy_always_ && !force_spdy_over_ssl_;
   return rv && !HttpStreamFactory::HasSpdyExclusion(origin_);
 }
 
+bool HttpStreamFactoryImpl::Job::ShouldForceQuic() const {
+  return force_quic_port_ == origin_.port() && proxy_info_.is_direct();

[willchan no longer on Chromium, 2012/11/22 03:04:53]

FWIW, I read this as forcing all requests to go to a certain port for QUIC, not
forcing all http requests to a certain port to go over QUIC. Of course,
clarifying this would require a long ugly flag name. Perhaps it's worth it since
I do think we'l have the flag for awhile.

[Ryan Hamilton, 2012/11/22 23:08:40]

I hear ya.  Naming is hard.  What about --force-quic-for-requests-to-port=6121
(and a variable named force_quic_for_request_to_port)

Or --force-quic-when-origin-has-port ?

[willchan no longer on Chromium, 2012/12/11 02:02:08]

I prefer the latter, but both are better.

+}
+
 int HttpStreamFactoryImpl::Job::DoWaitForJob() {
   DCHECK(blocking_job_);
   next_state_ = STATE_WAIT_FOR_JOB_COMPLETE;
   return ERR_IO_PENDING;
 }
 
 int HttpStreamFactoryImpl::Job::DoWaitForJobComplete(int result) {
   DCHECK(!blocking_job_);
   DCHECK_EQ(OK, result);
   next_state_ = STATE_INIT_CONNECTION;
   return OK;
 }
 
 int HttpStreamFactoryImpl::Job::DoInitConnection() {
   DCHECK(!blocking_job_);
   DCHECK(!connection_->is_initialized());
   DCHECK(proxy_info_.proxy_server().is_valid());
   next_state_ = STATE_INIT_CONNECTION_COMPLETE;
 
   using_ssl_ = request_info_.url.SchemeIs("https") || ShouldForceSpdySSL();
   using_spdy_ = false;
 
+  if (ShouldForceQuic()) {
+    next_state_ = STATE_CREATE_STREAM;
+    using_quic_ = true;
+    return OK;
+  }
+
   // Check first if we have a spdy session for this group.  If so, then go
   // straight to using that.
   HostPortProxyPair spdy_session_key = GetSpdySessionKey();
   scoped_refptr<SpdySession> spdy_session =
       session_->spdy_session_pool()->GetIfExists(spdy_session_key, net_log_);
   if (spdy_session && CanUseExistingSpdySession()) {
     // If we're preconnecting, but we already have a SpdySession, we don't
     // actually need to preconnect any sockets, so we're done.
     if (IsPreconnecting())
       return OK;
@@ skipping 223 matching lines @@
   // This state indicates that the stream request is in a partially
   // completed state, and we've called back to the delegate for more
   // information.
 
   // We're always waiting here for the delegate to call us back.
   return ERR_IO_PENDING;
 }
 
 int HttpStreamFactoryImpl::Job::DoCreateStream() {
   DCHECK(connection_->socket() || existing_spdy_session_ ||
-         existing_available_pipeline_);
+         existing_available_pipeline_ || using_quic_);
 
   next_state_ = STATE_CREATE_STREAM_COMPLETE;
 
   // We only set the socket motivation if we're the first to use
   // this socket.  Is there a race for two SPDY requests?  We really
   // need to plumb this through to the connect level.
   if (connection_->socket() && !connection_->is_reused())
     SetSocketMotivation();
 
   const ProxyServer& proxy_server = proxy_info_.proxy_server();
 
+  if (using_quic_) {
+    return session_->quic_stream_factory()->Create(
+        HostPortProxyPair(origin_, proxy_server), net_log_, &quic_stream_,

[willchan no longer on Chromium, 2012/11/22 03:04:53]

How does cancellation work? Hm, everyone else just uses io_callback_ and it uses
base::Unretained(this). I need to page this code back into memory, but this all
seems reliant on Job never getting canceled.

I guess we never cancel jobs, even when the request goes away, since a new
request may come in that uses it. Except during shutdown since we must cancel
everything. This means shutdown order is probably very important, so I should
make sure that's done correctly for all this stuff.

[Ryan Hamilton, 2012/11/22 23:08:40]

Yes, I think your reading is correct.  I *think* the shutdown ordering also
works, but I admit that this is an area full of subtlety. 

+        io_callback_);
+  }
+
   if (!using_spdy_) {
     bool using_proxy = (proxy_info_.is_http() || proxy_info_.is_https()) &&
         request_info_.url.SchemeIs("http");
     if (stream_factory_->http_pipelined_host_pool_.
             IsExistingPipelineAvailableForKey(*http_pipelining_key_.get())) {
       stream_.reset(stream_factory_->http_pipelined_host_pool_.
                     CreateStreamOnExistingPipeline(
                         *http_pipelining_key_.get()));
       CHECK(stream_.get());
     } else if (!using_proxy && IsRequestEligibleForPipelining()) {
@@ skipping 62 matching lines @@
 
   bool use_relative_url = direct || request_info_.url.SchemeIs("https");
   stream_.reset(new SpdyHttpStream(spdy_session, use_relative_url));
   return OK;
 }
 
 int HttpStreamFactoryImpl::Job::DoCreateStreamComplete(int result) {
   if (result < 0)
     return result;
 
+  if (using_quic_) {
+    CHECK(quic_stream_);
+    stream_.reset(quic_stream_);
+    quic_stream_ = NULL;
+  }
+
   session_->proxy_service()->ReportSuccess(proxy_info_);
   next_state_ = STATE_NONE;
   return OK;
 }
 
 int HttpStreamFactoryImpl::Job::DoRestartTunnelAuth() {
   next_state_ = STATE_RESTART_TUNNEL_AUTH_COMPLETE;
   ProxyClientSocket* proxy_socket =
       static_cast<ProxyClientSocket*>(connection_->socket());
   return proxy_socket->RestartWithAuth(io_callback_);
@@ skipping 271 matching lines @@
       (net::LOAD_MAIN_FRAME | net::LOAD_SUB_FRAME | net::LOAD_PREFETCH |
        net::LOAD_IS_DOWNLOAD)) {
     // Avoid pipelining resources that may be streamed for a long time.
     return false;
   }
   return stream_factory_->http_pipelined_host_pool_.IsKeyEligibleForPipelining(
       *http_pipelining_key_.get());
 }
 
 }  // namespace net