Add a force pipelining option to load flags.

net/http/http_stream_factory_impl_request.cc

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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_request.h"
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "net/http/http_stream_factory_impl_job.h"
 #include "net/spdy/spdy_http_stream.h"
 #include "net/spdy/spdy_session.h"
@@ skipping 38 matching lines @@
 void HttpStreamFactoryImpl::Request::SetSpdySessionKey(
     const HostPortProxyPair& spdy_session_key) {
   DCHECK(!spdy_session_key_.get());
   spdy_session_key_.reset(new HostPortProxyPair(spdy_session_key));
   RequestSet& request_set =
       factory_->spdy_session_request_map_[spdy_session_key];
   DCHECK(!ContainsKey(request_set, this));
   request_set.insert(this);
 }
 
-void HttpStreamFactoryImpl::Request::SetHttpPipeliningKey(
-    const HostPortPair& http_pipelining_key) {
+bool HttpStreamFactoryImpl::Request::SetHttpPipeliningKey(
+    const HttpPipelinedHost::Key& http_pipelining_key) {
   DCHECK(!http_pipelining_key_.get());
-  http_pipelining_key_.reset(new HostPortPair(http_pipelining_key));
+  http_pipelining_key_.reset(new HttpPipelinedHost::Key(http_pipelining_key));
+  bool was_new_key = !ContainsKey(factory_->http_pipelining_request_map_,
+                                  http_pipelining_key);
   RequestSet& request_set =
       factory_->http_pipelining_request_map_[http_pipelining_key];
   DCHECK(!ContainsKey(request_set, this));
   request_set.insert(this);
+  return was_new_key;
 }
 
 void HttpStreamFactoryImpl::Request::AttachJob(Job* job) {
   DCHECK(job);
   jobs_.insert(job);
   factory_->request_map_[job] = this;
 }
 
 void HttpStreamFactoryImpl::Request::Complete(
     bool was_npn_negotiated,
@@ skipping 45 matching lines @@
     DCHECK(jobs_.empty());
   }
   delegate_->OnStreamReady(used_ssl_config, used_proxy_info, stream);
 }
 
 void HttpStreamFactoryImpl::Request::OnStreamFailed(
     Job* job,
     int status,
     const SSLConfig& used_ssl_config) {
   DCHECK_NE(OK, status);
-  if (!bound_job_.get()) {
+  // |job| should only be NULL if we're being canceled by a late bound
+  // HttpPipelinedConnection (one that was not created by a job in our |jobs_|
+  // set).
+  if (!job) {
+    DCHECK(!bound_job_.get());
+    DCHECK(!jobs_.empty());
+    // NOTE(willchan): We do *NOT* call OrphanJobs() here. The reason is because
+    // we *WANT* to cancel the unnecessary Jobs from other requests if another
+    // Job completes first.
+  } else if (!bound_job_.get()) {
     // Hey, we've got other jobs! Maybe one of them will succeed, let's just
     // ignore this failure.
     if (jobs_.size() > 1) {
       jobs_.erase(job);
       factory_->request_map_.erase(job);
       delete job;
       return;
     } else {
       bound_job_.reset(job);
       jobs_.erase(job);
@@ skipping 177 matching lines @@
   RemoveRequestFromHttpPipeliningRequestMap();
 
   std::set<Job*> tmp;
   tmp.swap(jobs_);
 
   for (std::set<Job*>::iterator it = tmp.begin(); it != tmp.end(); ++it)
     factory_->OrphanJob(*it, this);
 }
 
 }  // namespace net