[Download] Return DownloadInterruptReason from OnStartedCallback

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 19 matching lines @@
 #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 {
 
 void CallStartedCBOnUIThread(
     const DownloadUrlParameters::OnStartedCallback& started_cb,
     DownloadItem* item,
-    net::Error error) {
+    DownloadInterruptReason interrupt_reason) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (started_cb.is_null())
     return;
-  started_cb.Run(item, error);
+  started_cb.Run(item, interrupt_reason);
 }
 
 // Static function in order to prevent any accidental accesses to
 // DownloadResourceHandler members from the UI thread.
 static void StartOnUIThread(
     scoped_ptr<DownloadCreateInfo> info,
     scoped_ptr<ByteStreamReader> stream,
     const DownloadUrlParameters::OnStartedCallback& started_cb) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DownloadManager* download_manager = info->request_handle.GetDownloadManager();
   if (!download_manager) {
     // NULL in unittests or if the page closed right after starting the
     // download.
     if (!started_cb.is_null())
-      started_cb.Run(NULL, net::ERR_ACCESS_DENIED);
+      started_cb.Run(NULL, DOWNLOAD_INTERRUPT_REASON_USER_CANCELED);
     return;
   }
 
   download_manager->StartDownload(info.Pass(), stream.Pass(), started_cb);
 }
 
 }  // namespace
 
 const int DownloadResourceHandler::kDownloadByteStreamSize = 100 * 1024;
 
@@ skipping 127 matching lines @@
                  // access is always on IO thread but function
                  // is called on UI thread.
                  started_cb_));
   // Guaranteed to be called in StartOnUIThread
   started_cb_.Reset();
 
   return true;
 }
 
 void DownloadResourceHandler::CallStartedCB(
-    DownloadItem* item, net::Error error) {
+    DownloadItem* item,
+    DownloadInterruptReason interrupt_reason) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (started_cb_.is_null())
     return;
   BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
-      base::Bind(&CallStartedCBOnUIThread, started_cb_, item, error));
+      BrowserThread::UI,
+      FROM_HERE,
+      base::Bind(
+          &CallStartedCBOnUIThread, started_cb_, item, interrupt_reason));
   started_cb_.Reset();
 }
 
 bool DownloadResourceHandler::OnWillStart(int request_id,
                                           const GURL& url,
                                           bool* defer) {
   return true;
 }
 
 // Create a new buffer, which will be handed to the download thread for file
@@ skipping 145 matching lines @@
   if (request()->response_headers()) {
     request()->response_headers()->EnumerateHeader(
         NULL, "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_);
 
-  CallStartedCB(NULL, error_code);
+  CallStartedCB(NULL, reason);
 
   // Send the info down the stream.  Conditional is in case we get
   // OnResponseCompleted without OnResponseStarted.
   if (stream_writer_)
     stream_writer_->Close(reason);
 
   // If the error mapped to something unknown, record it so that
   // we can drill down.
   if (reason == DOWNLOAD_INTERRUPT_REASON_NETWORK_FAILED) {
     UMA_HISTOGRAM_CUSTOM_ENUMERATION("Download.MapErrorNetworkFailed",
@@ skipping 64 matching lines @@
                             info->GetRequestID(),
                             info->GetRouteID());
 }
 
 DownloadResourceHandler::~DownloadResourceHandler() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   // This won't do anything if the callback was called before.
   // If it goes through, it will likely be because OnWillStart() returned
   // false somewhere in the chain of resource handlers.
-  CallStartedCB(NULL, net::ERR_ACCESS_DENIED);
+  CallStartedCB(NULL, DOWNLOAD_INTERRUPT_REASON_NETWORK_FAILED);
 
   // Remove output stream callback if a stream exists.
   if (stream_writer_)
     stream_writer_->RegisterCallback(base::Closure());
 
   UMA_HISTOGRAM_TIMES("SB2.DownloadDuration",
                       base::TimeTicks::Now() - download_start_time_);
 }
 
 }  // namespace content