Resume the main job immediately when QUIC job fails, not wait for the head start timer to exprie

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 <memory>
 #include <string>
 #include <utility>
 
@@ skipping 45 matching lines @@
     bool is_preconnect)
     : factory_(factory),
       session_(session),
       job_factory_(job_factory),
       request_(nullptr),
       delegate_(delegate),
       is_preconnect_(is_preconnect),
       alternative_job_net_error_(OK),
       job_bound_(false),
       main_job_is_blocked_(false),
+      main_job_is_resumed_(false),
       bound_job_(nullptr),
       can_start_alternative_proxy_job_(false),
       privacy_mode_(PRIVACY_MODE_DISABLED),
       net_log_(
           NetLogWithSource::Make(session->net_log(),
                                  NetLogSourceType::HTTP_STREAM_JOB_CONTROLLER)),
       ptr_factory_(this) {
   DCHECK(factory);
   net_log_.BeginEvent(NetLogEventType::HTTP_STREAM_JOB_CONTROLLER,
                       base::Bind(&NetLogJobControllerCallback,
@@ skipping 464 matching lines @@
     Job* job,
     const ConnectionAttempts& attempts) {
   if (is_preconnect_ || (job_bound_ && bound_job_ != job))
     return;
 
   DCHECK(request_);
   request_->AddConnectionAttempts(attempts);
 }
 
 void HttpStreamFactoryImpl::JobController::ResumeMainJob() {
+  if (main_job_is_resumed_)
+    return;
+
+  main_job_is_resumed_ = true;
   main_job_->net_log().AddEvent(
       NetLogEventType::HTTP_STREAM_JOB_DELAYED,
       base::Bind(&NetLogHttpStreamJobDelayCallback, main_job_wait_time_));
 
   main_job_->Resume();
   main_job_wait_time_ = base::TimeDelta();
 }
 
 void HttpStreamFactoryImpl::JobController::MaybeResumeMainJob(
     Job* job,
     const base::TimeDelta& delay) {
+  DCHECK(delay == base::TimeDelta() || delay == main_job_wait_time_);
   DCHECK(job == main_job_.get() || job == alternative_job_.get());
 
-  if (!main_job_is_blocked_ || job != alternative_job_.get() || !main_job_)
+  if (job != alternative_job_.get() || !main_job_)
     return;
 
-  main_job_is_blocked_ = false;
+  if (main_job_is_blocked_)
+    main_job_is_blocked_ = false;

[Ryan Hamilton, 2017/02/15 00:52:08]

Might as well just set main_job_is_blocked_ = false, without the guard.

[Zhongyi Shi, 2017/02/15 01:39:05]

Done.

 
-  if (!main_job_->is_waiting())
+  if (!main_job_->is_waiting()) {
+    // There are two cases where the main job is not in WAIT state:
+    //   1) The main job hasn't got to waiting state, simply mark it unblocked.

[Ryan Hamilton, 2017/02/15 00:52:08]

If it's not blocked, but main_job_wait_time_ is not zero, then the job will wait
for that time once it calls ShouldWait(), right?

In any case, the body of this block does not "mark it unblocked" so I'd be
inclined to say something like " so do not yet post a task to resume since that
will happen in ShouldWait()" or some such.

[Zhongyi Shi, 2017/02/15 01:39:04]

Yup.
Thanks for helping clarify the case.

+    //   2) The main job has passed waiting state, no-op.

[Zhongyi Shi, 2017/02/15 00:26:58]

main_job_.is_waiting() will be false
1. main job hasn't started yet, not in WAIT state, just unblock it, main job
then will start to proceed without blocking.
2. main job has passed WAIT state, which is resumed.

[Ryan Hamilton, 2017/02/15 00:52:08]

Instead of "no-op" I would say something like, "so the job does not need to be
resumed"

[Zhongyi Shi, 2017/02/15 01:39:04]

Done.

     return;
+  }
+
+  main_job_wait_time_ = delay;
 
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&HttpStreamFactoryImpl::JobController::ResumeMainJob,
                  ptr_factory_.GetWeakPtr()),
       main_job_wait_time_);
 }
 
 void HttpStreamFactoryImpl::JobController::OnConnectionInitialized(Job* job,
                                                                    int rv) {
@@ skipping 576 matching lines @@
     return;
   DCHECK(alternative_job_->alternative_proxy_server().is_valid());
   alternative_job_->Start(request_->stream_type());
 }
 
 bool HttpStreamFactoryImpl::JobController::IsJobOrphaned(Job* job) const {
   return !request_ || (job_bound_ && bound_job_ != job);
 }
 
 }  // namespace net