Throttle HttpStreamFactoryImpl::Job to HTTP/2-supported servers

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 "base/bind.h"
@@ skipping 186 matching lines @@
       was_alpn_negotiated_(false),
       negotiated_protocol_(kProtoUnknown),
       num_streams_(0),
       spdy_session_direct_(
           !(proxy_info.is_https() && origin_url_.SchemeIs(url::kHttpScheme))),
       spdy_session_key_(GetSpdySessionKey(spdy_session_direct_,
                                           proxy_info_.proxy_server(),
                                           origin_url_,
                                           request_info_.privacy_mode)),
       stream_type_(HttpStreamRequest::BIDIRECTIONAL_STREAM),
+      init_connection_already_resumed_(false),
       ptr_factory_(this) {
   DCHECK(session);
   if (alternative_protocol != kProtoUnknown) {
     // The job cannot have protocol requirements dictated by alternative service
     // and have an alternative proxy server set at the same time, since
     // alternative services are used for requests that are fetched directly,
     // while the alternative proxy server is used for requests that should be
     // fetched using proxy.
     DCHECK(!alternative_proxy_server_.is_valid());
     // If the alternative service protocol is specified, then the job type must
@@ skipping 330 matching lines @@
   RunLoop(result);
 }
 
 void HttpStreamFactoryImpl::Job::RunLoop(int result) {
   TRACE_EVENT0(kNetTracingCategory, "HttpStreamFactoryImpl::Job::RunLoop");
   result = DoLoop(result);
 
   if (result == ERR_IO_PENDING)
     return;
 
+  // Resume all throttled Jobs with the same SpdySessionKey if there are any,
+  // now that this job is done.
+  session_->spdy_session_pool()->ResumePendingRequests(spdy_session_key_);
+
   if (job_type_ == PRECONNECT) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(&HttpStreamFactoryImpl::Job::OnPreconnectsComplete,
                    ptr_factory_.GetWeakPtr()));
     return;
   }
 
   if (IsCertificateError(result)) {
     // Retrieve SSL information from the socket.
@@ skipping 111 matching lines @@
         DCHECK_EQ(OK, rv);
         rv = DoStart();
         break;
       case STATE_WAIT:
         DCHECK_EQ(OK, rv);
         rv = DoWait();
         break;
       case STATE_WAIT_COMPLETE:
         rv = DoWaitComplete(rv);
         break;
+      case STATE_EVALUATE_THROTTLE:
+        DCHECK_EQ(OK, rv);
+        rv = DoEvaluateThrottle();
+        break;
       case STATE_INIT_CONNECTION:
         DCHECK_EQ(OK, rv);
         rv = DoInitConnection();
         break;
       case STATE_INIT_CONNECTION_COMPLETE:
         rv = DoInitConnectionComplete(rv);
         break;
       case STATE_WAITING_USER_ACTION:
         rv = DoWaitingUserAction(rv);
         break;
@@ skipping 57 matching lines @@
                       NetLog::BoolCallback("should_wait", should_wait));
   if (should_wait)
     return ERR_IO_PENDING;
 
   return OK;
 }
 
 int HttpStreamFactoryImpl::Job::DoWaitComplete(int result) {
   net_log_.EndEvent(NetLogEventType::HTTP_STREAM_JOB_WAITING);
   DCHECK_EQ(OK, result);
+  next_state_ = STATE_EVALUATE_THROTTLE;
+  return OK;
+}
+
+int HttpStreamFactoryImpl::Job::DoEvaluateThrottle() {
   next_state_ = STATE_INIT_CONNECTION;
-  return OK;
+  if (!using_ssl_)
+    return OK;
+  // Ask |delegate_delegate_| to update the spdy session key for the request
+  // that launched this job.
+  delegate_->SetSpdySessionKey(this, spdy_session_key_);
+
+  // Throttle connect to an HTTP/2 supported server, if there are pending
+  // requests with the same SpdySessionKey.
+  if (session_->http_server_properties()->RequiresHTTP11(
+          spdy_session_key_.host_port_pair()))
+    return OK;
+  url::SchemeHostPort scheme_host_port(
+      using_ssl_ ? url::kHttpsScheme : url::kHttpScheme,
+      spdy_session_key_.host_port_pair().host(),
+      spdy_session_key_.host_port_pair().port());
+  if (!session_->http_server_properties()->GetSupportsSpdy(scheme_host_port))
+    return OK;
+  base::Closure callback =
+      base::Bind(&HttpStreamFactoryImpl::Job::ResumeInitConnection,
+                 ptr_factory_.GetWeakPtr());
+  if (session_->spdy_session_pool()->StartRequest(spdy_session_key_,
+                                                  callback)) {
+    return OK;
+  }
+  base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+      FROM_HERE, callback, base::TimeDelta::FromMilliseconds(kHTTP2ThrottleMs));
+  return ERR_IO_PENDING;
+}
+
+void HttpStreamFactoryImpl::Job::ResumeInitConnection() {
+  if (init_connection_already_resumed_)
+    return;
+  CHECK_EQ(next_state_, STATE_INIT_CONNECTION);

[Bence, 2017/06/15 13:37:46]

Very optional: a DCHECK should be enough here.

[xunjieli, 2017/06/15 13:53:25]

Thanks. I add a TODO to change it back to DCHECK. It seems that Canary channel
doesn't have DCHECKs enabled. In case we have a bug in this CL, it might be
easier to spot. 

+  init_connection_already_resumed_ = true;
+  OnIOComplete(OK);
 }
 
 int HttpStreamFactoryImpl::Job::DoInitConnection() {
   net_log_.BeginEvent(NetLogEventType::HTTP_STREAM_JOB_INIT_CONNECTION);
   int result = DoInitConnectionImpl();
   if (result != ERR_SPDY_SESSION_ALREADY_EXISTS)
     delegate_->OnConnectionInitialized(this, result);
 
   return result;
 }
@@ skipping 89 matching lines @@
       // If we're preconnecting, but we already have a SpdySession, we don't
       // actually need to preconnect any sockets, so we're done.
       if (job_type_ == PRECONNECT)
         return OK;
       using_spdy_ = true;
       next_state_ = STATE_CREATE_STREAM;
       existing_spdy_session_ = spdy_session;
       return OK;
     }
   }
-  if (using_ssl_) {
-    // Ask |delegate_delegate_| to update the spdy session key for the request
-    // that launched this job.
-    delegate_->SetSpdySessionKey(this, spdy_session_key_);
-  }
 
   if (proxy_info_.is_http() || proxy_info_.is_https())
     establishing_tunnel_ = using_ssl_;
 
   HttpServerProperties* http_server_properties =
       session_->http_server_properties();
   if (http_server_properties) {
     http_server_properties->MaybeForceHTTP11(destination_, &server_ssl_config_);
     if (proxy_info_.is_http() || proxy_info_.is_https()) {
       http_server_properties->MaybeForceHTTP11(
@@ skipping 560 matching lines @@
     bool enable_ip_based_pooling,
     NetLog* net_log) {
   return base::MakeUnique<HttpStreamFactoryImpl::Job>(
       delegate, job_type, session, request_info, priority, proxy_info,
       server_ssl_config, proxy_ssl_config, destination, origin_url,
       kProtoUnknown, alternative_proxy_server, enable_ip_based_pooling,
       net_log);
 }
 
 }  // namespace net