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

net/http/http_stream_factory_impl_job.cc

 // 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.
 
 #include "net/http/http_stream_factory_impl_job.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 
@@ skipping 135 matching lines @@
     const std::string* proto,
     NetLogCaptureMode /* capture_mode */) {
   std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
 
   dict->SetString("next_proto_status",
                   SSLClientSocket::NextProtoStatusToString(status));
   dict->SetString("proto", *proto);
   return std::move(dict);
 }
 
-HttpStreamFactoryImpl::Job::Job(Delegate* delegate,
-                                JobType job_type,
+HttpStreamFactoryImpl::Job::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)
-    : Job(delegate,
-          job_type,
+    : Job(stream_factory,
           session,
           request_info,
           priority,
           server_ssl_config,
           proxy_ssl_config,
           destination,
           origin_url,
           AlternativeService(),
           net_log) {}
 
-HttpStreamFactoryImpl::Job::Job(Delegate* delegate,
-                                JobType job_type,
+HttpStreamFactoryImpl::Job::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)
-    : request_info_(request_info),
+    : request_(NULL),
+      request_info_(request_info),
       priority_(priority),
       server_ssl_config_(server_ssl_config),
       proxy_ssl_config_(proxy_ssl_config),
       net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_HTTP_STREAM_JOB)),
       io_callback_(base::Bind(&Job::OnIOComplete, base::Unretained(this))),
       connection_(new ClientSocketHandle),
       session_(session),
+      stream_factory_(stream_factory),
       next_state_(STATE_NONE),
       pac_request_(NULL),
       destination_(destination),
       origin_url_(origin_url),
       alternative_service_(alternative_service),
-      delegate_(delegate),
-      job_type_(job_type),
       blocking_job_(NULL),
       waiting_job_(NULL),
       using_ssl_(false),
       using_spdy_(false),
       using_quic_(false),
       quic_request_(session_->quic_stream_factory()),
       using_existing_quic_session_(false),
       spdy_certificate_error_(OK),
       establishing_tunnel_(false),
       was_npn_negotiated_(false),
       protocol_negotiated_(kProtoUnknown),
       num_streams_(0),
       spdy_session_direct_(false),
       job_status_(STATUS_RUNNING),
       other_job_status_(STATUS_RUNNING),
       stream_type_(HttpStreamRequest::BIDIRECTIONAL_STREAM),
       ptr_factory_(this) {
+  DCHECK(stream_factory);
   DCHECK(session);
   if (IsSpdyAlternative() &&
       !session_->params().enable_alternative_service_for_insecure_origins) {
     DCHECK(origin_url_.SchemeIs("https"));
   }
   if (IsQuicAlternative()) {
     DCHECK(session_->params().enable_quic);
     using_quic_ = true;
   }
 }
@@ skipping 10 matching lines @@
   }
 
   if (pac_request_)
     session_->proxy_service()->CancelPacRequest(pac_request_);
 
   // The stream could be in a partial state.  It is not reusable.
   if (stream_.get() && next_state_ != STATE_DONE)
     stream_->Close(true /* not reusable */);
 }
 
-void HttpStreamFactoryImpl::Job::Start(
-    HttpStreamRequest::StreamType stream_type) {
-  stream_type_ = stream_type;
+void HttpStreamFactoryImpl::Job::Start(Request* request) {
+  DCHECK(request);
+  request_ = request;
+  // Saves |stream_type_|, since request is nulled when job is orphaned.
+  stream_type_ = request_->stream_type();
   StartInternal();
 }
 
 int HttpStreamFactoryImpl::Job::Preconnect(int num_streams) {
   DCHECK_GT(num_streams, 0);
   base::WeakPtr<HttpServerProperties> http_server_properties =
       session_->http_server_properties();
   if (http_server_properties &&
       http_server_properties->SupportsRequestPriority(
           url::SchemeHostPort(request_info_.url))) {
@@ skipping 58 matching lines @@
   // be delayed by the |wait_time_| when it resumes.
   if (next_state_ == STATE_NONE || next_state_ <= STATE_WAIT_FOR_JOB_COMPLETE)
     wait_time_ = delay;
 
   // We know we're blocked if the next_state_ is STATE_WAIT_FOR_JOB_COMPLETE.
   // Unblock |this|.
   if (next_state_ == STATE_WAIT_FOR_JOB_COMPLETE)
     ResumeAfterDelay();
 }
 
-void HttpStreamFactoryImpl::Job::Orphan() {
+void HttpStreamFactoryImpl::Job::Orphan(const Request* request) {
+  DCHECK_EQ(request_, request);
+  request_ = NULL;
   net_log_.AddEvent(NetLog::TYPE_HTTP_STREAM_JOB_ORPHANED);
   if (blocking_job_) {
     // We've been orphaned, but there's a job we're blocked on. Don't bother
     // racing, just cancel ourself.
     DCHECK(blocking_job_->waiting_job_);
     blocking_job_->waiting_job_ = NULL;
     blocking_job_ = NULL;
-    if (delegate_->for_websockets() && connection_ && connection_->socket()) {
+    if (stream_factory_->for_websockets_ &&
+        connection_ && connection_->socket()) {
       connection_->socket()->Disconnect();
     }
-    delegate_->OnOrphanedJobComplete(this);
-  } else if (delegate_->for_websockets()) {
+    stream_factory_->OnOrphanedJobComplete(this);
+  } else if (stream_factory_->for_websockets_) {
     // We cancel this job because a WebSocketHandshakeStream can't be created
     // without a WebSocketHandshakeStreamBase::CreateHelper which is stored in
-    // the Request class and isn't retrievable by this job.
+    // the Request class and isn't accessible from this job.
     if (connection_ && connection_->socket()) {
       connection_->socket()->Disconnect();
     }
-    delegate_->OnOrphanedJobComplete(this);
+    stream_factory_->OnOrphanedJobComplete(this);
   }
-  // |this| may be deleted after this call.
 }
 
 void HttpStreamFactoryImpl::Job::SetPriority(RequestPriority priority) {
   priority_ = priority;
   // TODO(akalin): Propagate this to |connection_| and maybe the
   // preconnect state.
 }
 
 bool HttpStreamFactoryImpl::Job::was_npn_negotiated() const {
   return was_npn_negotiated_;
@@ skipping 47 matching lines @@
   // https (the normal case) or if we're connection to a SPDY proxy.
   // https://crbug.com/133176
   // TODO(ricea): Add "wss" back to this list when SPDY WebSocket support is
   // working.
   return origin_url_.SchemeIs("https") ||
          proxy_info_.proxy_server().is_https() || IsSpdyAlternative();
 }
 
 void HttpStreamFactoryImpl::Job::OnStreamReadyCallback() {
   DCHECK(stream_.get());
-  DCHECK_NE(job_type_, PRECONNECT);
-  DCHECK(!delegate_->for_websockets());
+  DCHECK(!IsPreconnecting());
+  DCHECK(!stream_factory_->for_websockets_);
 
   UMA_HISTOGRAM_TIMES("Net.HttpStreamFactoryJob.StreamReadyCallbackTime",
                       base::TimeTicks::Now() - job_stream_ready_start_time_);
 
   MaybeCopyConnectionAttemptsFromSocketOrHandle();
 
-  delegate_->OnStreamReady(this, server_ssl_config_, proxy_info_);
+  if (IsOrphaned()) {
+    stream_factory_->OnOrphanedJobComplete(this);
+  } else {
+    request_->Complete(was_npn_negotiated(), protocol_negotiated(),
+                       using_spdy());
+    request_->OnStreamReady(this, server_ssl_config_, proxy_info_,
+                            stream_.release());
+  }
   // |this| may be deleted after this call.
 }
 
 void HttpStreamFactoryImpl::Job::OnWebSocketHandshakeStreamReadyCallback() {
   DCHECK(websocket_stream_);
-  DCHECK_NE(job_type_, PRECONNECT);
-  DCHECK(delegate_->for_websockets());
+  DCHECK(!IsPreconnecting());
+  DCHECK(stream_factory_->for_websockets_);
+  // An orphaned WebSocket job will be closed immediately and
+  // never be ready.
+  DCHECK(!IsOrphaned());
 
   MaybeCopyConnectionAttemptsFromSocketOrHandle();
 
-  delegate_->OnWebSocketHandshakeStreamReady(
-      this, server_ssl_config_, proxy_info_, websocket_stream_.release());
+  request_->Complete(was_npn_negotiated(), protocol_negotiated(), using_spdy());
+  request_->OnWebSocketHandshakeStreamReady(this,
+                                            server_ssl_config_,
+                                            proxy_info_,
+                                            websocket_stream_.release());
   // |this| may be deleted after this call.
 }
 
 void HttpStreamFactoryImpl::Job::OnBidirectionalStreamImplReadyCallback() {
   DCHECK(bidirectional_stream_impl_);
 
   MaybeCopyConnectionAttemptsFromSocketOrHandle();
 
-  delegate_->OnBidirectionalStreamImplReady(this, server_ssl_config_,
-                                            proxy_info_);
-  // |this| may be deleted after this call.
+  if (IsOrphaned()) {
+    stream_factory_->OnOrphanedJobComplete(this);
+  } else {
+    request_->Complete(was_npn_negotiated(), protocol_negotiated(),
+                       using_spdy());
+    request_->OnBidirectionalStreamImplReady(
+        this, server_ssl_config_, proxy_info_,
+        bidirectional_stream_impl_.release());
+  }
+// |this| may be deleted after this call.
 }
 
 void HttpStreamFactoryImpl::Job::OnNewSpdySessionReadyCallback() {
   DCHECK(stream_.get() || bidirectional_stream_impl_.get());
-  DCHECK_NE(job_type_, PRECONNECT);
+  DCHECK(!IsPreconnecting());
   DCHECK(using_spdy());
   // Note: an event loop iteration has passed, so |new_spdy_session_| may be
   // NULL at this point if the SpdySession closed immediately after creation.
   base::WeakPtr<SpdySession> spdy_session = new_spdy_session_;
   new_spdy_session_.reset();
 
   MaybeCopyConnectionAttemptsFromSocketOrHandle();
 
-  delegate_->OnNewSpdySessionReady(this, spdy_session, spdy_session_direct_);
-
+  // TODO(jgraettinger): Notify the factory, and let that notify |request_|,
+  // rather than notifying |request_| directly.
+  if (IsOrphaned()) {
+    if (spdy_session) {
+      stream_factory_->OnNewSpdySessionReady(
+          spdy_session, spdy_session_direct_, server_ssl_config_, proxy_info_,
+          was_npn_negotiated(), protocol_negotiated(), using_spdy(), net_log_);
+    }
+    stream_factory_->OnOrphanedJobComplete(this);
+  } else {
+    if (stream_type_ == HttpStreamRequest::BIDIRECTIONAL_STREAM) {
+      DCHECK(bidirectional_stream_impl_);
+      request_->OnNewSpdySessionReady(this, /*spdy_http_stream=*/nullptr,
+                                      std::move(bidirectional_stream_impl_),
+                                      spdy_session, spdy_session_direct_);
+    } else {
+      DCHECK(stream_);
+      request_->OnNewSpdySessionReady(this, std::move(stream_),
+                                      /** bidirectional_stream_impl=*/nullptr,
+                                      spdy_session, spdy_session_direct_);
+    }
+  }
   // |this| may be deleted after this call.
 }
 
 void HttpStreamFactoryImpl::Job::OnStreamFailedCallback(int result) {
-  DCHECK_NE(job_type_, PRECONNECT);
+  DCHECK(!IsPreconnecting());
 
   MaybeCopyConnectionAttemptsFromSocketOrHandle();
 
-  SSLFailureState ssl_failure_state =
-      connection_ ? connection_->ssl_failure_state() : SSL_FAILURE_NONE;
-
-  delegate_->OnStreamFailed(this, result, server_ssl_config_,
-                            ssl_failure_state);
+  if (IsOrphaned()) {
+    stream_factory_->OnOrphanedJobComplete(this);
+  } else {
+    SSLFailureState ssl_failure_state =
+        connection_ ? connection_->ssl_failure_state() : SSL_FAILURE_NONE;
+    request_->OnStreamFailed(this, result, server_ssl_config_,
+                             ssl_failure_state);
+  }
   // |this| may be deleted after this call.
 }
 
 void HttpStreamFactoryImpl::Job::OnCertificateErrorCallback(
     int result, const SSLInfo& ssl_info) {
-  DCHECK_NE(job_type_, PRECONNECT);
+  DCHECK(!IsPreconnecting());
 
   MaybeCopyConnectionAttemptsFromSocketOrHandle();
 
-  delegate_->OnCertificateError(this, result, server_ssl_config_, ssl_info);
+  if (IsOrphaned())
+    stream_factory_->OnOrphanedJobComplete(this);
+  else
+    request_->OnCertificateError(this, result, server_ssl_config_, ssl_info);
   // |this| may be deleted after this call.
 }
 
 void HttpStreamFactoryImpl::Job::OnNeedsProxyAuthCallback(
     const HttpResponseInfo& response,
     HttpAuthController* auth_controller) {
-  DCHECK_NE(job_type_, PRECONNECT);
-
-  delegate_->OnNeedsProxyAuth(this, response, server_ssl_config_, proxy_info_,
-                              auth_controller);
+  DCHECK(!IsPreconnecting());
+  if (IsOrphaned())
+    stream_factory_->OnOrphanedJobComplete(this);
+  else
+    request_->OnNeedsProxyAuth(
+        this, response, server_ssl_config_, proxy_info_, auth_controller);
   // |this| may be deleted after this call.
 }
 
 void HttpStreamFactoryImpl::Job::OnNeedsClientAuthCallback(
     SSLCertRequestInfo* cert_info) {
-  DCHECK_NE(job_type_, PRECONNECT);
-
-  delegate_->OnNeedsClientAuth(this, server_ssl_config_, cert_info);
+  DCHECK(!IsPreconnecting());
+  if (IsOrphaned())
+    stream_factory_->OnOrphanedJobComplete(this);
+  else
+    request_->OnNeedsClientAuth(this, server_ssl_config_, cert_info);
   // |this| may be deleted after this call.
 }
 
 void HttpStreamFactoryImpl::Job::OnHttpsProxyTunnelResponseCallback(
     const HttpResponseInfo& response_info,
     HttpStream* stream) {
-  DCHECK_NE(job_type_, PRECONNECT);
-
-  delegate_->OnHttpsProxyTunnelResponse(this, response_info, server_ssl_config_,
-                                        proxy_info_, stream);
+  DCHECK(!IsPreconnecting());
+  if (IsOrphaned())
+    stream_factory_->OnOrphanedJobComplete(this);
+  else
+    request_->OnHttpsProxyTunnelResponse(
+        this, response_info, server_ssl_config_, proxy_info_, stream);
   // |this| may be deleted after this call.
 }
 
 void HttpStreamFactoryImpl::Job::OnPreconnectsComplete() {
+  DCHECK(!request_);
   if (new_spdy_session_.get()) {
-    delegate_->OnNewSpdySessionReady(this, new_spdy_session_,
-                                     spdy_session_direct_);
+    stream_factory_->OnNewSpdySessionReady(new_spdy_session_,
+                                           spdy_session_direct_,
+                                           server_ssl_config_,
+                                           proxy_info_,
+                                           was_npn_negotiated(),
+                                           protocol_negotiated(),
+                                           using_spdy(),
+                                           net_log_);
   }
-  delegate_->OnPreconnectsComplete(this);
+  stream_factory_->OnPreconnectsComplete(this);
   // |this| may be deleted after this call.
 }
 
 // static
 int HttpStreamFactoryImpl::Job::OnHostResolution(
     SpdySessionPool* spdy_session_pool,
     const SpdySessionKey& spdy_session_key,
     const GURL& origin_url,
     const AddressList& addresses,
     const BoundNetLog& net_log) {
@@ skipping 17 matching lines @@
                "HttpStreamFactoryImpl::Job::RunLoop");
   result = DoLoop(result);
 
   if (result == ERR_IO_PENDING)
     return result;
 
   // If there was an error, we should have already resumed the |waiting_job_|,
   // if there was one.
   DCHECK(result == OK || waiting_job_ == NULL);
 
-  if (job_type_ == PRECONNECT) {
+  if (IsPreconnecting()) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(&HttpStreamFactoryImpl::Job::OnPreconnectsComplete,
                    ptr_factory_.GetWeakPtr()));
     return ERR_IO_PENDING;
   }
 
   if (IsCertificateError(result)) {
     // Retrieve SSL information from the socket.
     GetSSLInfo();
@@ skipping 51 matching lines @@
     }
 
     case OK:
       job_status_ = STATUS_SUCCEEDED;
       MaybeMarkAlternativeServiceBroken();
       next_state_ = STATE_DONE;
       if (new_spdy_session_.get()) {
         base::ThreadTaskRunnerHandle::Get()->PostTask(
             FROM_HERE, base::Bind(&Job::OnNewSpdySessionReadyCallback,
                                   ptr_factory_.GetWeakPtr()));
-      } else if (delegate_->for_websockets()) {
+      } else if (stream_factory_->for_websockets_) {
         DCHECK(websocket_stream_);
         base::ThreadTaskRunnerHandle::Get()->PostTask(
             FROM_HERE, base::Bind(&Job::OnWebSocketHandshakeStreamReadyCallback,
                                   ptr_factory_.GetWeakPtr()));
       } else if (stream_type_ == HttpStreamRequest::BIDIRECTIONAL_STREAM) {
         if (!bidirectional_stream_impl_) {
           base::ThreadTaskRunnerHandle::Get()->PostTask(
               FROM_HERE, base::Bind(&Job::OnStreamFailedCallback,
                                     ptr_factory_.GetWeakPtr(), ERR_FAILED));
         } else {
@@ skipping 91 matching lines @@
   CHECK_EQ(STATE_NONE, next_state_);
   next_state_ = STATE_START;
   int rv = RunLoop(OK);
   DCHECK_EQ(ERR_IO_PENDING, rv);
   return rv;
 }
 
 int HttpStreamFactoryImpl::Job::DoStart() {
   valid_spdy_session_pool_.reset(new ValidSpdySessionPool(
       session_->spdy_session_pool(), origin_url_, IsSpdyAlternative()));
-  const BoundNetLog* net_log = delegate_->GetNetLog(this);
 
-  if (net_log) {
-    net_log_.BeginEvent(
-        NetLog::TYPE_HTTP_STREAM_JOB,
-        base::Bind(&NetLogHttpStreamJobCallback, net_log->source(),
-                   &request_info_.url, &origin_url_, &alternative_service_,
-                   priority_));
-    net_log->AddEvent(NetLog::TYPE_HTTP_STREAM_REQUEST_STARTED_JOB,
-                      net_log_.source().ToEventParametersCallback());
+  net_log_.BeginEvent(
+      NetLog::TYPE_HTTP_STREAM_JOB,
+      base::Bind(&NetLogHttpStreamJobCallback,
+                 request_ ? request_->net_log().source() : NetLog::Source(),
+                 &request_info_.url, &origin_url_, &alternative_service_,
+                 priority_));
+  if (request_) {
+    request_->net_log().AddEvent(NetLog::TYPE_HTTP_STREAM_REQUEST_STARTED_JOB,
+                                 net_log_.source().ToEventParametersCallback());
   }
 
   // Don't connect to restricted ports.
   if (!IsPortAllowedForScheme(destination_.port(),
                               request_info_.url.scheme())) {
     if (waiting_job_) {
       waiting_job_->Resume(this, base::TimeDelta());
       waiting_job_ = NULL;
     }
     return ERR_UNSAFE_PORT;
@@ skipping 214 matching lines @@
   // straight to using that.
   if (CanUseExistingSpdySession()) {
     base::WeakPtr<SpdySession> spdy_session;
     int result = valid_spdy_session_pool_->FindAvailableSession(
         spdy_session_key, net_log_, &spdy_session);
     if (result != OK)
       return result;
     if (spdy_session) {
       // If we're preconnecting, but we already have a SpdySession, we don't
       // actually need to preconnect any sockets, so we're done.
-      if (job_type_ == PRECONNECT)
+      if (IsPreconnecting())
         return OK;
       using_spdy_ = true;
       next_state_ = STATE_CREATE_STREAM;
       existing_spdy_session_ = spdy_session;
       return OK;
     }
   }
-  if (using_ssl_) {
-    // Ask |delegate_delegate_| to update the spdy session key for the request
-    // that launched this job.
-    delegate_->SetSpdySessionKey(this, spdy_session_key);
+  if (request_ && !request_->HasSpdySessionKey() && using_ssl_) {
+    // Update the spdy session key for the request that launched this job.
+    request_->SetSpdySessionKey(spdy_session_key);
   }
 
   // OK, there's no available SPDY session. Let |waiting_job_| resume if it's
   // paused.
   if (waiting_job_) {
     waiting_job_->Resume(this, base::TimeDelta());
     waiting_job_ = NULL;
   }
 
   if (proxy_info_.is_http() || proxy_info_.is_https())
     establishing_tunnel_ = using_ssl_;
 
   const bool expect_spdy = IsSpdyAlternative();
 
   base::WeakPtr<HttpServerProperties> http_server_properties =
       session_->http_server_properties();
   if (http_server_properties) {
     http_server_properties->MaybeForceHTTP11(destination_, &server_ssl_config_);
     if (proxy_info_.is_http() || proxy_info_.is_https()) {
       http_server_properties->MaybeForceHTTP11(
           proxy_info_.proxy_server().host_port_pair(), &proxy_ssl_config_);
     }
   }
 
-  if (job_type_ == PRECONNECT) {
-    DCHECK(!delegate_->for_websockets());
+  if (IsPreconnecting()) {
+    DCHECK(!stream_factory_->for_websockets_);
     return PreconnectSocketsForHttpRequest(
         GetSocketGroup(), destination_, request_info_.extra_headers,
         request_info_.load_flags, priority_, session_, proxy_info_, expect_spdy,
         server_ssl_config_, proxy_ssl_config_, request_info_.privacy_mode,
         net_log_, num_streams_);
   }
 
   // If we can't use a SPDY session, don't bother checking for one after
   // the hostname is resolved.
   OnHostResolutionCallback resolution_callback =
       CanUseExistingSpdySession()
           ? base::Bind(&Job::OnHostResolution, session_->spdy_session_pool(),
                        spdy_session_key, origin_url_)
           : OnHostResolutionCallback();
-  if (delegate_->for_websockets()) {
+  if (stream_factory_->for_websockets_) {
     // TODO(ricea): Re-enable NPN when WebSockets over SPDY is supported.
     SSLConfig websocket_server_ssl_config = server_ssl_config_;
     websocket_server_ssl_config.alpn_protos.clear();
     websocket_server_ssl_config.npn_protos.clear();
     return InitSocketHandleForWebSocketRequest(
         GetSocketGroup(), destination_, request_info_.extra_headers,
         request_info_.load_flags, priority_, session_, proxy_info_, expect_spdy,
         websocket_server_ssl_config, proxy_ssl_config_,
         request_info_.privacy_mode, net_log_, connection_.get(),
         resolution_callback, io_callback_);
   }
 
   return InitSocketHandleForHttpRequest(
       GetSocketGroup(), destination_, request_info_.extra_headers,
       request_info_.load_flags, priority_, session_, proxy_info_, expect_spdy,
       server_ssl_config_, proxy_ssl_config_, request_info_.privacy_mode,
       net_log_, connection_.get(), resolution_callback, io_callback_);
 }
 
 int HttpStreamFactoryImpl::Job::DoInitConnectionComplete(int result) {
   if (using_quic_ && result < 0 && waiting_job_) {
     waiting_job_->Resume(this, base::TimeDelta());
     waiting_job_ = NULL;
   }
-  if (job_type_ == PRECONNECT) {
+  if (IsPreconnecting()) {
     if (using_quic_)
       return result;
     DCHECK_EQ(OK, result);
     return OK;
   }
 
   if (result == ERR_SPDY_SESSION_ALREADY_EXISTS) {
     // We found a SPDY connection after resolving the host.  This is
     // probably an IP pooled connection.
     SpdySessionKey spdy_session_key = GetSpdySessionKey();
@@ skipping 164 matching lines @@
 
   // We're always waiting here for the delegate to call us back.
   return ERR_IO_PENDING;
 }
 
 int HttpStreamFactoryImpl::Job::SetSpdyHttpStreamOrBidirectionalStreamImpl(
     base::WeakPtr<SpdySession> session,
     bool direct) {
   // TODO(ricea): Restore the code for WebSockets over SPDY once it's
   // implemented.
-  if (delegate_->for_websockets())
+  if (stream_factory_->for_websockets_)
     return ERR_NOT_IMPLEMENTED;
   if (stream_type_ == HttpStreamRequest::BIDIRECTIONAL_STREAM) {
     bidirectional_stream_impl_.reset(new BidirectionalStreamSpdyImpl(session));
     return OK;
   }
 
   // TODO(willchan): Delete this code, because eventually, the
   // HttpStreamFactoryImpl will be creating all the SpdyHttpStreams, since it
   // will know when SpdySessions become available.
 
@@ skipping 24 matching lines @@
   // need to plumb this through to the connect level.
   if (connection_->socket() && !connection_->is_reused())
     SetSocketMotivation();
 
   if (!using_spdy_) {
     DCHECK(!IsSpdyAlternative());
     // We may get ftp scheme when fetching ftp resources through proxy.
     bool using_proxy = (proxy_info_.is_http() || proxy_info_.is_https()) &&
                        (request_info_.url.SchemeIs("http") ||
                         request_info_.url.SchemeIs("ftp"));
-    if (delegate_->for_websockets()) {
-      DCHECK_NE(job_type_, PRECONNECT);
-      DCHECK(delegate_->websocket_handshake_stream_create_helper());
+    if (stream_factory_->for_websockets_) {
+      DCHECK(request_);
+      DCHECK(request_->websocket_handshake_stream_create_helper());
       websocket_stream_.reset(
-          delegate_->websocket_handshake_stream_create_helper()
+          request_->websocket_handshake_stream_create_helper()
               ->CreateBasicStream(std::move(connection_), using_proxy));
     } else {
       stream_.reset(new HttpBasicStream(connection_.release(), using_proxy));
     }
     return OK;
   }
 
   CHECK(!stream_.get());
 
   bool direct = !IsHttpsProxyAndHttpUrl();
@@ skipping 101 matching lines @@
 
   return ReconsiderProxyAfterError(result);
 }
 
 void HttpStreamFactoryImpl::Job::ReturnToStateInitConnection(
     bool close_connection) {
   if (close_connection && connection_->socket())
     connection_->socket()->Disconnect();
   connection_->Reset();
 
-  delegate_->RemoveRequestFromSpdySessionRequestMapForJob(this);
+  if (request_)
+    request_->RemoveRequestFromSpdySessionRequestMap();
 
   next_state_ = STATE_INIT_CONNECTION;
 }
 
 void HttpStreamFactoryImpl::Job::SetSocketMotivation() {
   if (request_info_.motivation == HttpRequestInfo::PRECONNECT_MOTIVATED)
     connection_->socket()->SetSubresourceSpeculation();
   else if (request_info_.motivation == HttpRequestInfo::OMNIBOX_MOTIVATED)
     connection_->socket()->SetOmniboxSpeculation();
   // TODO(mbelshe): Add other motivations (like EARLY_LOAD_MOTIVATED).
@@ skipping 121 matching lines @@
   int rv = session_->proxy_service()->ReconsiderProxyAfterError(
       request_info_.url, request_info_.method, request_info_.load_flags, error,
       &proxy_info_, io_callback_, &pac_request_,
       session_->params().proxy_delegate, net_log_);
   if (rv == OK || rv == ERR_IO_PENDING) {
     // If the error was during connection setup, there is no socket to
     // disconnect.
     if (connection_->socket())
       connection_->socket()->Disconnect();
     connection_->Reset();
-    delegate_->RemoveRequestFromSpdySessionRequestMapForJob(this);
+    if (request_)
+      request_->RemoveRequestFromSpdySessionRequestMap();
     next_state_ = STATE_RESOLVE_PROXY_COMPLETE;
   } else {
     // If ReconsiderProxyAfterError() failed synchronously, it means
     // there was nothing left to fall-back to, so fail the transaction
     // with the last connection error we got.
     // TODO(eroman): This is a confusing contract, make it more obvious.
     rv = error;
   }
 
   return rv;
@@ skipping 30 matching lines @@
   if (ssl_socket->IgnoreCertError(error, load_flags))
     return OK;
   return error;
 }
 
 void HttpStreamFactoryImpl::Job::SwitchToSpdyMode() {
   if (HttpStreamFactory::spdy_enabled())
     using_spdy_ = true;
 }
 
+bool HttpStreamFactoryImpl::Job::IsPreconnecting() const {
+  DCHECK_GE(num_streams_, 0);
+  return num_streams_ > 0;
+}
+
+bool HttpStreamFactoryImpl::Job::IsOrphaned() const {
+  return !IsPreconnecting() && !request_;
+}
+
 void HttpStreamFactoryImpl::Job::ReportJobSucceededForRequest() {
   if (using_existing_quic_session_) {
     // If an existing session was used, then no TCP connection was
     // started.
     HistogramAlternateProtocolUsage(ALTERNATE_PROTOCOL_USAGE_NO_RACE);
   } else if (IsSpdyAlternative() || IsQuicAlternative()) {
     // This Job was the alternative Job, and hence won the race.
     HistogramAlternateProtocolUsage(ALTERNATE_PROTOCOL_USAGE_WON_RACE);
   } else {
     // This Job was the normal Job, and hence the alternative Job lost the race.
@@ skipping 90 matching lines @@
   return ClientSocketPoolManager::NORMAL_GROUP;
 }
 
 // If the connection succeeds, failed connection attempts leading up to the
 // success will be returned via the successfully connected socket. If the
 // connection fails, failed connection attempts will be returned via the
 // ClientSocketHandle. Check whether a socket was returned and copy the
 // connection attempts from the proper place.
 void HttpStreamFactoryImpl::Job::
     MaybeCopyConnectionAttemptsFromSocketOrHandle() {
-  if (!connection_)
+  if (IsOrphaned() || !connection_)
     return;
 
-  ConnectionAttempts socket_attempts = connection_->connection_attempts();
   if (connection_->socket()) {
+    ConnectionAttempts socket_attempts;
     connection_->socket()->GetConnectionAttempts(&socket_attempts);
+    request_->AddConnectionAttempts(socket_attempts);
+  } else {
+    request_->AddConnectionAttempts(connection_->connection_attempts());
   }
-
-  delegate_->AddConnectionAttemptsToRequest(this, socket_attempts);
 }
 
 }  // namespace net