Initial CL for Downloads resumption.

content/browser/download/download_resource_handler.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_resource_handler.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 10 matching lines @@
 #include "content/browser/loader/resource_dispatcher_host_impl.h"
 #include "content/browser/loader/resource_request_info_impl.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/download_interrupt_reasons.h"
 #include "content/public/browser/download_item.h"
 #include "content/public/browser/download_manager_delegate.h"
 #include "content/public/common/resource_response.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_response_headers.h"
+#include "net/http/http_status_code.h"
 #include "net/url_request/url_request_context.h"
 
 namespace content {
 namespace {
 
 static const int kDownloadByteStreamSize = 100 * 1024;
 
 void CallStartedCBOnUIThread(
     const DownloadResourceHandler::OnStartedCallback& started_cb,
     DownloadItem* item,
@@ skipping 25 matching lines @@
   DownloadItem* item = download_manager->StartDownload(
       info.Pass(), stream.Pass());
 
   if (!started_cb.is_null())
     started_cb.Run(item, net::OK);
 }
 
 }  // namespace
 
 DownloadResourceHandler::DownloadResourceHandler(
+    DownloadId id,
     net::URLRequest* request,
     const DownloadResourceHandler::OnStartedCallback& started_cb,
     scoped_ptr<DownloadSaveInfo> save_info)
-    : render_view_id_(0),               // Actually initialized below.
+    : download_id_(id),
+      render_view_id_(0),               // Actually initialized below.
       content_length_(0),
       request_(request),
       started_cb_(started_cb),
       save_info_(save_info.Pass()),
       last_buffer_size_(0),
       bytes_read_(0),
       pause_count_(0),
       was_deferred_(false),
       on_response_started_called_(false) {
   ResourceRequestInfoImpl* info(ResourceRequestInfoImpl::ForRequest(request));
@@ skipping 52 matching lines @@
 
   // Create the ByteStream for sending data to the download sink.
   scoped_ptr<ByteStreamReader> stream_reader;
   CreateByteStream(
       base::MessageLoopProxy::current(),
       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE),
       kDownloadByteStreamSize, &stream_writer_, &stream_reader);
   stream_writer_->RegisterCallback(
       base::Bind(&DownloadResourceHandler::ResumeRequest, AsWeakPtr()));
 
+  info->download_id = download_id_;
   info->url_chain = request_->url_chain();
   info->referrer_url = GURL(request_->referrer());
   info->start_time = base::Time::Now();
   info->total_bytes = content_length_;
   info->has_user_gesture = request_info->HasUserGesture();
   info->content_disposition = content_disposition_;
   info->mime_type = response->head.mime_type;
   info->remote_address = request_->GetSocketAddress().host();
   RecordDownloadMimeType(info->mime_type);
   RecordDownloadContentDisposition(info->content_disposition);
 
   info->request_handle =
       DownloadRequestHandle(AsWeakPtr(), global_id_.child_id,
                             render_view_id_, global_id_.request_id);
 
   // Get the last modified time and etag.
   const net::HttpResponseHeaders* headers = request_->response_headers();
   if (headers) {
     std::string last_modified_hdr;
     std::string etag;
     if (headers->EnumerateHeader(NULL, "Last-Modified", &last_modified_hdr))
       info->last_modified = last_modified_hdr;
     if (headers->EnumerateHeader(NULL, "ETag", &etag))
       info->etag = etag;
+
+    int status = headers->response_code();
+    if (2 == status / 100  && status != net::HTTP_PARTIAL_CONTENT) {
+      // Success & not range response; if we asked for a range, we didn't
+      // get it--reset the file pointers to reflect that.
+      save_info_->offset = 0;
+      save_info_->hash_state = "";
+    }
   }
 
   std::string content_type_header;
   if (!response->head.headers ||
       !response->head.headers->GetMimeType(&content_type_header))
     content_type_header = "";
   info->original_mime_type = content_type_header;
 
   if (!response->head.headers ||
       !response->head.headers->EnumerateHeader(
@@ skipping 89 matching lines @@
     *defer = was_deferred_ = true;
 
   return true;
 }
 
 bool DownloadResourceHandler::OnResponseCompleted(
     int request_id,
     const net::URLRequestStatus& status,
     const std::string& security_info) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  int response_code = status.is_success() ? request_->GetResponseCode() : 0;
   VLOG(20) << __FUNCTION__ << "()" << DebugString()
            << " request_id = " << request_id
            << " status.status() = " << status.status()
-           << " status.error() = " << status.error();
-  int response_code = status.is_success() ? request_->GetResponseCode() : 0;
+           << " status.error() = " << status.error()
+           << " response_code = " << response_code;
 
   net::Error error_code = net::OK;
   if (status.status() == net::URLRequestStatus::FAILED ||
       // Note cancels as failures too.
       status.status() == net::URLRequestStatus::CANCELED) {
     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;
   }
@@ skipping 16 matching lines @@
     // 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(ahendrickson) -- Find a better set of codes to use here, as
     // CANCELED/ERR_ABORTED can occur for reasons other than user cancel.
     reason = DOWNLOAD_INTERRUPT_REASON_USER_CANCELED;
   }
 
-  if (status.is_success()) {
-    if (response_code >= 400) {
-      switch(response_code) {
-        case 404:  // File Not Found.
-          reason = DOWNLOAD_INTERRUPT_REASON_SERVER_BAD_CONTENT;
-          break;
-        case 416:  // Range Not Satisfiable.
-          reason = DOWNLOAD_INTERRUPT_REASON_SERVER_NO_RANGE;
-          break;
-        case 412:  // Precondition Failed.
-          reason = DOWNLOAD_INTERRUPT_REASON_SERVER_PRECONDITION;
-          break;
-        default:
-          reason = DOWNLOAD_INTERRUPT_REASON_SERVER_FAILED;
-          break;
-      }
+  if (status.is_success() &&
+      reason == DOWNLOAD_INTERRUPT_REASON_NONE &&
+      request_->response_headers()) {
+    // Handle server's response codes.
+    switch(response_code) {
+      case -1:                          // Non-HTTP request.
+      case net::HTTP_OK:
+      case net::HTTP_PARTIAL_CONTENT:
+        // Expected successful codes.
+        break;
+      case net::HTTP_NO_CONTENT:
+      case net::HTTP_NOT_FOUND:
+        reason = DOWNLOAD_INTERRUPT_REASON_SERVER_BAD_CONTENT;
+        break;
+      case net::HTTP_PRECONDITION_FAILED:
+        // Failed our 'If-Unmodified-Since' or 'If-Match'; see
+        // download_manager_impl.cc BeginDownload()
+        reason = DOWNLOAD_INTERRUPT_REASON_SERVER_PRECONDITION;
+        break;
+      case net::HTTP_REQUESTED_RANGE_NOT_SATISFIABLE:
+        // Retry by downloading from the start automatically:
+        // If we haven't received data when we get this error, we won't.
+        reason = DOWNLOAD_INTERRUPT_REASON_SERVER_NO_RANGE;
+        break;
+      default:    // All other errors.
+        // Redirection should have been handled earlier in the stack.
+        DCHECK(3 != response_code / 100);
+
+        // Informational codes should have been handled earlier in the
+        // stack.
+        DCHECK(1 != response_code / 100);
+        reason = DOWNLOAD_INTERRUPT_REASON_SERVER_FAILED;
+        break;
     }
   }
 
   RecordAcceptsRanges(accept_ranges_, bytes_read_);
   RecordNetworkBlockage(
       base::TimeTicks::Now() - download_start_time_, total_pause_time_);
 
   CallStartedCB(NULL, error_code);
 
   // Send the info down the stream.  Conditional is in case we get
@@ skipping 99 matching lines @@
 
   // Remove output stream callback if a stream exists.
   if (stream_writer_.get())
     stream_writer_->RegisterCallback(base::Closure());
 
   UMA_HISTOGRAM_TIMES("SB2.DownloadDuration",
                       base::TimeTicks::Now() - download_start_time_);
 }
 
 }  // namespace content