JobController 2: Remove reference between HttpStreamFactoryImpl::Jobs.

net/http/http_stream_factory_impl_job_controller.cc

 // Copyright (c) 2016 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_controller.h"
 
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "net/base/host_mapping_rules.h"
 #include "net/http/bidirectional_stream_impl.h"
 #include "net/http/http_stream_factory_impl.h"
 #include "net/http/http_stream_factory_impl_job.h"
 #include "net/http/http_stream_factory_impl_request.h"
 #include "net/http/transport_security_state.h"
 #include "net/spdy/spdy_session.h"
 
 namespace net {
 
 HttpStreamFactoryImpl::JobController::JobController(
     HttpStreamFactoryImpl* factory,
     HttpStreamRequest::Delegate* delegate,
     HttpNetworkSession* session)
     : factory_(factory),
       session_(session),
       request_(nullptr),
       delegate_(delegate),
       is_preconnect_(false),
       job_bounded_(false),
+      blocking_(false),
       bound_job_(nullptr) {
   DCHECK(factory);
 }
 
 HttpStreamFactoryImpl::JobController::~JobController() {
   main_job_.reset();
   alternative_job_.reset();
   bound_job_ = nullptr;
 }
 
@@ skipping 92 matching lines @@
 void HttpStreamFactoryImpl::JobController::SetPriority(
     RequestPriority priority) {
   if (main_job_) {
     main_job_->SetPriority(priority);
   }
   if (alternative_job_) {
     alternative_job_->SetPriority(priority);
   }
 }
 
+int HttpStreamFactoryImpl::JobController::ScheduleJob(Job* job) {
+  if ((job->job_type() == ALTERNATIVE || !blocking()) &&
+      job->wait_time().is_zero()) {
+    // There is no blocking job and there is no |wait_time_|.
+    job->SetNextState(STATE_INIT_CONNECTION);
+    return OK;
+  }
+
+  job->SetNextState(STATE_WAIT_FOR_JOB_COMPLETE);
+  if (!job->wait_time().is_zero()) {
+    // If there is a waiting_time, then resume the job after the wait_time_.
+    DCHECK((job->job_type() == ALTERNATIVE || !blocking()));
+    job->ResumeAfterDelay();
+  }
+
+  return ERR_IO_PENDING;
+}
+
 void HttpStreamFactoryImpl::JobController::OnStreamReady(
     Job* job,
     const SSLConfig& used_ssl_config,
     const ProxyInfo& used_proxy_info) {
   if (job_bounded_ && bound_job_ != job) {
     // We have bound a job to the associated Request, |job| has been orphaned.
     OnOrphanedJobComplete(job);
     return;
   }
 
@@ skipping 231 matching lines @@
                                    used_proxy_info, was_npn_negotiated,
                                    protocol_negotiated, using_spdy, net_log);
   }
   if (is_job_orphaned) {
     OnOrphanedJobComplete(job);
   }
 }
 
 void HttpStreamFactoryImpl::JobController::OnPreconnectsComplete(Job* job) {
   DCHECK_EQ(main_job_.get(), job);
+  DCHECK(!bound_job_);
   main_job_.reset();
   factory_->OnPreconnectsCompleteInternal();
   MaybeNotifyFactoryOfCompletion();
 }
 
 void HttpStreamFactoryImpl::JobController::OnOrphanedJobComplete(
     const Job* job) {
   if (job->job_type() == MAIN) {
     DCHECK_EQ(main_job_.get(), job);
     main_job_.reset();
@@ skipping 49 matching lines @@
     DCHECK(ContainsKey(spdy_session_request_map, *spdy_session_key));
     RequestSet& request_set = spdy_session_request_map[*spdy_session_key];
     DCHECK(ContainsKey(request_set, request_));
     request_set.erase(request_);
     if (request_set.empty())
       spdy_session_request_map.erase(*spdy_session_key);
     request_->ResetSpdySessionKey();
   }
 }
 
+void HttpStreamFactoryImpl::JobController::MaybeResumeOtherJob(
+    Job* job,
+    const base::TimeDelta& delay) {
+  if (!blocking_)
+    return;
+
+  if (job == alternative_job_.get() && main_job_) {
+    main_job_->Resume(delay);
+  } else if (job != main_job_.get() && job != alternative_job_.get()) {
+    NOTREACHED();
+  }
+  blocking_ = false;
+}
+
 const BoundNetLog* HttpStreamFactoryImpl::JobController::GetNetLog(
     Job* job) const {
   if (is_preconnect_ || (job_bounded_ && bound_job_ != job))
     return nullptr;
   DCHECK(request_);
   return &request_->net_log();
 }
 
 WebSocketHandshakeStreamBase::CreateHelper* HttpStreamFactoryImpl::
     JobController::websocket_handshake_stream_create_helper() {
@@ skipping 33 matching lines @@
     HostPortPair alternative_destination(alternative_service.host_port_pair());
     ignore_result(
         ApplyHostMappingRules(request_info.url, &alternative_destination));
 
     alternative_job_.reset(
         new Job(this, ALTERNATIVE, session_, request_info, priority,
                 server_ssl_config, proxy_ssl_config, alternative_destination,
                 origin_url, alternative_service, net_log.net_log()));
     AttachJob(alternative_job_.get());
 
-    main_job_->WaitFor(alternative_job_.get());
-    // Make sure to wait until we call WaitFor(), before starting
-    // |alternative_job|, otherwise |alternative_job| will not notify |job|
-    // appropriately.
+    blocking_ = true;
     alternative_job_->Start(request_->stream_type());
   }
   // Even if |alternative_job| has already finished, it will not have notified
   // the request yet, since we defer that to the next iteration of the
   // MessageLoop, so starting |main_job_| is always safe.
   main_job_->Start(request_->stream_type());
 }
 
 void HttpStreamFactoryImpl::JobController::AttachJob(Job* job) {
   DCHECK(job);
@@ skipping 238 matching lines @@
       first_alternative_service = alternative_service;
   }
 
   // Ask delegate to mark QUIC as broken for the origin.
   if (quic_advertised && quic_all_broken && delegate != nullptr)
     delegate->OnQuicBroken();
 
   return first_alternative_service;
 }
 }