Cleanup: Use PostTaskAndReplyWithResults instead of passing callbacks around in downloads code.

chrome/browser/download/download_path_reservation_tracker.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 "chrome/browser/download/download_path_reservation_tracker.h"
 
 #include <map>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 129 matching lines @@
   *path = dir.Append(truncated + ext);
   return true;
 }
 
 // Called on the FILE thread to reserve a download path. This method:
 // - Creates directory |default_download_path| if it doesn't exist.
 // - Verifies that the parent directory of |suggested_path| exists and is
 //   writeable.
 // - Truncates the suggested name if it exceeds the filesystem's limit.
 // - Uniquifies |suggested_path| if |should_uniquify_path| is true.
-// - Schedules |callback| on the UI thread with the reserved path and a flag
-//   indicating whether the returned path has been successfully verified.
-void CreateReservation(
+// - Returns true if |reserved_path| has been successfully verified.
+bool CreateReservation(
     ReservationKey key,
     const base::FilePath& suggested_path,
     const base::FilePath& default_download_path,
     bool create_directory,
     DownloadPathReservationTracker::FilenameConflictAction conflict_action,
-    const DownloadPathReservationTracker::ReservedPathCallback& callback) {
+    base::FilePath* reserved_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   DCHECK(suggested_path.IsAbsolute());
 
   // Create a reservation map if one doesn't exist. It will be automatically
   // deleted when all the reservations are revoked.
   if (g_reservation_map == NULL)
     g_reservation_map = new ReservationMap;
 
   ReservationMap& reservations = *g_reservation_map;
   DCHECK(!ContainsKey(reservations, key));
@@ skipping 67 matching lines @@
             has_conflicts = false;
             break;
           }
         }
       }
     }
   }
 
   reservations[key] = target_path;
   bool verified = (is_path_writeable && !has_conflicts && !name_too_long);
-  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-                          base::Bind(callback, target_path, verified));
+  *reserved_path = target_path;
+  return verified;
 }
 
 // Called on the FILE thread to update the path of the reservation associated
 // with |key| to |new_path|.
 void UpdateReservation(ReservationKey key, const base::FilePath& new_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   DCHECK(g_reservation_map != NULL);
   ReservationMap::iterator iter = g_reservation_map->find(key);
   if (iter != g_reservation_map->end()) {
     iter->second = new_path;
@@ skipping 12 matching lines @@
   DCHECK(g_reservation_map != NULL);
   DCHECK(ContainsKey(*g_reservation_map, key));
   g_reservation_map->erase(key);
   if (g_reservation_map->size() == 0) {
     // No more reservations. Delete map.
     delete g_reservation_map;
     g_reservation_map = NULL;
   }
 }
 
+void RunGetReservedPathCallback(
+    const DownloadPathReservationTracker::ReservedPathCallback& callback,
+    const base::FilePath* reserved_path,
+    bool verified) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  callback.Run(*reserved_path, verified);
+}
+
 DownloadItemObserver::DownloadItemObserver(DownloadItem* download_item)
     : download_item_(download_item),
       last_target_path_(download_item->GetTargetFilePath()) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   download_item_->AddObserver(this);
 }
 
 DownloadItemObserver::~DownloadItemObserver() {
   download_item_->RemoveObserver(this);
 }
@@ skipping 52 matching lines @@
     const base::FilePath& default_path,
     bool create_directory,
     FilenameConflictAction conflict_action,
     const ReservedPathCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // Attach an observer to the download item so that we know when the target
   // path changes and/or the download is no longer active.
   new DownloadItemObserver(download_item);
   // DownloadItemObserver deletes itself.
 
-  BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE, base::Bind(
-      &CreateReservation,
-      download_item,
-      target_path,
-      default_path,
-      create_directory,
-      conflict_action,
-      callback));
+  base::FilePath* reserved_path = new base::FilePath;
+  BrowserThread::PostTaskAndReplyWithResult(
+      BrowserThread::FILE,
+      FROM_HERE,
+      base::Bind(&CreateReservation,
+                 download_item,
+                 target_path,
+                 default_path,
+                 create_directory,
+                 conflict_action,
+                 reserved_path),
+      base::Bind(&RunGetReservedPathCallback,
+                 callback,
+                 base::Owned(reserved_path)));
 }
 
 // static
 bool DownloadPathReservationTracker::IsPathInUseForTesting(
     const base::FilePath& path) {
   return IsPathInUse(path);
 }