Download code cleanup:

chrome/browser/download/download_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_manager.h"
 
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "base/callback.h"
 #include "base/file_util.h"
@@ skipping 823 matching lines @@
     // We need to update the path uniquifier so that the UI shows the right
     // name when calling GetFileName().
     download->set_path_uniquifier(new_path_uniquifier);
     RenameDownload(download, new_path);
   }
 
   // Continue the download finished sequence.
   ContinueDownloadFinished(download);
 }
 
-// static
-void DownloadManager::OnCancelDownloadRequest(ResourceDispatcherHost* rdh,
-                                              int render_process_id,
-                                              int request_id) {
-  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
-  rdh->CancelRequest(render_process_id, request_id, false);
-}
-
 void DownloadManager::DownloadCancelled(int32 download_id) {
   DownloadMap::iterator it = in_progress_.find(download_id);
   if (it == in_progress_.end())
     return;
   DownloadItem* download = it->second;
 
   // Clean up will happen when the history system create callback runs if we
   // don't have a valid db_handle yet.
   if (download->db_handle() != kUninitializedHandle) {
     in_progress_.erase(it);
     UpdateHistoryForDownload(download);
   }
 
   DownloadCancelledInternal(download_id,
                             download->render_process_id(),
                             download->request_id());
   UpdateAppIcon();
 }
 
 void DownloadManager::DownloadCancelledInternal(int download_id,
                                                 int render_process_id,
                                                 int request_id) {
   // Cancel the network request.  RDH is guaranteed to outlive the IO thread.
   ChromeThread::PostTask(
       ChromeThread::IO, FROM_HERE,
-      NewRunnableFunction(&DownloadManager::OnCancelDownloadRequest,
+      NewRunnableFunction(&download_util::CancelDownloadRequest,
                           g_browser_process->resource_dispatcher_host(),
                           render_process_id,
                           request_id));
 
   // Tell the file manager to cancel the download.
   file_manager_->RemoveDownload(download_id, this);  // On the UI thread
   ChromeThread::PostTask(
       ChromeThread::FILE, FROM_HERE,
       NewRunnableMethod(
           file_manager_, &DownloadFileManager::CancelDownload, download_id));
@@ skipping 154 matching lines @@
   return RemoveDownloadsBetween(base::Time(), base::Time());
 }
 
 // Initiate a download of a specific URL. We send the request to the
 // ResourceDispatcherHost, and let it send us responses like a regular
 // download.
 void DownloadManager::DownloadUrl(const GURL& url,
                                   const GURL& referrer,
                                   const std::string& referrer_charset,
                                   TabContents* tab_contents) {
-  file_manager_->DownloadUrl(url,
-                             referrer,
-                             referrer_charset,
-                             DownloadSaveInfo(),
-                             tab_contents->GetRenderProcessHost()->id(),
-                             tab_contents->render_view_host()->routing_id(),
-                             request_context_getter_);
+  DownloadUrlToFile(url, referrer, referrer_charset, DownloadSaveInfo(),
+                    tab_contents);
 }
 
 void DownloadManager::DownloadUrlToFile(const GURL& url,
                                         const GURL& referrer,
                                         const std::string& referrer_charset,
                                         const DownloadSaveInfo& save_info,
                                         TabContents* tab_contents) {
   DCHECK(tab_contents);
-  file_manager_->DownloadUrl(url,
-                             referrer,
-                             referrer_charset,
-                             save_info,
-                             tab_contents->GetRenderProcessHost()->id(),
-                             tab_contents->render_view_host()->routing_id(),
-                             request_context_getter_);
+  ChromeThread::PostTask(ChromeThread::IO, FROM_HERE,
+      NewRunnableFunction(&download_util::DownloadUrl,
+                          url,
+                          referrer,
+                          referrer_charset,
+                          save_info,
+                          g_browser_process->resource_dispatcher_host(),
+                          tab_contents->GetRenderProcessHost()->id(),
+                          tab_contents->render_view_host()->routing_id(),
+                          request_context_getter_));
 }
 
 void DownloadManager::GenerateExtension(
     const FilePath& file_name,
     const std::string& mime_type,
     FilePath::StringType* generated_extension) {
   // We're worried about three things here:
   //
   // 1) Security.  Many sites let users upload content, such as buddy icons, to
   //    their web sites.  We want to mitigate the case where an attacker
@@ skipping 524 matching lines @@
   observing_download_manager_->NotifyModelChanged();
 }
 
 void DownloadManager::OtherDownloadManagerObserver::SetDownloads(
     std::vector<DownloadItem*>& downloads) {
 }
 
 void DownloadManager::OtherDownloadManagerObserver::ManagerGoingDown() {
   observed_download_manager_ = NULL;
 }