QUIC - Whne alternate job decides to delay the main(TCP) job and if the

net/http/http_stream_factory_impl_job.h

 // 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.
 
 #ifndef NET_HTTP_HTTP_STREAM_FACTORY_IMPL_JOB_H_
 #define NET_HTTP_HTTP_STREAM_FACTORY_IMPL_JOB_H_
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 95 matching lines @@
   bool IsOrphaned() const;
 
   // Called to indicate that this job succeeded, and some other jobs
   // will be orphaned.
   void ReportJobSucceededForRequest();
 
   // Marks that the other |job| has completed.
   void MarkOtherJobComplete(const Job& job);
 
  private:
+  FRIEND_TEST_ALL_PREFIXES(HttpStreamFactoryImplRequestTest, DelayMainJob);
+
   enum State {
     STATE_START,
     STATE_RESOLVE_PROXY,
     STATE_RESOLVE_PROXY_COMPLETE,
 
     // Note that when Alternate-Protocol says we can connect to an alternate
     // port using a different protocol, we have the choice of communicating over
     // the original protocol, or speaking the alternate protocol (currently,
     // only npn-spdy) over an alternate port. For a cold page load, the http
     // connection that delivers the http response that has the
     // Alternate-Protocol header will already be warm. So, blocking the next
     // http request on establishing a new npn-spdy connection would incur extra
     // latency. Even if the http connection was not reused, establishing a new
     // http connection is typically faster than npn-spdy, since npn-spdy
     // requires a SSL handshake. Therefore, we start both the http and the
     // npn-spdy jobs in parallel. In order not to unnecessarily waste sockets,
     // we have the http job block on the npn-spdy job after proxy resolution.
     // The npn-spdy job will Resume() the http job if, in
     // STATE_INIT_CONNECTION_COMPLETE, it detects an error or does not find an
     // existing SpdySession. In that case, the http and npn-spdy jobs will race.

[Ryan Hamilton, 2016/01/19 23:23:27]

Can you update this comment when you have a chance?

[ramant (doing other things), 2016/01/20 04:37:52]

Done.

     STATE_WAIT_FOR_JOB,
     STATE_WAIT_FOR_JOB_COMPLETE,
 
     STATE_INIT_CONNECTION,
     STATE_INIT_CONNECTION_COMPLETE,
     STATE_WAITING_USER_ACTION,
     STATE_RESTART_TUNNEL_AUTH,
     STATE_RESTART_TUNNEL_AUTH_COMPLETE,
     STATE_CREATE_STREAM,
     STATE_CREATE_STREAM_COMPLETE,
@@ skipping 48 matching lines @@
     // the Job is not a SPDY alternative job, or if |spdy_session| is null.
     // Returns appropriate error code otherwise.
     int CheckAlternativeServiceValidityForOrigin(
         base::WeakPtr<SpdySession> spdy_session);
 
     SpdySessionPool* const spdy_session_pool_;
     const GURL origin_url_;
     const bool is_spdy_alternative_;
   };
 
+  // Resume the |this| job after the specified |delay|.
+  void ResumeWaitingJobAfterDelay(const base::TimeDelta& delay);
+
   void OnStreamReadyCallback();
   void OnBidirectionalStreamJobReadyCallback();
   void OnWebSocketHandshakeStreamReadyCallback();
   // This callback function is called when a new SPDY session is created.
   void OnNewSpdySessionReadyCallback();
   void OnStreamFailedCallback(int result);
   void OnCertificateErrorCallback(int result, const SSLInfo& ssl_info);
   void OnNeedsProxyAuthCallback(const HttpResponseInfo& response_info,
                                 HttpAuthController* auth_controller);
   void OnNeedsClientAuthCallback(SSLCertRequestInfo* cert_info);
@@ skipping 131 matching lines @@
 
   // This is the Job we're dependent on. It will notify us if/when it's OK to
   // proceed.
   Job* blocking_job_;
 
   // |waiting_job_| is a Job waiting to see if |this| can reuse a connection.
   // If |this| is unable to do so, we'll notify |waiting_job_| that it's ok to
   // proceed and then race the two Jobs.
   Job* waiting_job_;
 
+  base::TimeDelta wait_time_;
+
   // True if handling a HTTPS request, or using SPDY with SSL
   bool using_ssl_;
 
   // True if this network transaction is using SPDY instead of HTTP.
   bool using_spdy_;
 
   // True if this network transaction is using QUIC instead of HTTP.
   bool using_quic_;
   QuicStreamRequest quic_request_;
 
@@ skipping 47 matching lines @@
   bool for_bidirectional_;
 
   base::WeakPtrFactory<Job> ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Job);
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_HTTP_STREAM_FACTORY_IMPL_JOB_H_