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 Job(s).
+class HttpStreamFactoryImpl::JobController {
+ public:
+  JobController(HttpStreamFactoryImpl* factory,
+                HttpStreamRequest::Delegate* delegate,
+                HttpNetworkSession* session);
+  ~JobController();
+
+  bool for_websockets() { return factory_->for_websockets_; }
+
+  // Methods below are called by HttpStreamFactoryImpl only.
+  // Creates request and hands out to HttpStreamFactoryImpl, this will also
+  // create Job(s) and start 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);
+
+  // Methods below are called by HttpStreamFactoryImpl::Request only.
+  LoadState GetLoadState() const;
+
+  // Called when |request_| is destructed.
+  // Job(s) associated with but not bound to |request_| will be deleted.
+  // |request_| and |bound_job_| will be nulled if ever set.
+  void OnRequestComplete();
+
+  int RestartTunnelWithProxyAuth(const AuthCredentials& credentials);
+
+  void SetPriority(RequestPriority priority);
+
+  // Methods below are called by HttpStreamFactoryImpl::Job only.
+  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 OnHttpsProxyTunnelResponse(Job* job,
+                                  const HttpResponseInfo& response_info,
+                                  const SSLConfig& used_ssl_config,
+                                  const ProxyInfo& used_proxy_info,
+                                  HttpStream* stream);
+
+  void OnNeedsClientAuth(Job* job,
+                         const SSLConfig& used_ssl_config,
+                         SSLCertRequestInfo* cert_info);
+
+  void OnNeedsProxyAuth(Job* job,
+                        const HttpResponseInfo& proxy_response,
+                        const SSLConfig& used_ssl_config,
+                        const ProxyInfo& used_proxy_info,
+                        HttpAuthController* auth_controller);
+
+  // Invoked to notify the |request_| and |factory_| of the readiness of new
+  // SPDY session.
+  void OnNewSpdySessionReady(Job* job,
+                             const base::WeakPtr<SpdySession>& spdy_session,
+                             bool direct);
+
+  // Invoked when the orphaned |job| finishes.
+  void OnOrphanedJobComplete(const Job* job);
+
+  // Invoked when the |job| finishes pre-connecting sockets.
+  void OnPreconnectsComplete(Job* job);
+
+  // Invoked to record connection attempts made by the socket layer to
+  // |request_| if |job| is associated with |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);

[Randy Smith (Not in Mondays), 2016/05/16 20:46:39]

The style guide discourages using overloading, i.e. two methods with the same
name but different arguments; specifically, they discourage doing it unless it's
pretty clear from the call site what different functionality (if any) will be
invoked.  My inclination is to say that this isn't such a situation; can you
rename one of the two methods?

https://google.github.io/styleguide/cppguide.html#Function_Overloading

[Zhongyi Shi, 2016/05/16 23:08:53]

Done.

+
+  const BoundNetLog* GetNetLog(Job* job) const;
+
+  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);
+
+  // Called to bind |job| to the |request_| and orphan all other jobs that are
+  // still associated with |request_|.
+  void BindJob(Job* job);
+
+  // Called when |request_| is destructed.
+  // Job(s) associated with but not bound to |request_| will be deleted.
+  void CancelJobs();
+
+  // Used to orphan jobs.
+  // Job(s) associated with not bounded to the |request_| will be disassociated
+  // from the |request_| so that it will not be canceled when |request_| is
+  // destructed. Nor will it report completion to |request_|.
+  void OrphanJobs();
+
+  // Called when a Job succeeds.
+  void OnJobSucceeded(Job* job);
+
+  // Marks completion of the |request_|.
+  void MarkRequestComplete(bool was_npn_negotiated,
+                           NextProto protocol_negotiated,
+                           bool using_spdy);
+
+  void MaybeNotifyFactoryOfCompletion();
+
+  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 and is safe as |request_| will notify |this| JobController
+  // when it's destructed by calling OnRequestComplete(), which nulls
+  // |request_|.
+  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 a Job has ever been bound to the |request_|.
+  bool job_bound_;
+
+  // At the point where a Job is irrevocably tied to |request_|, we set this.
+  // It will be nulled when the |request_| is finished.
+  Job* bound_job_;
+};
+
+}  // namespace net
+
+#endif  // NET_HTTP_HTTP_STREAM_FACTORY_IMPL_JOB_CONTROLLER_H_