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 when |job| finishes initiating a connection.
+  // Resume the other job if there's an error raised.
+  void OnConnectionInitialized(Job* job, int rv) 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

[Ryan Hamilton, 2016/07/12 00:21:45]

ResumeAfterDelay is now dead, right? Perhaps this should be reworked?

[Zhongyi Shi, 2016/07/12 23:03:12]

Done.

+  // |job| with appropriate wait time.
+  bool ShouldWait(Job* job) 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;
+
+  void SetWaitTimeForMainJob(const base::TimeDelta& delay) override;
+
   WebSocketHandshakeStreamBase::CreateHelper*
   websocket_handshake_stream_create_helper() override;
 
  private:
-  FRIEND_TEST_ALL_PREFIXES(HttpStreamFactoryImplRequestTest, DelayMainJob);
+  friend class JobControllerPeer;
 
   // 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,
                   const SSLConfig& proxy_ssl_config,
                   HttpStreamRequest::Delegate* delegate,
                   HttpStreamRequest::StreamType stream_type,
                   const BoundNetLog& net_log);
 
@@ skipping 16 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 main job with delay.
+  void MaybeResumeMainJob(Job* job, const base::TimeDelta& delay);
+
+  void ResumeMainJob();
+
   // 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_|. The delay
+  // is specified in |main_job_wait_time_|.
+  bool main_job_is_blocked_;

[Ryan Hamilton, 2016/07/12 00:21:45]

Let's comment this a bit more. 

When main_job_is_blocked_ is true, then the main job must not create a
connection. If it is ready to create a connection while it is blocked, then it
must wait until is it resumed.

Or some such...

[Zhongyi Shi, 2016/07/12 23:03:12]

Done.

+  base::TimeDelta main_job_wait_time_;
+
   // 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_;
+
+  base::WeakPtrFactory<JobController> ptr_factory_;
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_HTTP_STREAM_FACTORY_IMPL_JOB_CONTROLLER_H_