Add HttpStreamFactory Job orphaning semantics.

net/http/http_stream_factory_impl_job.cc

 // Copyright (c) 2011 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 "base/logging.h"
 #include "base/stl_util-inl.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
@@ skipping 27 matching lines @@
   GURL::Replacements replacements;
   // new_sheme and new_port need to be in scope here because GURL::Replacements
   // references the memory contained by them directly.
   const std::string new_scheme = "https";
   const std::string new_port = base::IntToString(443);
   replacements.SetSchemeStr(new_scheme);
   replacements.SetPortStr(new_port);
   return original_url.ReplaceComponents(replacements);
 }
 
+// Parameters associated with the creation of a Job.
+class JobCreationParameters : public NetLog::EventParameters {
+ public:
+  JobCreationParameters(const std::string& url) : url_(url) {}
+
+  virtual Value* ToValue() const {
+    DictionaryValue* dict = new DictionaryValue();
+    dict->SetString("url", url_);
+    return dict;
+  }
+
+ private:
+  const std::string url_;
+};
+
 }  // namespace
 
 HttpStreamFactoryImpl::Job::Job(HttpStreamFactoryImpl* stream_factory,
                                 HttpNetworkSession* session)
     : request_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(io_callback_(this, &Job::OnIOComplete)),
       connection_(new ClientSocketHandle),
       session_(session),
       stream_factory_(stream_factory),
       next_state_(STATE_NONE),
@@ skipping 69 matching lines @@
       return LOAD_STATE_RESOLVING_PROXY_FOR_URL;
     case STATE_CREATE_STREAM_COMPLETE:
       return connection_->GetLoadState();
     case STATE_INIT_CONNECTION_COMPLETE:
       return LOAD_STATE_SENDING_REQUEST;
     default:
       return LOAD_STATE_IDLE;
   }
 }
 
+void HttpStreamFactoryImpl::Job::Orphan(const Request* request) {
+  DCHECK_EQ(request_, request);
+  request_ = NULL;
+}
+
 bool HttpStreamFactoryImpl::Job::was_alternate_protocol_available() const {
   return was_alternate_protocol_available_;
 }
 
 bool HttpStreamFactoryImpl::Job::was_npn_negotiated() const {
   return was_npn_negotiated_;
 }
 
 bool HttpStreamFactoryImpl::Job::using_spdy() const {
   return using_spdy_;
@@ skipping 11 matching lines @@
   DCHECK(using_ssl_);
   DCHECK(!establishing_tunnel_);
   DCHECK(connection_.get() && connection_->socket());
   SSLClientSocket* ssl_socket =
       static_cast<SSLClientSocket*>(connection_->socket());
   ssl_socket->GetSSLInfo(&ssl_info_);
 }
 
 void HttpStreamFactoryImpl::Job::OnStreamReadyCallback() {
   DCHECK(stream_.get());
-  request_->Complete(was_alternate_protocol_available(),
-                    was_npn_negotiated(),
-                    using_spdy(),
-                    net_log_.source());
-  request_->OnStreamReady(ssl_config_, proxy_info_, stream_.release());
+  DCHECK(!IsPreconnecting());
+  if (IsOrphaned()) {
+    stream_factory_->OnOrphanedJobComplete(this);
+  } else {
+    request_->Complete(was_alternate_protocol_available(),
+                       was_npn_negotiated(),
+                       using_spdy(),
+                       net_log_.source());
+    request_->OnStreamReady(this, ssl_config_, proxy_info_, stream_.release());
+  }
   // |this| may be deleted after this call.
 }
 
 void HttpStreamFactoryImpl::Job::OnSpdySessionReadyCallback() {
   DCHECK(!stream_.get());
+  DCHECK(!IsPreconnecting());
   DCHECK(using_spdy());
   DCHECK(new_spdy_session_);
   scoped_refptr<SpdySession> spdy_session = new_spdy_session_;
   new_spdy_session_ = NULL;
-  stream_factory_->OnSpdySessionReady(this, spdy_session, spdy_session_direct_);
+  if (IsOrphaned()) {
+    // TODO(willchan): This is actually probably yet another opportunity for
+    // improving SPDY late binding. Investigate getting this to work. It'll
+    // probably make a bigger difference when we have ip connection pooling.
+    stream_factory_->OnOrphanedJobComplete(this);
+  } else {
+    request_->OnSpdySessionReady(this, spdy_session, spdy_session_direct_);
+  }
   // |this| may be deleted after this call.
 }
 
 void HttpStreamFactoryImpl::Job::OnStreamFailedCallback(int result) {
-  request_->OnStreamFailed(result, ssl_config_);
+  DCHECK(!IsPreconnecting());
+  if (IsOrphaned())
+    stream_factory_->OnOrphanedJobComplete(this);
+  else
+    request_->OnStreamFailed(this, result, ssl_config_);
   // |this| may be deleted after this call.
 }
 
 void HttpStreamFactoryImpl::Job::OnCertificateErrorCallback(
     int result, const SSLInfo& ssl_info) {
-  request_->OnCertificateError(result, ssl_config_, ssl_info);
+  DCHECK(!IsPreconnecting());
+  if (IsOrphaned())
+    stream_factory_->OnOrphanedJobComplete(this);
+  else
+    request_->OnCertificateError(this, result, ssl_config_, ssl_info);
   // |this| may be deleted after this call.
 }
 
 void HttpStreamFactoryImpl::Job::OnNeedsProxyAuthCallback(
     const HttpResponseInfo& response,
     HttpAuthController* auth_controller) {
-  request_->OnNeedsProxyAuth(
-      response, ssl_config_, proxy_info_, auth_controller);
+  DCHECK(!IsPreconnecting());
+  if (IsOrphaned())
+    stream_factory_->OnOrphanedJobComplete(this);
+  else
+    request_->OnNeedsProxyAuth(
+        this, response, ssl_config_, proxy_info_, auth_controller);
   // |this| may be deleted after this call.
 }
 
 void HttpStreamFactoryImpl::Job::OnNeedsClientAuthCallback(
     SSLCertRequestInfo* cert_info) {
-  request_->OnNeedsClientAuth(ssl_config_, cert_info);
+  DCHECK(!IsPreconnecting());
+  if (IsOrphaned())
+    stream_factory_->OnOrphanedJobComplete(this);
+  else
+    request_->OnNeedsClientAuth(this, ssl_config_, cert_info);
   // |this| may be deleted after this call.
 }
 
 void HttpStreamFactoryImpl::Job::OnHttpsProxyTunnelResponseCallback(
     const HttpResponseInfo& response_info,
     HttpStream* stream) {
-  request_->OnHttpsProxyTunnelResponse(
-      response_info, ssl_config_, proxy_info_, stream);
+  DCHECK(!IsPreconnecting());
+  if (IsOrphaned())
+    stream_factory_->OnOrphanedJobComplete(this);
+  else
+    request_->OnHttpsProxyTunnelResponse(
+        this, response_info, ssl_config_, proxy_info_, stream);
   // |this| may be deleted after this call.
 }
 
 void HttpStreamFactoryImpl::Job::OnPreconnectsComplete() {
-  stream_factory_->OnPreconnectsComplete(this);
+  DCHECK(!request_);
+  if (IsOrphaned())
+    stream_factory_->OnOrphanedJobComplete(this);
+  else
+    stream_factory_->OnPreconnectsComplete(this);
   // |this| may be deleted after this call.
 }
 
 void HttpStreamFactoryImpl::Job::OnIOComplete(int result) {
   RunLoop(result);
 }
 
 int HttpStreamFactoryImpl::Job::RunLoop(int result) {
   result = DoLoop(result);
 
@@ skipping 284 matching lines @@
           HostPortProxyPair(endpoint_, proxy_info_.proxy_server());
     }
     if (session_->spdy_session_pool()->HasSession(spdy_session_key)) {
       // If we're preconnecting, but we already have a SpdySession, we don't
       // actually need to preconnect any sockets, so we're done.
       if (IsPreconnecting())
         return OK;
       using_spdy_ = true;
       next_state_ = STATE_CREATE_STREAM;
       return OK;
-    } else if (!IsPreconnecting()) {
+    } else if (request_) {
       // Update the spdy session key for the request that launched this job.
       request_->SetSpdySessionKey(spdy_session_key);
     }
   }
 
   // Build the string used to uniquely identify connections of this type.
   // Determine the host and port to connect to.
   std::string connection_group = endpoint_.ToString();
   DCHECK(!connection_group.empty());
 
@@ skipping 591 matching lines @@
       NOTREACHED();
       break;
   }
 }
 
 bool HttpStreamFactoryImpl::Job::IsPreconnecting() const {
   DCHECK_GE(num_streams_, 0);
   return num_streams_ > 0;
 }
 
+bool HttpStreamFactoryImpl::Job::IsOrphaned() const {
+  return !IsPreconnecting() && !request_;
+}
+
 }  // namespace net