Home | History | Annotate | Download | only in http 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #ifndef NET_HTTP_HTTP_STREAM_FACTORY_IMPL_JOB_H_
      6 #define NET_HTTP_HTTP_STREAM_FACTORY_IMPL_JOB_H_
      7 
      8 #include "base/memory/ref_counted.h"
      9 #include "base/memory/scoped_ptr.h"
     10 #include "base/memory/weak_ptr.h"
     11 #include "net/base/completion_callback.h"
     12 #include "net/base/net_log.h"
     13 #include "net/base/request_priority.h"
     14 #include "net/http/http_auth.h"
     15 #include "net/http/http_auth_controller.h"
     16 #include "net/http/http_pipelined_host.h"
     17 #include "net/http/http_request_info.h"
     18 #include "net/http/http_stream_factory_impl.h"
     19 #include "net/proxy/proxy_service.h"
     20 #include "net/quic/quic_stream_factory.h"
     21 #include "net/socket/client_socket_handle.h"
     22 #include "net/socket/ssl_client_socket.h"
     23 #include "net/spdy/spdy_session_key.h"
     24 #include "net/ssl/ssl_config_service.h"
     25 
     26 namespace net {
     27 
     28 class ClientSocketHandle;
     29 class HttpAuthController;
     30 class HttpNetworkSession;
     31 class HttpStream;
     32 class SpdySessionPool;
     33 class QuicHttpStream;
     34 
     35 // An HttpStreamRequestImpl exists for each stream which is in progress of being
     36 // created for the StreamFactory.
     37 class HttpStreamFactoryImpl::Job {
     38  public:
     39   Job(HttpStreamFactoryImpl* stream_factory,
     40       HttpNetworkSession* session,
     41       const HttpRequestInfo& request_info,
     42       RequestPriority priority,
     43       const SSLConfig& server_ssl_config,
     44       const SSLConfig& proxy_ssl_config,
     45       NetLog* net_log);
     46   ~Job();
     47 
     48   // Start initiates the process of creating a new HttpStream. |request| will be
     49   // notified upon completion if the Job has not been Orphan()'d.
     50   void Start(Request* request);
     51 
     52   // Preconnect will attempt to request |num_streams| sockets from the
     53   // appropriate ClientSocketPool.
     54   int Preconnect(int num_streams);
     55 
     56   int RestartTunnelWithProxyAuth(const AuthCredentials& credentials);
     57   LoadState GetLoadState() const;
     58 
     59   // Marks this Job as the "alternate" job, from Alternate-Protocol. Tracks the
     60   // original url so we can mark the Alternate-Protocol as broken if
     61   // we fail to connect.  |alternate| specifies the alternate protocol to use
     62   // and alternate port to connect to.
     63   void MarkAsAlternate(const GURL& original_url,
     64                        PortAlternateProtocolPair alternate);
     65 
     66   // Tells |this| to wait for |job| to resume it.
     67   void WaitFor(Job* job);
     68 
     69   // Tells |this| that |job| has determined it still needs to continue
     70   // connecting, so allow |this| to continue. If this is not called, then
     71   // |request_| is expected to cancel |this| by deleting it.
     72   void Resume(Job* job);
     73 
     74   // Used to detach the Job from |request|.
     75   void Orphan(const Request* request);
     76 
     77   void SetPriority(RequestPriority priority);
     78 
     79   RequestPriority priority() const { return priority_; }
     80   bool was_npn_negotiated() const;
     81   NextProto protocol_negotiated() const;
     82   bool using_spdy() const;
     83   const BoundNetLog& net_log() const { return net_log_; }
     84 
     85   const SSLConfig& server_ssl_config() const;
     86   const SSLConfig& proxy_ssl_config() const;
     87   const ProxyInfo& proxy_info() const;
     88 
     89   // Indicates whether or not this job is performing a preconnect.
     90   bool IsPreconnecting() const;
     91 
     92   // Indicates whether or not this Job has been orphaned by a Request.
     93   bool IsOrphaned() const;
     94 
     95  private:
     96   enum State {
     97     STATE_START,
     98     STATE_RESOLVE_PROXY,
     99     STATE_RESOLVE_PROXY_COMPLETE,
    100 
    101     // Note that when Alternate-Protocol says we can connect to an alternate
    102     // port using a different protocol, we have the choice of communicating over
    103     // the original protocol, or speaking the alternate protocol (currently,
    104     // only npn-spdy) over an alternate port. For a cold page load, the http
    105     // connection that delivers the http response that has the
    106     // Alternate-Protocol header will already be warm. So, blocking the next
    107     // http request on establishing a new npn-spdy connection would incur extra
    108     // latency. Even if the http connection was not reused, establishing a new
    109     // http connection is typically faster than npn-spdy, since npn-spdy
    110     // requires a SSL handshake. Therefore, we start both the http and the
    111     // npn-spdy jobs in parallel. In order not to unnecessarily waste sockets,
    112     // we have the http job block on the npn-spdy job after proxy resolution.
    113     // The npn-spdy job will Resume() the http job if, in
    114     // STATE_INIT_CONNECTION_COMPLETE, it detects an error or does not find an
    115     // existing SpdySession. In that case, the http and npn-spdy jobs will race.
    116     STATE_WAIT_FOR_JOB,
    117     STATE_WAIT_FOR_JOB_COMPLETE,
    118 
    119     STATE_INIT_CONNECTION,
    120     STATE_INIT_CONNECTION_COMPLETE,
    121     STATE_WAITING_USER_ACTION,
    122     STATE_RESTART_TUNNEL_AUTH,
    123     STATE_RESTART_TUNNEL_AUTH_COMPLETE,
    124     STATE_CREATE_STREAM,
    125     STATE_CREATE_STREAM_COMPLETE,
    126     STATE_DRAIN_BODY_FOR_AUTH_RESTART,
    127     STATE_DRAIN_BODY_FOR_AUTH_RESTART_COMPLETE,
    128     STATE_DONE,
    129     STATE_NONE
    130   };
    131 
    132   void OnStreamReadyCallback();
    133   void OnWebSocketHandshakeStreamReadyCallback();
    134   // This callback function is called when a new SPDY session is created.
    135   void OnNewSpdySessionReadyCallback();
    136   void OnStreamFailedCallback(int result);
    137   void OnCertificateErrorCallback(int result, const SSLInfo& ssl_info);
    138   void OnNeedsProxyAuthCallback(const HttpResponseInfo& response_info,
    139                                 HttpAuthController* auth_controller);
    140   void OnNeedsClientAuthCallback(SSLCertRequestInfo* cert_info);
    141   void OnHttpsProxyTunnelResponseCallback(const HttpResponseInfo& response_info,
    142                                           HttpStream* stream);
    143   void OnPreconnectsComplete();
    144 
    145   void OnIOComplete(int result);
    146   int RunLoop(int result);
    147   int DoLoop(int result);
    148   int StartInternal();
    149 
    150   // Each of these methods corresponds to a State value.  Those with an input
    151   // argument receive the result from the previous state.  If a method returns
    152   // ERR_IO_PENDING, then the result from OnIOComplete will be passed to the
    153   // next state method as the result arg.
    154   int DoStart();
    155   int DoResolveProxy();
    156   int DoResolveProxyComplete(int result);
    157   int DoWaitForJob();
    158   int DoWaitForJobComplete(int result);
    159   int DoInitConnection();
    160   int DoInitConnectionComplete(int result);
    161   int DoWaitingUserAction(int result);
    162   int DoCreateStream();
    163   int DoCreateStreamComplete(int result);
    164   int DoRestartTunnelAuth();
    165   int DoRestartTunnelAuthComplete(int result);
    166 
    167   // Returns to STATE_INIT_CONNECTION and resets some state.
    168   void ReturnToStateInitConnection(bool close_connection);
    169 
    170   // Set the motivation for this request onto the underlying socket.
    171   void SetSocketMotivation();
    172 
    173   bool IsHttpsProxyAndHttpUrl() const;
    174 
    175   // Sets several fields of ssl_config for the given origin_server based on the
    176   // proxy info and other factors.
    177   void InitSSLConfig(const HostPortPair& origin_server,
    178                      SSLConfig* ssl_config,
    179                      bool is_proxy) const;
    180 
    181   // Retrieve SSLInfo from our SSL Socket.
    182   // This must only be called when we are using an SSLSocket.
    183   // After calling, the caller can use ssl_info_.
    184   void GetSSLInfo();
    185 
    186   SpdySessionKey GetSpdySessionKey() const;
    187 
    188   // Returns true if the current request can use an existing spdy session.
    189   bool CanUseExistingSpdySession() const;
    190 
    191   // Called when we encounter a network error that could be resolved by trying
    192   // a new proxy configuration.  If there is another proxy configuration to try
    193   // then this method sets next_state_ appropriately and returns either OK or
    194   // ERR_IO_PENDING depending on whether or not the new proxy configuration is
    195   // available synchronously or asynchronously.  Otherwise, the given error
    196   // code is simply returned.
    197   int ReconsiderProxyAfterError(int error);
    198 
    199   // Called to handle a certificate error.  Stores the certificate in the
    200   // allowed_bad_certs list, and checks if the error can be ignored.  Returns
    201   // OK if it can be ignored, or the error code otherwise.
    202   int HandleCertificateError(int error);
    203 
    204   // Called to handle a client certificate request.
    205   int HandleCertificateRequest(int error);
    206 
    207   // Moves this stream request into SPDY mode.
    208   void SwitchToSpdyMode();
    209 
    210   // Should we force SPDY to run over SSL for this stream request.
    211   bool ShouldForceSpdySSL() const;
    212 
    213   // Should we force SPDY to run without SSL for this stream request.
    214   bool ShouldForceSpdyWithoutSSL() const;
    215 
    216   // Should we force QUIC for this stream request.
    217   bool ShouldForceQuic() const;
    218 
    219   bool IsRequestEligibleForPipelining();
    220 
    221   // Record histograms of latency until Connect() completes.
    222   static void LogHttpConnectedMetrics(const ClientSocketHandle& handle);
    223 
    224   // Invoked by the transport socket pool after host resolution is complete
    225   // to allow the connection to be aborted, if a matching SPDY session can
    226   // be found.  Will return ERR_SPDY_SESSION_ALREADY_EXISTS if such a
    227   // session is found, and OK otherwise.
    228   static int OnHostResolution(SpdySessionPool* spdy_session_pool,
    229                               const SpdySessionKey& spdy_session_key,
    230                               const AddressList& addresses,
    231                               const BoundNetLog& net_log);
    232 
    233   Request* request_;
    234 
    235   const HttpRequestInfo request_info_;
    236   RequestPriority priority_;
    237   ProxyInfo proxy_info_;
    238   SSLConfig server_ssl_config_;
    239   SSLConfig proxy_ssl_config_;
    240   const BoundNetLog net_log_;
    241 
    242   CompletionCallback io_callback_;
    243   scoped_ptr<ClientSocketHandle> connection_;
    244   HttpNetworkSession* const session_;
    245   HttpStreamFactoryImpl* const stream_factory_;
    246   State next_state_;
    247   ProxyService::PacRequest* pac_request_;
    248   SSLInfo ssl_info_;
    249 
    250   // The origin server we're trying to reach.
    251   HostPortPair origin_;
    252 
    253   // The origin url we're trying to reach. This url may be different from the
    254   // original request when host mapping rules are set-up.
    255   GURL origin_url_;
    256 
    257   // If this is a Job for an "Alternate-Protocol", then this will be non-NULL
    258   // and will specify the original URL.
    259   scoped_ptr<GURL> original_url_;
    260 
    261   // This is the Job we're dependent on. It will notify us if/when it's OK to
    262   // proceed.
    263   Job* blocking_job_;
    264 
    265   // |waiting_job_| is a Job waiting to see if |this| can reuse a connection.
    266   // If |this| is unable to do so, we'll notify |waiting_job_| that it's ok to
    267   // proceed and then race the two Jobs.
    268   Job* waiting_job_;
    269 
    270   // True if handling a HTTPS request, or using SPDY with SSL
    271   bool using_ssl_;
    272 
    273   // True if this network transaction is using SPDY instead of HTTP.
    274   bool using_spdy_;
    275 
    276   // True if this network transaction is using QUIC instead of HTTP.
    277   bool using_quic_;
    278   QuicStreamRequest quic_request_;
    279 
    280   // Force spdy for all connections.
    281   bool force_spdy_always_;
    282 
    283   // Force spdy only for SSL connections.
    284   bool force_spdy_over_ssl_;
    285 
    286   // Force quic for a specific port.
    287   int force_quic_port_;
    288 
    289   // The certificate error while using SPDY over SSL for insecure URLs.
    290   int spdy_certificate_error_;
    291 
    292   scoped_refptr<HttpAuthController>
    293       auth_controllers_[HttpAuth::AUTH_NUM_TARGETS];
    294 
    295   // True when the tunnel is in the process of being established - we can't
    296   // read from the socket until the tunnel is done.
    297   bool establishing_tunnel_;
    298 
    299   scoped_ptr<HttpStream> stream_;
    300   scoped_ptr<WebSocketHandshakeStreamBase> websocket_stream_;
    301 
    302   // True if we negotiated NPN.
    303   bool was_npn_negotiated_;
    304 
    305   // Protocol negotiated with the server.
    306   NextProto protocol_negotiated_;
    307 
    308   // 0 if we're not preconnecting. Otherwise, the number of streams to
    309   // preconnect.
    310   int num_streams_;
    311 
    312   // Initialized when we create a new SpdySession.
    313   base::WeakPtr<SpdySession> new_spdy_session_;
    314 
    315   // Initialized when we have an existing SpdySession.
    316   base::WeakPtr<SpdySession> existing_spdy_session_;
    317 
    318   // Only used if |new_spdy_session_| is non-NULL.
    319   bool spdy_session_direct_;
    320 
    321   // Key used to identify the HttpPipelinedHost for |request_|.
    322   scoped_ptr<HttpPipelinedHost::Key> http_pipelining_key_;
    323 
    324   // True if an existing pipeline can handle this job's request.
    325   bool existing_available_pipeline_;
    326 
    327   base::WeakPtrFactory<Job> ptr_factory_;
    328 
    329   DISALLOW_COPY_AND_ASSIGN(Job);
    330 };
    331 
    332 }  // namespace net
    333 
    334 #endif  // NET_HTTP_HTTP_STREAM_FACTORY_IMPL_JOB_H_
    335