Change QuicStreamFactory::active_jobs_ to a Map from QuicServerId to Job

net/quic/chromium/quic_stream_factory.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/quic/chromium/quic_stream_factory.h"
 
 #include <algorithm>
 #include <tuple>
 #include <utility>
 
@@ skipping 880 matching lines @@
     if (it != active_sessions_.end()) {
       QuicChromiumClientSession* session = it->second;
       request->SetSession(session);
       return OK;
     }
   }
 
   // Associate with active job to |server_id| if such exists.
   auto it = active_jobs_.find(server_id);
   if (it != active_jobs_.end()) {
-    const JobSet& job_set = it->second;
-    // TODO(zhongyi): figure out how to link the NetLogs if there are more than
-    // one job serving the same server id, i.e., auxiliary job is also
-    // created.
-    if (job_set.size() == 1) {
-      const NetLogWithSource& job_net_log = job_set.begin()->first->net_log();
-      job_net_log.AddEvent(
-          NetLogEventType::QUIC_STREAM_FACTORY_JOB_BOUND_TO_HTTP_STREAM_JOB,
-          net_log.source().ToEventParametersCallback());
-      net_log.AddEvent(
-          NetLogEventType::HTTP_STREAM_JOB_BOUND_TO_QUIC_STREAM_FACTORY_JOB,
-          job_net_log.source().ToEventParametersCallback());
-    }
+    const NetLogWithSource& job_net_log = it->second->net_log();
+    job_net_log.AddEvent(
+        NetLogEventType::QUIC_STREAM_FACTORY_JOB_BOUND_TO_HTTP_STREAM_JOB,
+        net_log.source().ToEventParametersCallback());
+    net_log.AddEvent(
+        NetLogEventType::HTTP_STREAM_JOB_BOUND_TO_QUIC_STREAM_FACTORY_JOB,
+        job_net_log.source().ToEventParametersCallback());
     job_requests_map_[server_id].insert(request);
     return ERR_IO_PENDING;
   }
 
   // Pool to active session to |destination| if possible.
   if (!active_sessions_.empty()) {
     for (const auto& key_value : active_sessions_) {
       QuicChromiumClientSession* session = key_value.second;
       if (destination.Equals(all_sessions_[session].destination()) &&
           session->CanPool(server_id.host(), server_id.privacy_mode())) {
@@ skipping 11 matching lines @@
   ignore_result(StartCertVerifyJob(server_id, cert_verify_flags, net_log));
 
   QuicSessionKey key(destination, server_id);
   std::unique_ptr<Job> job = base::MakeUnique<Job>(
       this, host_resolver_, key, WasQuicRecentlyBroken(server_id),
       cert_verify_flags, net_log);
   int rv = job->Run(base::Bind(&QuicStreamFactory::OnJobComplete,
                                base::Unretained(this), job.get()));
   if (rv == ERR_IO_PENDING) {
     job_requests_map_[server_id].insert(request);
-    Job* job_ptr = job.get();
-    active_jobs_[server_id][job_ptr] = std::move(job);
+    active_jobs_[server_id] = std::move(job);
     return rv;
   }
   if (rv == OK) {
     // TODO(rtenneti): crbug.com/498823 - revert active_sessions_.empty()
     // related changes.
     if (active_sessions_.empty())
       return ERR_QUIC_PROTOCOL_ERROR;
     SessionMap::iterator it = active_sessions_.find(server_id);
     DCHECK(it != active_sessions_.end());
     if (it == active_sessions_.end())
@@ skipping 43 matching lines @@
       return true;
     }
   }
   return false;
 }
 
 void QuicStreamFactory::OnJobComplete(Job* job, int rv) {
   // Copy |server_id|, because |job| might be destroyed before this method
   // returns.
   const QuicServerId server_id(job->key().server_id());
-  if (rv != OK) {
-    JobSet* jobs = &(active_jobs_[server_id]);
-    if (jobs->size() > 1) {
-      // If there is another pending job, then we can delete this job and let
-      // the other job handle the request.
-      job->Cancel();
-      jobs->erase(job);
-      return;
-    }
-  }
 
   ServerIDRequestsMap::iterator requests_iter =
       job_requests_map_.find(server_id);
   DCHECK(requests_iter != job_requests_map_.end());
   if (rv == OK) {
     set_require_confirmation(false);
 
     if (!requests_iter->second.empty()) {
       SessionMap::iterator session_it = active_sessions_.find(server_id);
       DCHECK(session_it != active_sessions_.end());
       QuicChromiumClientSession* session = session_it->second;
       for (QuicStreamRequest* request : requests_iter->second) {
         DCHECK(request->server_id() == server_id);
         // Do not notify |request| yet.
         request->SetSession(session);
       }
     }
   }
 
   // It's okay not to erase |request| from |requests_iter->second| because the
   // entire RequestSet will be erased from |job_requests_map_|.
   for (auto* request : requests_iter->second) {
     // Even though we're invoking callbacks here, we don't need to worry
     // about |this| being deleted, because the factory is owned by the
     // profile which can not be deleted via callbacks.
     request->OnRequestComplete(rv);
   }
 
-  for (auto& other_job : active_jobs_[server_id]) {
-    if (other_job.first != job)
-      other_job.first->Cancel();
-  }
-
-  active_jobs_[server_id].clear();
   active_jobs_.erase(server_id);
   job_requests_map_.erase(requests_iter);
 }
 
 void QuicStreamFactory::OnCertVerifyJobComplete(CertVerifierJob* job, int rv) {
   active_cert_verifier_jobs_.erase(job->server_id());
 }
 
 void QuicStreamFactory::OnIdleSession(QuicChromiumClientSession* session) {}
 
@@ skipping 662 matching lines @@
   // Since the session was active, there's no longer an
   // HttpStreamFactoryImpl::Job running which can mark it broken, unless the TCP
   // job also fails. So to avoid not using QUIC when we otherwise could, we mark
   // it as recently broken, which means that 0-RTT will be disabled but we'll
   // still race.
   http_server_properties_->MarkAlternativeServiceRecentlyBroken(
       alternative_service);
 }
 
 }  // namespace net