Add HttpStreamFactory Job orphaning semantics.

net/http/http_stream_factory_impl.h

 // 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.
 
 #ifndef NET_HTTP_HTTP_STREAM_FACTORY_IMPL_H_
 #define NET_HTTP_HTTP_STREAM_FACTORY_IMPL_H_
 
 #include <map>
 #include <set>
 #include <string>
 
 #include "base/ref_counted.h"
 #include "net/http/http_stream_factory.h"
+#include "net/base/net_log.h"
 #include "net/proxy/proxy_server.h"
 
 namespace net {
 
 class HttpNetworkSession;
 class SpdySession;
 
 class HttpStreamFactoryImpl : public HttpStreamFactory {
  public:
   explicit HttpStreamFactoryImpl(HttpNetworkSession* session);
@@ skipping 13 matching lines @@
   virtual void AddTLSIntolerantServer(const GURL& url);
   virtual bool IsTLSIntolerantServer(const GURL& url) const;
 
  private:
   class Request;
   class Job;
 
   typedef std::set<Request*> RequestSet;
   typedef std::map<HostPortProxyPair, RequestSet> SpdySessionRequestMap;
 
-  LoadState GetLoadState(const Request& request) const;
+  // Detaches |job| from |request|.
+  void OrphanJob(Job* job, const Request* request);
 
   // Called when a SpdySession is ready. It will find appropriate Requests and
   // fulfill them. |direct| indicates whether or not |spdy_session| uses a
   // proxy.
-  void OnSpdySessionReady(const Job* job,
-                          scoped_refptr<SpdySession> spdy_session,
-                          bool direct);
+  void OnSpdySessionReady(scoped_refptr<SpdySession> spdy_session,
+                          bool direct,
+                          const SSLConfig& used_ssl_config,
+                          const ProxyInfo& used_proxy_info,
+                          bool was_alternate_protocol_available,
+                          bool was_npn_negotiated,
+                          bool using_spdy,
+                          const NetLog::Source& source);
 
   // Called when the Job detects that the endpoint indicated by the
   // Alternate-Protocol does not work. Lets the factory update
   // HttpAlternateProtocols with the failure and resets the SPDY session key.
   void OnBrokenAlternateProtocol(const Job*, const HostPortPair& origin);
 
+  // Invoked when an orphaned Job finishes.
+  void OnOrphanedJobComplete(const Job* job);
+
   // Invoked when the Job finishes preconnecting sockets.
   void OnPreconnectsComplete(const Job* job);
 
   // Called when the Preconnect completes. Used for testing.
   virtual void OnPreconnectsCompleteInternal() {}
 
   HttpNetworkSession* const session_;
 
   std::set<std::string> tls_intolerant_servers_;
 
   // All Requests are handed out to clients. By the time HttpStreamFactoryImpl
   // is destroyed, all Requests should be deleted (which should remove them from
   // |request_map_|. The Requests will delete the corresponding job.
   std::map<const Job*, Request*> request_map_;
 
   SpdySessionRequestMap spdy_session_request_map_;
 
+  // These jobs correspond to jobs orphaned by requests and now owned by
+  // HttpStreamFactoryImpl.  Leftover jobs will be deleted when the factory is
+  // destroyed.

[Mike Belshe, 2011/03/01 17:09:19]

"...deleted when the factory is destroyed." sounds like when the browser dies?

From looking at the code, its not nearly that bad.  The orphaned jobs simply
park here until the IO completes, at which point we clean them up and remove
them from this set?

[willchan no longer on Chromium, 2011/03/01 17:48:27]

Oh, I'll clarify this comment. What I mean is that for |request_map_|, we're
guaranteed that it's empty when we hit ~HttpStreamFactoryImpl, because all
URLRequests must be canceled by then. Orphaned jobs aren't tied to a Request, so
they won't be canceled when the URLRequest (and its corresponding Request) are
canceled, so there may be some leftover in this set when the destructor runs. We
delete all the leftovers.

+  std::set<const Job*> orphaned_job_set_;
+
   // These jobs correspond to preconnect requests and have no associated Request
   // object. They're owned by HttpStreamFactoryImpl. Leftover jobs will be
   // deleted when the factory is destroyed.
   std::set<const Job*> preconnect_job_set_;
 
   DISALLOW_COPY_AND_ASSIGN(HttpStreamFactoryImpl);
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_HTTP_STREAM_FACTORY_IMPL_H_