Add a force pipelining option to load flags.

chrome/browser/net/http_pipelining_compatibility_client.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 "chrome/browser/net/http_pipelining_compatibility_client.h"
 
 #include "base/metrics/histogram.h"
 #include "base/stringprintf.h"
 #include "net/base/load_flags.h"
 #include "net/disk_cache/histogram_macros.h"
+#include "net/http/http_network_layer.h"
+#include "net/http/http_network_session.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_version.h"
 
 namespace chrome_browser_net {
 
 HttpPipeliningCompatibilityClient::HttpPipeliningCompatibilityClient()
     : num_finished_(0) {
 }
 
 HttpPipeliningCompatibilityClient::~HttpPipeliningCompatibilityClient() {
 }
 
 void HttpPipeliningCompatibilityClient::Start(
     const std::string& base_url,
     std::vector<RequestInfo>& requests,
     const net::CompletionCallback& callback,
     net::URLRequestContext* url_request_context) {
+  net::HttpNetworkSession* old_session =
+      url_request_context->http_transaction_factory()->GetSession();
+  net::HttpNetworkSession::Params params = old_session->params();
+  params.force_http_pipelining = true;
+  scoped_refptr<net::HttpNetworkSession> session =
+      new net::HttpNetworkSession(params);
+  http_transaction_factory_.reset(
+      net::HttpNetworkLayer::CreateFactory(session.get()));
+
+  url_request_context_ = new net::URLRequestContext;
+  url_request_context_->CopyFrom(url_request_context);
+  url_request_context_->set_http_transaction_factory(
+      http_transaction_factory_.get());
+
   finished_callback_ = callback;
   for (size_t i = 0; i < requests.size(); ++i) {
     requests_.push_back(new Request(i, base_url, requests[i], this,
-                                    url_request_context));
+                                    url_request_context_.get()));
   }
 }
 
 void HttpPipeliningCompatibilityClient::OnRequestFinished(int request_id,
                                                           Status status) {
   // The CACHE_HISTOGRAM_* macros are used, because they allow dynamic metric
   // names.
   CACHE_HISTOGRAM_ENUMERATION(GetMetricName(request_id, "Status"),
                               status, STATUS_MAX);
   ++num_finished_;
@@ skipping 25 matching lines @@
     const std::string& base_url,
     const RequestInfo& info,
     HttpPipeliningCompatibilityClient* client,
     net::URLRequestContext* url_request_context)
     : request_id_(request_id),
       request_(GURL(base_url + info.filename), this),
       info_(info),
       client_(client),
       finished_(false) {
   request_.set_context(url_request_context);
-  // TODO(simonjam): Force pipelining.
   request_.set_load_flags(net::LOAD_BYPASS_CACHE |
                           net::LOAD_DISABLE_CACHE |
                           net::LOAD_DO_NOT_SAVE_COOKIES |
                           net::LOAD_DO_NOT_SEND_COOKIES |
                           net::LOAD_DO_NOT_PROMPT_FOR_LOGIN |
                           net::LOAD_DO_NOT_SEND_AUTH_DATA);
   request_.Start();
 }
 
 HttpPipeliningCompatibilityClient::Request::~Request() {
@@ skipping 91 matching lines @@
     // that all pipelining errors can be detected by the network stack, then we
     // don't need to worry about broken proxies.
     client_->ReportNetworkError(request_id_, status.error());
     client_->OnRequestFinished(request_id_, NETWORK_ERROR);
     return;
   }
   client_->OnRequestFinished(request_id_, result);
 }
 
 }  // namespace chrome_browser_net