JobController 1: Adding a new class HttpStreamFactoryImpl::JobController

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.h"
+
+namespace net {
+
+// HttpStreamFactoryImpl::JobController manages Request and Jobs.
+class HttpStreamFactoryImpl::JobController {
+ public:
+  JobController(HttpStreamFactoryImpl* factory,
+                HttpStreamRequest::Delegate* delegate,
+                HttpNetworkSession* session);
+  ~JobController();
+
+  // Creates request and hands out to HttpStreamFactoryImpl, creates Job(s) and
+  // starts serving the created request.
+  Request* Start(const HttpRequestInfo& request_info,
+                 HttpStreamRequest::Delegate* delegate,
+                 WebSocketHandshakeStreamBase::CreateHelper*
+                     websocket_handshake_stream_create_helper,
+                 const BoundNetLog& net_log,
+                 HttpStreamRequest::StreamType stream_type,
+                 RequestPriority priority,
+                 const SSLConfig& server_ssl_config,
+                 const SSLConfig& proxy_ssl_config);
+
+  void Preconnect(int num_streams,
+                  const HttpRequestInfo& request_info,
+                  const SSLConfig& server_ssl_config,
+                  const SSLConfig& proxy_ssl_config);
+
+  LoadState GetLoadState() const;
+
+  void SetPriority(RequestPriority priority);
+
+  int RestartTunnelWithProxyAuth(const AuthCredentials& credentials);
+
+  // Used to bind |job| to the |request_| and orphan all other jobs in |jobs_|.
+  void BindJob(Job* job);
+
+  // Used to orphan all jobs in |jobs_|.
+  void OrphanJobs();
+
+  // Called when a Job succeeds.
+  void CancelJobs();
+
+  // Called when a Job succeeds.
+  void OnJobSucceeded(Job* job);
+
+  void OnRequestFinish();
+
+  // Marks completion of the |request_|. Must be called before OnStreamReady().
+  void MarkRequestComplete(bool was_npn_negotiated,
+                           NextProto protocol_negotiated,
+                           bool using_spdy);
+
+  void OnStreamReady(Job* job,
+                     const SSLConfig& used_ssl_config,
+                     const ProxyInfo& used_proxy_info);
+
+  void OnBidirectionalStreamImplReady(Job* job,
+                                      const SSLConfig& used_ssl_config,
+                                      const ProxyInfo& used_proxy_info);
+
+  void OnWebSocketHandshakeStreamReady(Job* job,
+                                       const SSLConfig& used_ssl_config,
+                                       const ProxyInfo& used_proxy_info,
+                                       WebSocketHandshakeStreamBase* stream);
+
+  void OnStreamFailed(Job* job,
+                      int status,
+                      const SSLConfig& used_ssl_config,
+                      SSLFailureState ssl_failure_state);
+
+  void OnCertificateError(Job* job,
+                          int status,
+                          const SSLConfig& used_ssl_config,
+                          const SSLInfo& ssl_info);
+
+  void OnNeedsProxyAuth(Job* job,
+                        const HttpResponseInfo& proxy_response,
+                        const SSLConfig& used_ssl_config,
+                        const ProxyInfo& used_proxy_info,
+                        HttpAuthController* auth_controller);
+
+  void OnNeedsClientAuth(Job* job,
+                         const SSLConfig& used_ssl_config,
+                         SSLCertRequestInfo* cert_info);
+
+  void OnHttpsProxyTunnelResponse(Job* job,
+                                  const HttpResponseInfo& response_info,
+                                  const SSLConfig& used_ssl_config,
+                                  const ProxyInfo& used_proxy_info,
+                                  HttpStream* stream);
+
+  // Notify the |request_| and |factoy_| of the readiness of new SPDY session.
+  void OnNewSpdySessionReady(Job* job,
+                             const base::WeakPtr<SpdySession>& spdy_session,
+                             bool direct);
+
+  // Invoked when the Job finishes pre-connecting sockets.
+  void OnPreconnectsComplete(Job* job);
+
+  // Invoked when an orphaned Job finishes.
+  void OnOrphanedJobComplete(const Job* job);
+
+  // Called by an attached Job to record connection attempts made by the socket
+  // layer to |request_|.
+  void AddConnectionAttemptsToRequest(Job* job,
+                                      const ConnectionAttempts& attempts);
+
+  // 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);
+
+  // Remove session from the SpdySessionRequestMap.
+  void RemoveRequestFromSpdySessionRequestMap(Job* job);
+
+  void MaybeNotifyFactoryOfCompletion();
+
+  const BoundNetLog* GetNetLog(Job* job) const;
+
+  bool for_websockets() { return factory_->for_websockets_; }
+
+  WebSocketHandshakeStreamBase::CreateHelper*
+  websocket_handshake_stream_create_helper();
+
+ private:
+  FRIEND_TEST_ALL_PREFIXES(HttpStreamFactoryImplRequestTest, SetPriority);
+  FRIEND_TEST_ALL_PREFIXES(HttpStreamFactoryImplRequestTest, DelayMainJob);
+
+  // 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);
+
+  // Attaches |job| to |request_|. Does not mean that |request_| will use |job|.
+  void AttachJob(Job* job);
+
+  GURL ApplyHostMappingRules(const GURL& url, HostPortPair* endpoint);
+
+  // 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);
+
+  // Remove session from the SpdySessionRequestMap.
+  void RemoveRequestFromSpdySessionRequestMap();
+
+  HttpStreamFactoryImpl* factory_;
+  HttpNetworkSession* session_;
+  // Request will be handed out to factory once created. This just keeps an
+  // reference. It will be set to NULL once the request is completed.
+  Request* request_;
+
+  HttpStreamRequest::Delegate* const delegate_;
+
+  // True if this JobController is used to preconnect streams.
+  bool is_preconnect_;
+
+  // |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 ever a job is explicitly bounded to the |request_|.
+  bool job_bounded_;
+
+  // At the point where a Job is irrevocably tied to |request_|, we set this.
+  Job* bound_job_;
+};
+
+}  // namespace net
+
+#endif  // NET_HTTP_HTTP_STREAM_FACTORY_IMPL_JOB_CONTROLLER_H_