gdata: Cleanup GDataFileSystem::AddUploadedFileOnUIThread().

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 <set>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 3509 matching lines @@
 }
 
 void GDataFileSystem::AddUploadedFileOnUIThread(
     UploadMode upload_mode,
     const FilePath& virtual_dir_path,
     scoped_ptr<DocumentEntry> entry,
     const FilePath& file_content_path,
     GDataCache::FileOperationType cache_operation,
     const base::Closure& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK(!callback.is_null());
+  base::ScopedClosureRunner callback_runner(callback);

[achuithb, 2012/08/02 19:08:37]

nit: Please add a comment since this is not commonly used in chromium code base.

[satorux1, 2012/08/02 19:41:13]

ah this is pretty cool.

[hshi1, 2012/08/02 19:55:13]

Done.

 
   if (!entry.get()) {
     NOTREACHED();
-    callback.Run();
     return;
   }
 
   GDataEntry* dir_entry = directory_service_->FindEntryByPathSync(
       virtual_dir_path);
-  if (!dir_entry) {
-    callback.Run();
+  if (!dir_entry)
     return;
-  }
 
   GDataDirectory* parent_dir  = dir_entry->AsGDataDirectory();
-  if (!parent_dir) {
-    callback.Run();
+  if (!parent_dir)
     return;
-  }
 
   scoped_ptr<GDataEntry> new_entry(
       GDataEntry::FromDocumentEntry(
           parent_dir, entry.get(), directory_service_.get()));
-  if (!new_entry.get()) {
-    callback.Run();
+  if (!new_entry.get())
     return;
-  }
 
   if (upload_mode == UPLOAD_EXISTING_FILE) {
     // Remove an existing entry, which should be present.
     const std::string& resource_id = new_entry->resource_id();
     directory_service_->GetEntryByResourceIdAsync(resource_id,
         base::Bind(&RemoveStaleEntryOnUpload, resource_id, parent_dir));
   }
 
   GDataFile* file = new_entry->AsGDataFile();
   DCHECK(file);
   const std::string& resource_id = file->resource_id();
   const std::string& md5 = file->file_md5();
   parent_dir->AddEntry(new_entry.release());
 
   FOR_EACH_OBSERVER(GDataFileSystemInterface::Observer, observers_,
                     OnDirectoryChanged(virtual_dir_path));
 
   if (upload_mode == UPLOAD_NEW_FILE) {
     // Add the file to the cache if we have uploaded a new file.
     cache_->StoreOnUIThread(resource_id,
                             md5,
                             file_content_path,
                             cache_operation,
                             base::Bind(&OnCacheUpdatedForAddUploadedFile,
-                                       callback));
+                                       callback_runner.Release()));
   } else if (upload_mode == UPLOAD_EXISTING_FILE) {
     // Clear the dirty bit if we have updated an existing file.
     cache_->ClearDirtyOnUIThread(resource_id,
                                  md5,
                                  base::Bind(&OnCacheUpdatedForAddUploadedFile,
-                                            callback));
+                                            callback_runner.Release()));
   } else {
     NOTREACHED() << "Unexpected upload mode: " << upload_mode;
   }
 }
 
 void GDataFileSystem::Observe(int type,
                               const content::NotificationSource& source,
                               const content::NotificationDetails& details) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
@@ skipping 452 matching lines @@
   }
 
   PlatformFileInfoProto entry_file_info;
   GDataEntry::ConvertPlatformFileInfoToProto(*file_info, &entry_file_info);
   *entry_proto->mutable_file_info() = entry_file_info;
   if (!callback.is_null())
     callback.Run(GDATA_FILE_OK, entry_proto.Pass());
 }
 
 }  // namespace gdata