Race TCP connection to proxies with QUIC connections

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 <memory>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/time/time.h"
 #include "net/base/completion_callback.h"
 #include "net/base/net_export.h"
 #include "net/base/request_priority.h"
 #include "net/http/bidirectional_stream_impl.h"
 #include "net/http/http_auth.h"
 #include "net/http/http_auth_controller.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_stream_factory_impl.h"
 #include "net/log/net_log.h"
+#include "net/proxy/proxy_server.h"
 #include "net/proxy/proxy_service.h"
 #include "net/quic/chromium/quic_stream_factory.h"
 #include "net/socket/client_socket_handle.h"
 #include "net/socket/client_socket_pool_manager.h"
 #include "net/socket/ssl_client_socket.h"
 #include "net/spdy/spdy_session_key.h"
 #include "net/ssl/ssl_config_service.h"
 
 namespace net {
 
@@ skipping 56 matching lines @@
                                    const SSLConfig& used_ssl_config,
                                    SSLCertRequestInfo* cert_info) = 0;
 
     // Invoked when |job| needs proxy authentication.
     virtual void OnNeedsProxyAuth(Job* job,
                                   const HttpResponseInfo& proxy_response,
                                   const SSLConfig& used_ssl_config,
                                   const ProxyInfo& used_proxy_info,
                                   HttpAuthController* auth_controller) = 0;
 
+    // Invoked when |job| has completed proxy resolution.

[Zhongyi Shi, 2016/08/19 23:08:42]

nit: maybe mention it's default proxy resolution.

[tbansal1, 2016/08/20 01:53:39]

I do not understand this comment. You mean it is called only by the main job?
What is "default" proxy resolution?

[Zhongyi Shi, 2016/08/20 06:15:40]

Yeah, just mention that this method is trying to set a alt proxy jov with a
alternative proxy server if it's a HTTP request. 

[tbansal1, 2016/08/22 15:42:32]

Done.  I did not mention the specifics ("a HTTP request.") because that
seems like an internal detail.

+    virtual void OnResolveProxyComplete(
+        Job* job,
+        const HttpRequestInfo& request_info,
+        RequestPriority priority,
+        const SSLConfig& server_ssl_config,

[RyanSturm, 2016/08/19 19:03:23]

nit: I wouldn't complain if you forward declared SSLConfig, it's getting pulled
in via ssl_config_service.h

[tbansal1, 2016/08/20 01:53:39]

Done.

+        const SSLConfig& proxy_ssl_config,
+        HttpStreamRequest::StreamType stream_type) = 0;
+
     // Invoked to notify the Request and Factory of the readiness of new
     // SPDY session.
     virtual void OnNewSpdySessionReady(
         Job* job,
         const base::WeakPtr<SpdySession>& spdy_session,
         bool direct) = 0;
 
     // Invoked when the orphaned |job| finishes.
     virtual void OnOrphanedJobComplete(const Job* job) = 0;
 
@@ skipping 40 matching lines @@
       JobType job_type,
       HttpNetworkSession* session,
       const HttpRequestInfo& request_info,
       RequestPriority priority,
       const SSLConfig& server_ssl_config,
       const SSLConfig& proxy_ssl_config,
       HostPortPair destination,
       GURL origin_url,
       NetLog* net_log);
 
-  // Constructor for alternative Job.
-  // Job is owned by |delegate|, hence |delegate| is valid for the
-  // lifetime of the Job.
+  // Constructor for alternative Job. The Job is owned by |delegate|, hence
+  // |delegate| is valid for the lifetime of the Job.
+  // If |alternative_proxy_server| is a valid proxy server, then the job will
+  // use that instead of using ProxyService for proxy resolution. Further, if
+  // |alternative_proxy_server| is valid but bad proxy, then fallback proxies
+  // are not used.

[Zhongyi Shi, 2016/08/19 23:08:42]

The comments are a little confusing. If I understand correctly, QUIC proxy
connection will create a alternative job with alternative proxy if there's only
main job created, right?

Thus the alternative job might be:
1. a job running with alternative service
2. a job running with alternative proxy

And I think what you meant to say is if the alternative_service is provided, it
will use the alternative_service. Otherwise, if the alternative_proxy_server is
provided, it will use the the alternative_proxy_server.

[tbansal1, 2016/08/20 01:53:39]

Done.

   Job(Delegate* delegate,
       JobType job_type,
       HttpNetworkSession* session,
       const HttpRequestInfo& request_info,
       RequestPriority priority,
       const SSLConfig& server_ssl_config,
       const SSLConfig& proxy_ssl_config,
       HostPortPair destination,
       GURL origin_url,
       AlternativeService alternative_service,
+      const ProxyServer& alternative_proxy_server,
       NetLog* net_log);
   virtual ~Job();
 
   // Start initiates the process of creating a new HttpStream.
   // |delegate_| will be notified upon completion.
   void Start(HttpStreamRequest::StreamType stream_type);
 
   // Preconnect will attempt to request |num_streams| sockets from the
   // appropriate ClientSocketPool.
   int Preconnect(int num_streams);
@@ skipping 175 matching lines @@
   int HandleCertificateRequest(int error);
 
   // Moves this stream request into SPDY mode.
   void SwitchToSpdyMode();
 
   // Should we force QUIC for this stream request.
   bool ShouldForceQuic() const;
 
   void MaybeMarkAlternativeServiceBroken();
 
+  // May notify proxy delegate that the alternative proxy server is broken.

[RyanSturm, 2016/08/19 19:03:23]

The "May" here is somewhat confusing. It should be clear about when it notifies
the proxy delegate. Can you change the to something more descriptive about when
it informs the proxy delegate?

[tbansal1, 2016/08/20 01:53:39]

Done.

+  void MaybeNotifyAlternativeProxyServerBroken() const;
+
   ClientSocketPoolManager::SocketGroupType GetSocketGroup() const;
 
   void MaybeCopyConnectionAttemptsFromSocketOrHandle();
 
   // Record histograms of latency until Connect() completes.
   static void LogHttpConnectedMetrics(const ClientSocketHandle& handle);
 
   // Invoked by the transport socket pool after host resolution is complete
   // to allow the connection to be aborted, if a matching SPDY session can
   // be found.  Will return ERR_SPDY_SESSION_ALREADY_EXISTS if such a
@@ skipping 28 matching lines @@
 
   // AlternativeService for this Job if this is an alternative Job.
   const AlternativeService alternative_service_;
 
   // AlternativeService for the other Job if this is not an alternative Job.
   AlternativeService other_job_alternative_service_;
 
   // Unowned. |this| job is owned by |delegate_|.
   Delegate* delegate_;
 
+  // Alternative proxy server that should be used by |this| to fetch the
+  // request.
+  const ProxyServer alternative_proxy_server_;
+
+  // Alternative proxy server for the other job.
+  ProxyServer other_job_alternative_proxy_server_;
+
   JobType job_type_;
 
   // 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_;
@@ skipping 59 matching lines @@
       HttpStreamFactoryImpl::Job::Delegate* delegate,
       HttpStreamFactoryImpl::JobType job_type,
       HttpNetworkSession* session,
       const HttpRequestInfo& request_info,
       RequestPriority priority,
       const SSLConfig& server_ssl_config,
       const SSLConfig& proxy_ssl_config,
       HostPortPair destination,
       GURL origin_url,
       AlternativeService alternative_service,
+      const ProxyServer& proxy_server,

[RyanSturm, 2016/08/19 19:03:23]

s/proxy_server/alternative_proxy_server

[tbansal1, 2016/08/20 01:53:39]

Done.

       NetLog* net_log) = 0;
 
   // Creates a non-alternative Job.
   virtual HttpStreamFactoryImpl::Job* CreateJob(
       HttpStreamFactoryImpl::Job::Delegate* delegate,
       HttpStreamFactoryImpl::JobType job_type,
       HttpNetworkSession* session,
       const HttpRequestInfo& request_info,
       RequestPriority priority,
       const SSLConfig& server_ssl_config,
       const SSLConfig& proxy_ssl_config,
       HostPortPair destination,
       GURL origin_url,
       NetLog* net_log) = 0;
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_HTTP_STREAM_FACTORY_IMPL_JOB_H_