Ensure pipelined requests are sent in the same order they're queued.

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"
@@ skipping 67 matching lines @@
                             request_id, description);
 }
 
 HttpPipeliningCompatibilityClient::Request::Request(
     int request_id,
     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),
+      request_(new net::URLRequest(GURL(base_url + info.filename), this)),
       info_(info),
-      client_(client),
-      finished_(false) {
-  request_.set_context(url_request_context);
-  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();
+      client_(client) {
+  request_->set_context(url_request_context);
+  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() {
 }
 
 void HttpPipeliningCompatibilityClient::Request::OnReceivedRedirect(
     net::URLRequest* request,
     const GURL& new_url,
     bool* defer_redirect) {
   *defer_redirect = true;
   request->Cancel();
   Finished(REDIRECTED);
 }
 
 void HttpPipeliningCompatibilityClient::Request::OnSSLCertificateError(
     net::URLRequest* request,
     const net::SSLInfo& ssl_info,
     bool fatal) {
   Finished(CERT_ERROR);
 }
 
 void HttpPipeliningCompatibilityClient::Request::OnResponseStarted(
     net::URLRequest* request) {
-  if (finished_) {
-    return;
-  }
   int response_code = request->GetResponseCode();
   if (response_code > 0) {
     client_->ReportResponseCode(request_id_, response_code);
   }
   if (response_code == 200) {
     const net::HttpVersion required_version(1, 1);
     if (request->response_info().headers->GetParsedHttpVersion() <
         required_version) {
       Finished(BAD_HTTP_VERSION);
     } else {
@@ skipping 19 matching lines @@
     } else if (response_.find(info_.expected_response) == 0) {
       Finished(TOO_LARGE);
     } else {
       Finished(CONTENT_MISMATCH);
     }
   }
 }
 
 void HttpPipeliningCompatibilityClient::Request::DoRead() {
   int bytes_read = 0;
-  if (request_.Read(read_buffer_.get(), info_.expected_response.length(),
-                    &bytes_read)) {
-    OnReadCompleted(&request_, bytes_read);
+  if (request_->Read(read_buffer_.get(), info_.expected_response.length(),
+                     &bytes_read)) {
+    OnReadCompleted(request_.get(), bytes_read);
   }
 }
 
 void HttpPipeliningCompatibilityClient::Request::DoReadFinished() {
   if (response_.length() != info_.expected_response.length()) {
     if (info_.expected_response.find(response_) == 0) {
       Finished(TOO_SMALL);
     } else {
       Finished(CONTENT_MISMATCH);
     }
   } else if (response_ == info_.expected_response) {
     Finished(SUCCESS);
   } else {
     Finished(CONTENT_MISMATCH);
   }
 }
 
 void HttpPipeliningCompatibilityClient::Request::Finished(Status result) {
-  if (finished_) {
-    return;
-  }
-  finished_ = true;
-  const net::URLRequestStatus& status = request_.status();
+  const net::URLRequestStatus& status = request_->status();
   if (status.status() == net::URLRequestStatus::FAILED) {
     // Network errors trump all other status codes, because network errors can
     // be detected by the network stack even with real content. If we determine
     // 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;
+  } else {
+    client_->OnRequestFinished(request_id_, result);
   }
-  client_->OnRequestFinished(request_id_, result);
+  request_.reset();
 }
 
 }  // namespace chrome_browser_net