JobController 2: Remove reference between HttpStreamFactoryImpl::Jobs.

net/http/http_stream_factory_impl_job_controller.h

 // 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.
 
 #ifndef NET_HTTP_HTTP_STREAM_FACTORY_IMPL_JOB_CONTROLLER_H_
 #define NET_HTTP_HTTP_STREAM_FACTORY_IMPL_JOB_CONTROLLER_H_
 
 #include "net/http/http_stream_factory_impl_job.h"
 #include "net/http/http_stream_factory_impl_request.h"
 
@@ skipping 115 matching lines @@
 
   // Invoked when the |job| finishes pre-connecting sockets.
   void OnPreconnectsComplete(Job* job) override;
 
   // Invoked to record connection attempts made by the socket layer to
   // Request if |job| is associated with Request.
   void AddConnectionAttemptsToRequest(
       Job* job,
       const ConnectionAttempts& attempts) override;
 
+  // Invoked to resume the main job when |job| initiates a connection but
+  // does not succeed.
+  void OnInitConnectionNotSuccessful(Job* job,
+                                     const base::TimeDelta& delay) override;
+
+  // Return false if |job| has no blocking job and there's no wait time,
+  // i.e., |job| won't call Job::ResumeAfterDelay(). Else true and resume
+  // |job| with appropriate wait time.
+  bool ShoudWait(Job* job) const override;
+
   // Called when |job| determines the appropriate |spdy_session_key| for the
   // Request. Note that this does not mean that SPDY is necessarily supported
   // for this SpdySessionKey, since we may need to wait for NPN to complete
   // before knowing if SPDY is available.
   void SetSpdySessionKey(Job* job,
                          const SpdySessionKey& spdy_session_key) override;
 
   // Remove session from the SpdySessionRequestMap.
   void RemoveRequestFromSpdySessionRequestMapForJob(Job* job) override;
   const BoundNetLog* GetNetLog(Job* job) const override;
+
+  const base::TimeDelta& wait_time_for_main_job() const override;
+  void set_wait_time_for_main_job(const base::TimeDelta& delay) override;
+  bool blocking() override;
+
   WebSocketHandshakeStreamBase::CreateHelper*
   websocket_handshake_stream_create_helper() override;
 
  private:
   FRIEND_TEST_ALL_PREFIXES(HttpStreamFactoryImplRequestTest, DelayMainJob);
 
   // Creates Job(s) for |request_|. Job(s) will be owned by |this|.
   void CreateJobs(const HttpRequestInfo& request_info,
                   RequestPriority priority,
                   const SSLConfig& server_ssl_config,
@@ skipping 21 matching lines @@
   // Called when a Job succeeds.
   void OnJobSucceeded(Job* job);
 
   // Marks completion of the |request_|.
   void MarkRequestComplete(bool was_npn_negotiated,
                            NextProto protocol_negotiated,
                            bool using_spdy);
 
   void MaybeNotifyFactoryOfCompletion();
 
+  // Called to resume the alternative job.
+  void MaybeResumeOtherJob(Job* job, const base::TimeDelta& delay);

[Ryan Hamilton, 2016/06/29 23:12:28]

I think this can only resume the *main* job, right? So perhaps:

MaybeResumeMainJob?

(And tweak the comment)

[Zhongyi Shi, 2016/06/30 22:53:39]

Urgh, right! it should resume the main job only!

+
   // Returns true if QUIC is whitelisted for |host|.
   bool IsQuicWhitelistedForHost(const std::string& host);
 
   AlternativeService GetAlternativeServiceFor(
       const HttpRequestInfo& request_info,
       HttpStreamRequest::Delegate* delegate,
       HttpStreamRequest::StreamType stream_type);
 
   AlternativeService GetAlternativeServiceForInternal(
       const HttpRequestInfo& request_info,
@@ skipping 20 matching lines @@
 
   // |main_job_| is a job waiting to see if |alternative_job_| can reuse a
   // connection. If |alternative_job_| is unable to do so, |this| will notify
   // |main_job_| to proceed and then race the two jobs.
   std::unique_ptr<Job> main_job_;
   std::unique_ptr<Job> alternative_job_;
 
   // True if a Job has ever been bound to the |request_|.
   bool job_bound_;
 
+  // True if the |main_job_| has to wait for |alternative_job_|;
+  bool blocking_;

[Ryan Hamilton, 2016/06/29 23:12:28]

nit: main_job_is_blocked_;

+  base::TimeDelta wait_time_;

[Ryan Hamilton, 2016/06/29 23:12:28]

nit: main_job_wait_time_? (or some such)

Can you comment how this relates to the other bool? Can the main job resume if
the bool is true? Does it resume when that becomes false after the TimeDelta?

+
   // At the point where a Job is irrevocably tied to |request_|, we set this.
   // It will be nulled when the |request_| is finished.
   Job* bound_job_;
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_HTTP_STREAM_FACTORY_IMPL_JOB_CONTROLLER_H_