HttpStreamFactoryImpl::Job cleanup.

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 <utility>
 
@@ skipping 127 matching lines @@
     virtual const NetLogWithSource* GetNetLog() const = 0;
 
     virtual WebSocketHandshakeStreamBase::CreateHelper*
     websocket_handshake_stream_create_helper() = 0;
 
     virtual void MaybeSetWaitTimeForMainJob(const base::TimeDelta& delay) = 0;
 
     virtual bool for_websockets() = 0;
   };
 
-  // Constructor for non-alternative Job.
-  // Job is owned by |delegate|, hence |delegate| is valid for the
-  // lifetime of the Job.
+  // Job is owned by |delegate|, hence |delegate| is valid for the lifetime of
+  // the Job.
+  //
+  // |alternative_protocol| is the protocol required by Alternative Service, if
+  // any:
+  // * |alternative_protocol == kProtoUnknown| means that the Job can pool to an
+  //   existing SpdySession, or bind to a idle TCP socket that might use either
+  //   HTTP/1.1 or HTTP/2.
+  // * |alternative_protocol == kProtoHTTP2| means that the Job can pool to an
+  //   existing SpdySession, or bind to a idle TCP socket.  In the latter case,
+  //   if the socket does not use HTTP/2, then the Job fails.
+  // * |alternative_protocol == kProtoQUIC| means that the Job can pool to an
+  //   existing QUIC connection or open a new one.
+  // Note that this can be overwritten by using a QUIC proxy, or by setting

[xunjieli, 2017/06/14 18:28:01]

Just to be explicit. Could you specify that the QUIC proxy is done through
|alternative_proxy_server| ?

by using a QUIC proxy -> by using a QUIC proxy through
|alternative_proxy_server|.

[Bence, 2017/06/14 19:33:30]

It's good that you bring it up: in fact it is proxy_info_.is_quic() that forces
QUIC to be used.  In the old code that was in line 817, in the new code it's at
line 385, in the .cc file.

For an alternative proxy job, http_stream_factory_impl_job_controller.cc:831
fills |alternative_proxy_info| with |alternative_proxy_server|, and that
|alternative_proxy_info| gets passed to the factory as its |proxy_info|
argument.  So you are right that |alternative_proxy_server| can indirectly force
QUIC, though this seems to happen in JobController, not in Job.

+  // HttpNetworkSession::Params::origins_to_force_quic_on.
+  //
+  // 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 a valid but bad proxy, then fallback proxies
+  // are not used. It is illegal to call this constructor with a valid
+  // |alternative_proxy_server| and an |alternate_protocol| different from
+  // kProtoUnknown.
   Job(Delegate* delegate,
       JobType job_type,
       HttpNetworkSession* session,
       const HttpRequestInfo& request_info,
       RequestPriority priority,
       const ProxyInfo& proxy_info,
       const SSLConfig& server_ssl_config,
       const SSLConfig& proxy_ssl_config,
       HostPortPair destination,
       GURL origin_url,
-      bool enable_ip_based_pooling,
-      NetLog* net_log);
-
-  // Constructor for the alternative Job. The Job is owned by |delegate|, hence
-  // |delegate| is valid for the lifetime of the Job. If |alternative_service|
-  // is initialized, then the Job will use the alternative service. On the
-  // other hand, 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 a valid but bad proxy, then
-  // fallback proxies are not used. It is illegal to call this with an
-  // initialized |alternative_service|, and a valid |alternative_proxy_server|.
-  Job(Delegate* delegate,
-      JobType job_type,
-      HttpNetworkSession* session,
-      const HttpRequestInfo& request_info,
-      RequestPriority priority,
-      const ProxyInfo& proxy_info,
-      const SSLConfig& server_ssl_config,
-      const SSLConfig& proxy_ssl_config,
-      HostPortPair destination,
-      GURL origin_url,
-      AlternativeService alternative_service,
+      NextProto alternative_protocol,
       const ProxyServer& alternative_proxy_server,
       bool enable_ip_based_pooling,
       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
@@ skipping 31 matching lines @@
   // Returns the estimated memory usage in bytes.
   size_t EstimateMemoryUsage() const;
 
   bool is_waiting() const { return next_state_ == STATE_WAIT_COMPLETE; }
   const SSLConfig& server_ssl_config() const;
   const SSLConfig& proxy_ssl_config() const;
   const ProxyInfo& proxy_info() const;
 
   JobType job_type() const { return job_type_; }
 
-  const AlternativeService alternative_service() const {
-    return alternative_service_;
-  }
-
   const ProxyServer alternative_proxy_server() const {
     return alternative_proxy_server_;
   }
 
   bool using_existing_quic_session() const {
     return using_existing_quic_session_;
   }
 
   bool should_reconsider_proxy() const { return should_reconsider_proxy_; }
 
@@ skipping 79 matching lines @@
   int SetSpdyHttpStreamOrBidirectionalStreamImpl(
       base::WeakPtr<SpdySession> session,
       bool direct);
 
   // Returns to STATE_INIT_CONNECTION and resets some state.
   void ReturnToStateInitConnection(bool close_connection);
 
   // Set the motivation for this request onto the underlying socket.
   void SetSocketMotivation();
 
-  // Is this a SPDY or QUIC alternative Job?
-  bool IsSpdyAlternative() const;
-  bool IsQuicAlternative() const;
-
   // Sets several fields of |ssl_config| based on the proxy info and other
   // factors.
   void InitSSLConfig(SSLConfig* ssl_config, bool is_proxy) const;
 
   // Retrieve SSLInfo from our SSL Socket.
   // This must only be called when we are using an SSLSocket.
   void GetSSLInfo(SSLInfo* ssl_info);
 
+  // Called in Job constructor: should Job be forced to use QUIC.
+  static bool ShouldForceQuic(HttpNetworkSession* session,
+                              const HostPortPair& destination,
+                              GURL origin_url,

[xunjieli, 2017/06/14 18:28:01]

nit: const GURL& 

[Bence, 2017/06/14 19:33:30]

Done.

+                              const ProxyInfo& proxy_info);
+
   // Called in Job constructor. Use |spdy_session_key_| after construction.
-  SpdySessionKey GetSpdySessionKey() const;
+  static SpdySessionKey GetSpdySessionKey(bool spdy_session_direct,
+                                          const ProxyServer& proxy_server,
+                                          const GURL& origin_url,
+                                          PrivacyMode privacy_mode);
 
   // Returns true if the current request can use an existing spdy session.
   bool CanUseExistingSpdySession() const;
 
   // Called when we encounter a network error that could be resolved by trying
   // a new proxy configuration.  If there is another proxy configuration to try
   // then this method sets next_state_ appropriately and returns either OK or
   // ERR_IO_PENDING depending on whether or not the new proxy configuration is
   // available synchronously or asynchronously.  Otherwise, the given error
   // code is simply returned.
   int ReconsiderProxyAfterError(int error);
 
   // Called to handle a certificate error.  Stores the certificate in the
   // allowed_bad_certs list, and checks if the error can be ignored.  Returns
   // OK if it can be ignored, or the error code otherwise.
   int HandleCertificateError(int error);
 
   // Called to handle a client certificate request.
   int HandleCertificateRequest(int error);
 
-  // Should we force QUIC for this stream request.
-  bool ShouldForceQuic() 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 22 matching lines @@
   State next_state_;
 
   // The server we are trying to reach, could be that of the origin or of the
   // alternative service (after applying host mapping rules).
   const HostPortPair destination_;
 
   // The origin url we're trying to reach. This url may be different from the
   // original request when host mapping rules are set-up.
   const GURL origin_url_;
 
-  // AlternativeService for this Job if this is an alternative Job.
-  const AlternativeService alternative_service_;
-
   // Alternative proxy server that should be used by |this| to fetch the
   // request.
   const ProxyServer alternative_proxy_server_;
 
   // Enable pooling to a SpdySession with matching IP and certificate
   // even if the SpdySessionKey is different.
   const bool enable_ip_based_pooling_;
 
   // Unowned. |this| job is owned by |delegate_|.
   Delegate* const delegate_;
 
   const JobType job_type_;
 
   // True if handling a HTTPS request.
   const bool using_ssl_;
 
-  // True if this network transaction is using SPDY instead of HTTP.
+  // True if Job uses QUIC.
+  const bool using_quic_;
+
+  // True if Alternative Service protocol field requires that HTTP/2 is used.
+  // In this case, Job fails if it cannot pool to an existing SpdySession and
+  // the server does not negotiate HTTP/2 on a new socket.
+  const bool expect_spdy_;
+
+  // True if Job actually uses HTTP/2.
   bool using_spdy_;
 
-  // True if this network transaction is using QUIC instead of HTTP.
-  bool using_quic_;
-
   // True if this job might succeed with a different proxy config.
   bool should_reconsider_proxy_;
 
   QuicStreamRequest quic_request_;
 
   // True if this job used an existing QUIC session.
   bool using_existing_quic_session_;
 
   // True when the tunnel is in the process of being established - we can't
   // read from the socket until the tunnel is done.
@@ skipping 59 matching lines @@
       HttpStreamFactoryImpl::Job::Delegate* delegate,
       HttpStreamFactoryImpl::JobType job_type,
       HttpNetworkSession* session,
       const HttpRequestInfo& request_info,
       RequestPriority priority,
       const ProxyInfo& proxy_info,
       const SSLConfig& server_ssl_config,
       const SSLConfig& proxy_ssl_config,
       HostPortPair destination,
       GURL origin_url,
-      AlternativeService alternative_service,
+      NextProto alternative_protocol,
       bool enable_ip_based_pooling,
       NetLog* net_log);
 
   virtual std::unique_ptr<HttpStreamFactoryImpl::Job> CreateAltProxyJob(
       HttpStreamFactoryImpl::Job::Delegate* delegate,
       HttpStreamFactoryImpl::JobType job_type,
       HttpNetworkSession* session,
       const HttpRequestInfo& request_info,
       RequestPriority priority,
       const ProxyInfo& proxy_info,
       const SSLConfig& server_ssl_config,
       const SSLConfig& proxy_ssl_config,
       HostPortPair destination,
       GURL origin_url,
       const ProxyServer& alternative_proxy_server,
       bool enable_ip_based_pooling,
       NetLog* net_log);
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_HTTP_STREAM_FACTORY_IMPL_JOB_H_