Download code cleanup:

chrome/browser/download/download_file_manager.cc

 // Copyright (c) 2010 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/download/download_file_manager.h"
 
 #include "base/file_util.h"
 #include "base/task.h"
 #include "base/utf_string_conversions.h"
 #include "build/build_config.h"
@@ skipping 184 matching lines @@
                             resource_dispatcher_host_,
                             info->child_id,
                             info->request_id));
     delete info;
     delete download;
     return;
   }
 
   DCHECK(GetDownloadFile(info->download_id) == NULL);
   downloads_[info->download_id] = download;
-  info->path = download->full_path();
+  // TODO(phajdan.jr): fix the duplication of path info below.
+  info->path = info->save_info.file_path;
   {
     AutoLock lock(progress_lock_);
     ui_progress_[info->download_id] = info->received_bytes;
   }
 
   ChromeThread::PostTask(
       ChromeThread::UI, FROM_HERE,
       NewRunnableMethod(this, &DownloadFileManager::OnStartDownload, info));
 }
 
 // We don't forward an update to the UI thread here, since we want to throttle
 // the UI update rate via a periodic timer. If the user has cancelled the
 // download (in the UI thread), we may receive a few more updates before the IO
 // thread gets the cancel message: we just delete the data since the
 // DownloadFile has been deleted.
 void DownloadFileManager::UpdateDownload(int id, DownloadBuffer* buffer) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::FILE));
   std::vector<DownloadBuffer::Contents> contents;
   {
     AutoLock auto_lock(buffer->lock);
     contents.swap(buffer->contents);
   }
 
+  // Keep track of how many bytes we have successfully saved to update
+  // our progress status in the UI.
+  int64 progress_bytes = 0;
+
   DownloadFile* download = GetDownloadFile(id);
   for (size_t i = 0; i < contents.size(); ++i) {
     net::IOBuffer* data = contents[i].first;
     const int data_len = contents[i].second;
-    if (download)
-      download->AppendDataToFile(data->data(), data_len);
+    if (download) {
+      if (download->AppendDataToFile(data->data(), data_len))
+        progress_bytes += data_len;
+    }
     data->Release();
   }
 
   if (download) {
     AutoLock lock(progress_lock_);
-    ui_progress_[download->id()] = download->bytes_so_far();
+    ui_progress_[download->id()] += progress_bytes;
   }
 }
 
 void DownloadFileManager::DownloadFinished(int id, DownloadBuffer* buffer) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::FILE));
   delete buffer;
   DownloadFileMap::iterator it = downloads_.find(id);
   if (it != downloads_.end()) {
     DownloadFile* download = it->second;
-    download->set_in_progress(false);
+    download->Finish();
+
+    int64 download_size = -1;
+    {
+      AutoLock lock(progress_lock_);
+      download_size = ui_progress_[download->id()];
+    }
 
     ChromeThread::PostTask(
         ChromeThread::UI, FROM_HERE,
         NewRunnableMethod(
             this, &DownloadFileManager::OnDownloadFinished,
-            id, download->bytes_so_far()));
+            id, download_size));
 
     // We need to keep the download around until the UI thread has finalized
     // the name.
     if (download->path_renamed()) {
       downloads_.erase(it);
       delete download;
     }
   }
 
   if (downloads_.empty())
     ChromeThread::PostTask(
       ChromeThread::UI, FROM_HERE,
       NewRunnableMethod(this, &DownloadFileManager::StopUpdateTimer));
 }
 
 // This method will be sent via a user action, or shutdown on the UI thread, and
 // run on the download thread. Since this message has been sent from the UI
 // thread, the download may have already completed and won't exist in our map.
 void DownloadFileManager::CancelDownload(int id) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::FILE));
   DownloadFileMap::iterator it = downloads_.find(id);
   if (it != downloads_.end()) {
     DownloadFile* download = it->second;
-    download->set_in_progress(false);
-
     download->Cancel();
 
     ChromeThread::PostTask(
         ChromeThread::UI, FROM_HERE,
         NewRunnableMethod(
             this, &DownloadFileManager::RemoveDownloadFromUIProgress,
             download->id()));
 
     if (download->path_renamed()) {
       downloads_.erase(it);
@@ skipping 138 matching lines @@
   } else {
     // Error. Between the time the UI thread generated 'full_path' to the time
     // this code runs, something happened that prevents us from renaming.
     DownloadManagerMap::iterator dmit = managers_.find(download->id());
     if (dmit != managers_.end()) {
       DownloadManager* dlm = dmit->second;
       ChromeThread::PostTask(
           ChromeThread::UI, FROM_HERE,
           NewRunnableMethod(dlm, &DownloadManager::DownloadCancelled, id));
     } else {
-      ChromeThread::PostTask(
-          ChromeThread::IO, FROM_HERE,
-          NewRunnableFunction(&download_util::CancelDownloadRequest,
-                              resource_dispatcher_host_,
-                              download->child_id(),
-                              download->request_id()));
+      download->CancelDownloadRequest(resource_dispatcher_host_);
     }
   }
 
   // If the download has completed before we got this final name, we remove it
   // from our in progress map.
   if (!download->in_progress()) {
     downloads_.erase(it);
     delete download;
   }
 
   if (downloads_.empty()) {
     ChromeThread::PostTask(
       ChromeThread::UI, FROM_HERE,
       NewRunnableMethod(this, &DownloadFileManager::StopUpdateTimer));
   }
 }