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

net/spdy/chromium/spdy_session_pool.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/spdy/chromium/spdy_session_pool.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
@@ skipping 421 matching lines @@
           direct || request->url().SchemeIs(url::kHttpsScheme);
       request->OnStreamReady(
           used_ssl_config, used_proxy_info,
           base::MakeUnique<SpdyHttpStream>(spdy_session, use_relative_url,
                                            source_dependency));
     }
   }
   // TODO(mbelshe): Alert other valid requests.
 }
 
+bool SpdySessionPool::StartRequest(const SpdySessionKey& spdy_session_key,
+                                   const base::Closure& callback) {
+  auto iter = spdy_session_pending_request_map_.find(spdy_session_key);
+  if (iter == spdy_session_pending_request_map_.end()) {
+    spdy_session_pending_request_map_.emplace(spdy_session_key,
+                                              std::list<base::Closure>{});
+    return true;
+  }
+  iter->second.push_back(callback);
+  return false;
+}
+
+void SpdySessionPool::ResumeAllPendingRequests(
+    const SpdySessionKey& spdy_session_key) {
+  auto iter = spdy_session_pending_request_map_.find(spdy_session_key);
+  if (iter != spdy_session_pending_request_map_.end()) {
+    for (auto callback : iter->second) {
+      base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, callback);
+    }
+    spdy_session_pending_request_map_.erase(iter);
+  }
+}
+
 void SpdySessionPool::AddRequestToSpdySessionRequestMap(
     const SpdySessionKey& spdy_session_key,
     HttpStreamFactoryImpl::Request* request) {
   if (request->HasSpdySessionKey())
     return;
   RequestSet& request_set = spdy_session_request_map_[spdy_session_key];
   DCHECK(!base::ContainsKey(request_set, request));
   request_set.insert(request);
   request->SetSpdySessionKey(spdy_session_key);
 }
 
 void SpdySessionPool::RemoveRequestFromSpdySessionRequestMap(
     HttpStreamFactoryImpl::Request* request) {
   if (!request->HasSpdySessionKey())
     return;
   const SpdySessionKey& spdy_session_key = request->GetSpdySessionKey();
   auto iter = spdy_session_request_map_.find(spdy_session_key);
   DCHECK(iter != spdy_session_request_map_.end());
   RequestSet& request_set = iter->second;
   DCHECK(base::ContainsKey(request_set, request));
   request_set.erase(request);
   if (request_set.empty())
     spdy_session_request_map_.erase(spdy_session_key);
   request->ResetSpdySessionKey();
+  // If the request failed or canceled, open the floodgate to resume all
+  // requests.
+  ResumeAllPendingRequests(spdy_session_key);

[xunjieli, 2017/06/13 15:23:11]

I remove ResumeNextPendingRequest() to make the logic simpler and easier to
refactor later.

For any failed or canceled Request, RemoveRequestFromSpdySessionRequestMap()
will be called. When that is called, we just open the floodgate to allow
throttled Jobs to go through (rather than the first one in the previous patch). 

For preconnects, since they do not have a Request object, we open the floodgate
when Job::RunLoop() completes. 

 }
 
 void SpdySessionPool::DumpMemoryStats(
     base::trace_event::ProcessMemoryDump* pmd,
     const SpdyString& parent_dump_absolute_name) const {
   if (sessions_.empty())
     return;
   size_t total_size = 0;
   size_t buffer_size = 0;
   size_t cert_count = 0;
@@ skipping 99 matching lines @@
 
     if (idle_only && (*it)->is_active())
       continue;
 
     (*it)->CloseSessionOnError(error, description);
     DCHECK(!IsSessionAvailable(*it));
   }
 }
 
 }  // namespace net