Revert of JobController 1: Remove cross reference between Request, Job, and Impl

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_service.h"
 #include "net/quic/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 {
 
+class BidirectionalStreamImpl;
 class ClientSocketHandle;
 class HttpAuthController;
 class HttpNetworkSession;
 class HttpStream;
 class SpdySessionPool;
 class QuicHttpStream;
 
 // An HttpStreamRequestImpl exists for each stream which is in progress of being
 // created for the StreamFactory.
 class HttpStreamFactoryImpl::Job {
  public:
-  // Delegate to report Job's status to Request and HttpStreamFactory.
-  class NET_EXPORT_PRIVATE Delegate {
-   public:
-    virtual ~Delegate() {}
-
-    // Invoked when |job| has an HttpStream ready.
-    virtual void OnStreamReady(Job* job,
-                               const SSLConfig& used_ssl_config,
-                               const ProxyInfo& used_proxy_info) = 0;
-
-    // Invoked when |job| has a BidirectionalStream ready.
-    virtual void OnBidirectionalStreamImplReady(
-        Job* job,
-        const SSLConfig& used_ssl_config,
-        const ProxyInfo& used_proxy_info) = 0;
-
-    // Invoked when |job| has a WebSocketHandshakeStream ready.
-    virtual void OnWebSocketHandshakeStreamReady(
-        Job* job,
-        const SSLConfig& used_ssl_config,
-        const ProxyInfo& used_proxy_info,
-        WebSocketHandshakeStreamBase* stream) = 0;
-
-    // Invoked when |job| fails to create a stream.
-    virtual void OnStreamFailed(Job* job,
-                                int status,
-                                const SSLConfig& used_ssl_config,
-                                SSLFailureState ssl_failure_state) = 0;
-
-    // Invoked when |job| has a certificate error for the Request.
-    virtual void OnCertificateError(Job* job,
-                                    int status,
-                                    const SSLConfig& used_ssl_config,
-                                    const SSLInfo& ssl_info) = 0;
-
-    // Invoked when |job| has a failure of the CONNECT request through an HTTPS
-    // proxy.
-    virtual void OnHttpsProxyTunnelResponse(
-        Job* job,
-        const HttpResponseInfo& response_info,
-        const SSLConfig& used_ssl_config,
-        const ProxyInfo& used_proxy_info,
-        HttpStream* stream) = 0;
-
-    // Invoked when |job| raises failure for SSL Client Auth.
-    virtual void OnNeedsClientAuth(Job* job,
-                                   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 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;
-
-    // Invoked when the |job| finishes pre-connecting sockets.
-    virtual void OnPreconnectsComplete(Job* job) = 0;
-
-    // Invoked to record connection attempts made by the socket layer to
-    // Request if |job| is associated with Request.
-    virtual void AddConnectionAttemptsToRequest(
-        Job* job,
-        const ConnectionAttempts& attempts) = 0;
-
-    // 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.
-    virtual void SetSpdySessionKey(Job* job,
-                                   const SpdySessionKey& spdy_session_key) = 0;
-
-    // Remove session from the SpdySessionRequestMap.
-    virtual void RemoveRequestFromSpdySessionRequestMapForJob(Job* job) = 0;
-
-    virtual const BoundNetLog* GetNetLog(Job* job) const = 0;
-
-    virtual WebSocketHandshakeStreamBase::CreateHelper*
-    websocket_handshake_stream_create_helper() = 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(Delegate* delegate,
-      JobType job_type,
+  Job(HttpStreamFactoryImpl* stream_factory,
       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.
-  Job(Delegate* delegate,
-      JobType job_type,
+  Job(HttpStreamFactoryImpl* stream_factory,
       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,
       NetLog* net_log);
-  virtual ~Job();
+  ~Job();
 
-  // Start initiates the process of creating a new HttpStream.
-  // |delegate_| will be notified upon completion.
-  virtual void Start(HttpStreamRequest::StreamType stream_type);
+  // Start initiates the process of creating a new HttpStream. |request| will be
+  // notified upon completion if the Job has not been Orphan()'d.
+  void Start(Request* request);
 
   // Preconnect will attempt to request |num_streams| sockets from the
   // appropriate ClientSocketPool.
   int Preconnect(int num_streams);
 
   int RestartTunnelWithProxyAuth(const AuthCredentials& credentials);
   LoadState GetLoadState() const;
 
   // Tells |this| to wait for |job| to resume it.
   void WaitFor(Job* job);
 
   // Tells |this| that |job| has determined it still needs to continue
   // connecting, so allow |this| to continue after the specified |delay|. If
   // this is not called, then |request_| is expected to cancel |this| by
   // deleting it.
   void Resume(Job* job, const base::TimeDelta& delay);
 
-  // Called to detach |this| Job. May resume the other Job, will disconnect
-  // the socket for |this| Job, and notify |delegate| upon completion.
-  void Orphan();
+  // Used to detach the Job from |request|.
+  void Orphan(const Request* request);
 
   void SetPriority(RequestPriority priority);
 
   RequestPriority priority() const { return priority_; }
   bool was_npn_negotiated() const;
   NextProto protocol_negotiated() const;
   bool using_spdy() const;
   const BoundNetLog& net_log() const { return net_log_; }
   HttpStreamRequest::StreamType stream_type() const { return stream_type_; }
 
-  std::unique_ptr<HttpStream> ReleaseStream() { return std::move(stream_); }
-
-  void SetStream(HttpStream* http_stream) { stream_.reset(http_stream); }
-
-  std::unique_ptr<BidirectionalStreamImpl> ReleaseBidirectionalStream() {
-    return std::move(bidirectional_stream_impl_);
-  }
-
   const SSLConfig& server_ssl_config() const;
   const SSLConfig& proxy_ssl_config() const;
   const ProxyInfo& proxy_info() const;
 
+  // Indicates whether or not this job is performing a preconnect.
+  bool IsPreconnecting() const;
+
+  // Indicates whether or not this Job has been orphaned by a Request.
+  bool IsOrphaned() const;
+
   // Called to indicate that this job succeeded, and some other jobs
   // will be orphaned.
   void ReportJobSucceededForRequest();
 
   // Marks that the other |job| has completed.
-  virtual void MarkOtherJobComplete(const Job& job);
-
-  JobType job_type() const { return job_type_; }
+  void MarkOtherJobComplete(const Job& job);
 
  private:
   FRIEND_TEST_ALL_PREFIXES(HttpStreamFactoryImplRequestTest, DelayMainJob);
 
   enum State {
     STATE_START,
     STATE_RESOLVE_PROXY,
     STATE_RESOLVE_PROXY_COMPLETE,
 
     // Note that when Alternate-Protocol says we can connect to an alternate
@@ skipping 187 matching lines @@
   // 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
   // session is found, and OK otherwise.
   static int OnHostResolution(SpdySessionPool* spdy_session_pool,
                               const SpdySessionKey& spdy_session_key,
                               const GURL& origin_url,
                               const AddressList& addresses,
                               const BoundNetLog& net_log);
 
+  Request* request_;
+
   const HttpRequestInfo request_info_;
   RequestPriority priority_;
   ProxyInfo proxy_info_;
   SSLConfig server_ssl_config_;
   SSLConfig proxy_ssl_config_;
   const BoundNetLog net_log_;
 
   CompletionCallback io_callback_;
   std::unique_ptr<ClientSocketHandle> connection_;
   HttpNetworkSession* const session_;
+  HttpStreamFactoryImpl* const stream_factory_;
   State next_state_;
   ProxyService::PacRequest* pac_request_;
   SSLInfo ssl_info_;
 
   // The server we are trying to reach, could be that of the origin or of the
   // alternative service (after applying host mapping rules).
   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.
   GURL origin_url_;
 
   // 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_;
-
-  JobType job_type_;
-
   // This is the Job we're dependent on. It will notify us if/when it's OK to
   // proceed.
   Job* blocking_job_;
 
   // |waiting_job_| is a Job waiting to see if |this| can reuse a connection.
   // If |this| is unable to do so, we'll notify |waiting_job_| that it's ok to
   // proceed and then race the two Jobs.
   Job* waiting_job_;
 
   base::TimeDelta wait_time_;
@@ skipping 54 matching lines @@
   base::TimeTicks job_stream_ready_start_time_;
 
   // Type of stream that is requested.
   HttpStreamRequest::StreamType stream_type_;
 
   base::WeakPtrFactory<Job> ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Job);
 };
 
-// Factory for creating Jobs.
-class HttpStreamFactoryImpl::JobFactory {
- public:
-  virtual ~JobFactory() {}
-
-  // Creates an 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,
-      AlternativeService alternative_service,
-      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_