Replace NewRunnableMethod with Callback in DownloadFileManager.

content/browser/download/download_file_manager.cc

 // Copyright (c) 2011 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_file_manager.h"
 
+#include <set>
+#include <string>

[Randy Smith (Not in Mondays), 2011/10/28 17:42:31]

Why the extra includes?

[achuithb, 2011/10/28 19:37:37]

To satisfy gcl lint (include what you use). We are actually using set and string
in this file and they have not been included.

+
+#include "base/bind.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
-#include "base/task.h"
 #include "base/utf_string_conversions.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/download/download_buffer.h"
 #include "content/browser/download/download_create_info.h"
 #include "content/browser/download/download_file.h"
 #include "content/browser/download/download_manager.h"
 #include "content/browser/download/download_request_handle.h"
 #include "content/browser/renderer_host/resource_dispatcher_host.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/public/browser/download_manager_delegate.h"
@@ skipping 13 matching lines @@
 }
 
 DownloadFileManager::~DownloadFileManager() {
   DCHECK(downloads_.empty());
 }
 
 void DownloadFileManager::Shutdown() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
-      NewRunnableMethod(this, &DownloadFileManager::OnShutdown));
+      base::Bind(&DownloadFileManager::OnShutdown, this));
 }
 
 void DownloadFileManager::OnShutdown() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   StopUpdateTimer();
   STLDeleteValues(&downloads_);
 }
 
 void DownloadFileManager::CreateDownloadFile(
     DownloadCreateInfo* info, const DownloadRequestHandle& request_handle,
@@ skipping 16 matching lines @@
   DCHECK(GetDownloadFile(global_id) == NULL);
   downloads_[global_id] = download_file.release();
 
   // The file is now ready, we can un-pause the request and start saving data.
   request_handle.ResumeRequest();
 
   StartUpdateTimer();
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      NewRunnableMethod(download_manager,
-                        &DownloadManager::StartDownload, info->download_id));
+      base::Bind(&DownloadManager::StartDownload, download_manager,
+                 info->download_id));
 }
 
 DownloadFile* DownloadFileManager::GetDownloadFile(DownloadId global_id) {
   DownloadFileMap::iterator it = downloads_.find(global_id);
   return it == downloads_.end() ? NULL : it->second;
 }
 
 void DownloadFileManager::StartUpdateTimer() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   if (!update_timer_.IsRunning()) {
@@ skipping 10 matching lines @@
 
 void DownloadFileManager::UpdateInProgressDownloads() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   for (DownloadFileMap::iterator i = downloads_.begin();
        i != downloads_.end(); ++i) {
     DownloadId global_id = i->first;
     DownloadFile* download_file = i->second;
     DownloadManager* manager = download_file->GetDownloadManager();
     if (manager) {
       BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-          NewRunnableMethod(manager, &DownloadManager::UpdateDownload,
-                            global_id.local(), download_file->bytes_so_far()));
+          base::Bind(&DownloadManager::UpdateDownload, manager,
+                     global_id.local(), download_file->bytes_so_far()));
     }
   }
 }
 
 void DownloadFileManager::StartDownload(
     DownloadCreateInfo* info, const DownloadRequestHandle& request_handle) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(info);
 
   DownloadManager* manager = request_handle.GetDownloadManager();
   if (!manager) {
     request_handle.CancelRequest();
     delete info;
     return;
   }
 
   // TODO(phajdan.jr): fix the duplication of path info below.
   info->path = info->save_info.file_path;
 
   manager->CreateDownloadItem(info, request_handle);
   bool hash_needed = manager->delegate()->GenerateFileHash();
 
   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
-      NewRunnableMethod(this, &DownloadFileManager::CreateDownloadFile,
-                        info, request_handle, make_scoped_refptr(manager),
-                        hash_needed));
+      base::Bind(&DownloadFileManager::CreateDownloadFile, this,
+                 info, request_handle, make_scoped_refptr(manager),
+                 hash_needed));
 }
 
 // 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(
     DownloadId global_id, content::DownloadBuffer* buffer) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
@@ skipping 14 matching lines @@
 
         int64 bytes_downloaded = download_file->bytes_so_far();
         // Calling this here in case we get more data, to avoid
         // processing data after an error.  That could lead to
         // files that are corrupted if the later processing succeeded.
         CancelDownload(global_id);
         download_file = NULL;  // Was deleted in |CancelDownload|.
 
         if (download_manager) {
           BrowserThread::PostTask(
-              BrowserThread::UI,
-              FROM_HERE,
-              NewRunnableMethod(
-                  download_manager,
-                  &DownloadManager::OnDownloadInterrupted,
-                  global_id.local(),
-                  bytes_downloaded,
-                  ConvertNetErrorToInterruptReason(
-                      write_result,
-                      DOWNLOAD_INTERRUPT_FROM_DISK)));
+              BrowserThread::UI, FROM_HERE,
+              base::Bind(&DownloadManager::OnDownloadInterrupted,
+                         download_manager, global_id.local(), bytes_downloaded,
+                         ConvertNetErrorToInterruptReason(
+                             write_result, DOWNLOAD_INTERRUPT_FROM_DISK)));
         }
       }
     }
     data->Release();
   }
 }
 
 void DownloadFileManager::OnResponseCompleted(
     DownloadId global_id,
     InterruptReason reason,
@@ skipping 13 matching lines @@
     CancelDownload(global_id);
     return;
   }
 
   std::string hash;
   if (!download_file->GetSha256Hash(&hash))
     hash.clear();
 
   if (reason == DOWNLOAD_INTERRUPT_REASON_NONE) {
     BrowserThread::PostTask(
-        BrowserThread::UI,
-        FROM_HERE,
-        NewRunnableMethod(
-            download_manager,
-            &DownloadManager::OnResponseCompleted,
-            global_id.local(),
-            download_file->bytes_so_far(),
-            hash));
+        BrowserThread::UI, FROM_HERE,
+        base::Bind(&DownloadManager::OnResponseCompleted,
+                   download_manager, global_id.local(),
+                   download_file->bytes_so_far(), hash));
   } else {
     BrowserThread::PostTask(
-        BrowserThread::UI,
-        FROM_HERE,
-        NewRunnableMethod(
-            download_manager,
-            &DownloadManager::OnDownloadInterrupted,
-            global_id.local(),
-            download_file->bytes_so_far(),
-            reason));
+        BrowserThread::UI, FROM_HERE,
+        base::Bind(&DownloadManager::OnDownloadInterrupted,
+                   download_manager, global_id.local(),
+                   download_file->bytes_so_far(), reason));
   }
   // We need to keep the download around until the UI thread has finalized
   // the name.
 }
 
 // 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(DownloadId global_id) {
   VLOG(20) << __FUNCTION__ << "()" << " id = " << global_id;
@@ skipping 130 matching lines @@
   }
 
 #if defined(OS_MACOSX)
   // Done here because we only want to do this once; see
   // http://crbug.com/13120 for details.
   download_file->AnnotateWithSourceInformation();
 #endif
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      NewRunnableMethod(
-          download_manager, &DownloadManager::OnDownloadRenamedToFinalName,
-          global_id.local(), new_path, uniquifier));
+      base::Bind(&DownloadManager::OnDownloadRenamedToFinalName,
+                 download_manager, global_id.local(), new_path, uniquifier));
 }
 
 // Called only from RenameInProgressDownloadFile and
 // RenameCompletingDownloadFile on the FILE thread.
 void DownloadFileManager::CancelDownloadOnRename(
     DownloadId global_id, net::Error rename_error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   DownloadFile* download_file = GetDownloadFile(global_id);
   if (!download_file)
     return;
 
   DownloadManager* download_manager = download_file->GetDownloadManager();
   if (!download_manager) {
     // Without a download manager, we can't cancel the request normally, so we
     // need to do it here.  The normal path will also update the download
     // history before canceling the request.
     download_file->CancelDownloadRequest();
     return;
   }
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      NewRunnableMethod(download_manager,
-                        &DownloadManager::OnDownloadInterrupted,
-                        global_id.local(),
-                        download_file->bytes_so_far(),
-                        ConvertNetErrorToInterruptReason(
-                            rename_error,
-                            DOWNLOAD_INTERRUPT_FROM_DISK)));
+      base::Bind(&DownloadManager::OnDownloadInterrupted,
+                 download_manager, global_id.local(),
+                 download_file->bytes_so_far(),
+                 ConvertNetErrorToInterruptReason(
+                     rename_error, DOWNLOAD_INTERRUPT_FROM_DISK)));
 }
 
 void DownloadFileManager::EraseDownload(DownloadId global_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   if (!ContainsKey(downloads_, global_id))
     return;
 
   DownloadFile* download_file = downloads_[global_id];
 
   VLOG(20) << " " << __FUNCTION__ << "()"
            << " id = " << global_id
            << " download_file = " << download_file->DebugString();
 
   downloads_.erase(global_id);
 
   delete download_file;
 
   if (downloads_.empty())
     StopUpdateTimer();
 }