interrupt and resume download with CONTENT_LENGTH_MISMATCH errors

content/browser/download/download_request_core.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 "content/browser/download/download_request_core.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 380 matching lines @@
 
 void DownloadRequestCore::OnResponseCompleted(
     const net::URLRequestStatus& status) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   int response_code = status.is_success() ? request()->GetResponseCode() : 0;
   DVLOG(20) << __func__ << "() " << DebugString()
             << " status.status() = " << status.status()
             << " status.error() = " << status.error()
             << " response_code = " << response_code;
 
-  DownloadInterruptReason reason = HandleRequestStatus(status);
+  bool has_strong_validators = false;
+  if (request()->response_headers()) {
+    has_strong_validators =
+        request()->response_headers()->HasStrongValidators();
+  }
+  DownloadInterruptReason reason = HandleRequestStatus(
+      status, has_strong_validators);
 
   if (status.error() == net::ERR_ABORTED) {
     // ERR_ABORTED == something outside of the network
     // stack cancelled the request.  There aren't that many things that
     // could do this to a download request (whose lifetime is separated from
     // the tab from which it came).  We map this to USER_CANCELLED as the
     // case we know about (system suspend because of laptop close) corresponds
     // to a user action.
     // TODO(asanka): A lid close or other power event should result in an
     // interruption that doesn't discard the partial state, unlike
     // USER_CANCELLED. (https://crbug.com/166179)
     if (net::IsCertStatusError(request()->ssl_info().cert_status)) {
       reason = DOWNLOAD_INTERRUPT_REASON_SERVER_CERT_PROBLEM;
     } else {
       reason = DOWNLOAD_INTERRUPT_REASON_USER_CANCELED;
     }
   } else if (abort_reason_ != DOWNLOAD_INTERRUPT_REASON_NONE) {
     // If a more specific interrupt reason was specified before the request
     // was explicitly cancelled, then use it.
     reason = abort_reason_;
   }
 
   std::string accept_ranges;
-  bool has_strong_validators = false;
   if (request()->response_headers()) {
     request()->response_headers()->EnumerateHeader(nullptr, "Accept-Ranges",
                                                    &accept_ranges);
-    has_strong_validators =
-        request()->response_headers()->HasStrongValidators();
   }
   RecordAcceptsRanges(accept_ranges, bytes_read_, has_strong_validators);
   RecordNetworkBlockage(base::TimeTicks::Now() - download_start_time_,
                         total_pause_time_);
 
   // Send the info down the stream.  Conditional is in case we get
   // OnResponseCompleted without OnResponseStarted.
   if (stream_writer_)
     stream_writer_->Close(reason);
 
@@ skipping 52 matching lines @@
       " this=%p "
       " url_ = "
       "\"%s\""
       " }",
       reinterpret_cast<const void*>(this),
       request() ? request()->url().spec().c_str() : "<NULL request>");
 }
 
 // static
 DownloadInterruptReason DownloadRequestCore::HandleRequestStatus(
-    const net::URLRequestStatus& status) {
+    const net::URLRequestStatus& status, bool has_strong_validators) {
   net::Error error_code = net::OK;
   if (!status.is_success()) {
     error_code = static_cast<net::Error>(status.error());  // Normal case.
     // Make sure that at least the fact of failure comes through.
     if (error_code == net::OK)
       error_code = net::ERR_FAILED;
   }
 
-  // ERR_CONTENT_LENGTH_MISMATCH is allowed since a number of servers in the
-  // wild close the connection too early by mistake. Other browsers - IE9,
-  // Firefox 11.0, and Safari 5.1.4 - treat downloads as complete in both cases,
-  // so we follow their lead.
-  if (error_code == net::ERR_CONTENT_LENGTH_MISMATCH)
+  // ERR_CONTENT_LENGTH_MISMATCH can be caused by 1 of the following reasons:
+  // 1. Server or proxy closes the connection too early.
+  // 2. The content-length header is wrong.
+  // If the download has strong validators, we can interrupt the download
+  // and let it resume automatically. Otherwise, resuming the download will
+  // cause it to restart and the download may never complete if the error was
+  // caused by reason 2. As a result, downloads without strong validators are
+  // treated as completed here.
+  // TODO(qinmin): check the metrics from downloads with strong validators,
+  // and decide whether we should interrupt downloads without strong validators
+  // rather than complete them.
+  if (error_code == net::ERR_CONTENT_LENGTH_MISMATCH &&
+      !has_strong_validators) {
     error_code = net::OK;
+    RecordDownloadCount(COMPLETED_WITH_CONTENT_LENGTH_MISMATCH_COUNT);
+  }
+
   DownloadInterruptReason reason = ConvertNetErrorToInterruptReason(
       error_code, DOWNLOAD_INTERRUPT_FROM_NETWORK);
 
   return reason;
 }
 
 // static
 DownloadInterruptReason DownloadRequestCore::HandleSuccessfulServerResponse(
     const net::HttpResponseHeaders& http_headers,
     DownloadSaveInfo* save_info) {
@@ skipping 148 matching lines @@
   // old servers that didn't implement "If-Match" and must be ignored when
   // "If-Match" presents.
   if (has_last_modified) {
     request->SetExtraRequestHeaderByName(
         net::HttpRequestHeaders::kIfUnmodifiedSince, params->last_modified(),
         true);
   }
 }
 
 }  // namespace content