gdata: Simplify InitiateUpload() and ResumeUpload()

chrome/browser/chromeos/gdata/gdata_file_system.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/chromeos/gdata/gdata_file_system.h"
 
 #include <errno.h>
 #include <sys/stat.h>
 
 #include <set>
@@ skipping 1870 matching lines @@
   cache_paths_.push_back(root_path.Append(kGDataCacheTmpDocumentsDir));
 }
 
 void GDataFileSystem::InitiateUpload(
     const std::string& file_name,
     const std::string& content_type,
     int64 content_length,
     const FilePath& destination_directory,
     const FilePath& virtual_path,
     const InitiateUploadCallback& callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
   GURL destination_directory_url =
       GetUploadUrlForDirectory(destination_directory);
 
   if (destination_directory_url.is_empty()) {
     if (!callback.is_null()) {
       MessageLoop::current()->PostTask(

[achuithb, 2012/04/24 23:46:14]

Is there a reason to PostTask here instead of running the callback?

[satorux1, 2012/04/24 23:54:19]

In async functions, we usually run a callback through the message loop as the
caller may not expect that the callback is called immediately. I think this
convention is to be just extra defensive.

           FROM_HERE,
           base::Bind(callback,
                      HTTP_BAD_REQUEST, GURL()));
     }
     return;
   }
 
   documents_service_->InitiateUpload(
-          InitiateUploadParams(file_name,
-                                 content_type,
-                                 content_length,
-                                 destination_directory_url,
-                                 virtual_path),
-          base::Bind(&GDataFileSystem::OnUploadLocationReceived,
-                     GetWeakPtrForCurrentThread(),
-                     callback,
-                     // MessageLoopProxy is used to run |callback| on the
-                     // thread where this function was called.
-                     base::MessageLoopProxy::current()));
-}
-
-void GDataFileSystem::OnUploadLocationReceived(
-    const InitiateUploadCallback& callback,
-    scoped_refptr<base::MessageLoopProxy> message_loop_proxy,
-    GDataErrorCode code,
-    const GURL& upload_location) {
-
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (!callback.is_null()) {
-    message_loop_proxy->PostTask(FROM_HERE, base::Bind(callback, code,
-                                                       upload_location));
-  }
+      InitiateUploadParams(file_name,
+                           content_type,
+                           content_length,
+                           destination_directory_url,
+                           virtual_path),
+      callback);
 }
 
 void GDataFileSystem::ResumeUpload(
     const ResumeUploadParams& params,
     const ResumeFileUploadCallback& callback) {
-  documents_service_->ResumeUpload(
-          params,
-          base::Bind(&GDataFileSystem::OnResumeUpload,
-                     GetWeakPtrForCurrentThread(),
-                     base::MessageLoopProxy::current(),
-                     callback));
-}
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-void GDataFileSystem::OnResumeUpload(
-    scoped_refptr<base::MessageLoopProxy> message_loop_proxy,
-    const ResumeFileUploadCallback& callback,
-    const ResumeUploadResponse& response,
-    scoped_ptr<DocumentEntry> new_entry) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (!callback.is_null())
-    message_loop_proxy->PostTask(FROM_HERE,
-        base::Bind(callback, response, base::Passed(&new_entry)));
+  documents_service_->ResumeUpload(params, callback);
 }
 
 void GDataFileSystem::UnsafeFindEntryByPath(
     const FilePath& file_path,
     FindEntryDelegate* delegate) {
   DCHECK(delegate);
   lock_.AssertAcquired();
 
   std::vector<FilePath::StringType> components;
   file_path.GetComponents(&components);
@@ skipping 2436 matching lines @@
   pref_registrar_->Init(profile_->GetPrefs());
   pref_registrar_->Add(prefs::kDisableGDataHostedFiles, this);
 }
 
 void SetFreeDiskSpaceGetterForTesting(FreeDiskSpaceGetterInterface* getter) {
   delete global_free_disk_getter_for_testing;  // Safe to delete NULL;
   global_free_disk_getter_for_testing = getter;
 }
 
 }  // namespace gdata