Remove directory_path argument from chromeos::FindEntryCallback

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 767 matching lines @@
   *error = file_util::CopyFile(src_file_path, dest_file_path) ?
       base::PLATFORM_FILE_OK : base::PLATFORM_FILE_ERROR_FAILED;
 }
 
 // Relays the given FindEntryCallback to another thread via |replay_proxy|.
 void RelayFindEntryCallback(scoped_refptr<base::MessageLoopProxy> relay_proxy,
                             const FindEntryCallback& callback,
                             base::PlatformFileError error,
                             const FilePath& directory_path,
                             GDataEntry* entry) {
-  relay_proxy->PostTask(FROM_HERE,
-                        base::Bind(callback, error, directory_path, entry));
+  relay_proxy->PostTask(FROM_HERE, base::Bind(callback, error, entry));
 }
 
 // Ditto for FileOperationCallback.
 void RelayFileOperationCallback(
     scoped_refptr<base::MessageLoopProxy> relay_proxy,
     const FileOperationCallback& callback,
     base::PlatformFileError error) {
   relay_proxy->PostTask(FROM_HERE, base::Bind(callback, error));
 }
 
@@ skipping 215 matching lines @@
                                  root_->largest_changestamp(),
                                  root_->GetFilePath(),
                                  base::Bind(&GDataFileSystem::OnUpdateChecked,
                                             ui_weak_ptr_,
                                             initial_origin));
   }
 }
 
 void GDataFileSystem::OnUpdateChecked(ContentOrigin initial_origin,
                                       base::PlatformFileError error,
-                                      const FilePath& /* directory_path */,
                                       GDataEntry* /* entry */) {
   if (error != base::PLATFORM_FILE_OK) {
     base::AutoLock lock(lock_);
     root_->set_origin(initial_origin);
   }
 }
 
 bool GDataFileSystem::SetCacheRootPathForTesting(const FilePath& root_path) {
   if (cache_initialization_started_)
     return false;
@@ skipping 74 matching lines @@
     const std::string& resource_id,
     const FindEntryCallback& callback) {
   base::AutoLock lock(lock_);  // To access the cache map.
 
   GDataFile* file = NULL;
   GDataEntry* entry = root_->GetEntryByResourceId(resource_id);
   if (entry)
     file = entry->AsGDataFile();
 
   if (file)
-    callback.Run(base::PLATFORM_FILE_OK, file->parent()->GetFilePath(), file);
+    callback.Run(base::PLATFORM_FILE_OK, file);
   else
-    callback.Run(base::PLATFORM_FILE_ERROR_NOT_FOUND, FilePath(), NULL);
+    callback.Run(base::PLATFORM_FILE_ERROR_NOT_FOUND, NULL);
 }
 
 void GDataFileSystem::FindEntryByPathAsyncOnUIThread(
     const FilePath& search_file_path,
     const FindEntryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   base::AutoLock lock(lock_);
   if (root_->origin() == INITIALIZING) {
     // If root feed is not initialized but the initilization process has
@@ skipping 161 matching lines @@
                                                     feed_list.release(),
                                                     should_fetch_multiple_feeds,
                                                     search_file_path,
                                                     search_query,
                                                     entry_found_callback))));
 }
 
 void GDataFileSystem::OnFeedFromServerLoaded(GetDocumentsParams* params,
                                              base::PlatformFileError error) {
   if (error != base::PLATFORM_FILE_OK) {
-    if (!params->callback.is_null()) {
-      params->callback.Run(error, FilePath(),
-                           reinterpret_cast<GDataEntry*>(NULL));
-    }
+    if (!params->callback.is_null())
+      params->callback.Run(error, NULL);
     return;
   }
 
   error = UpdateFromFeed(*params->feed_list,
                          FROM_SERVER,
                          params->start_changestamp,
                          params->root_feed_changestamp);
 
   if (error != base::PLATFORM_FILE_OK) {
-    if (!params->callback.is_null()) {
-      params->callback.Run(error, FilePath(),
-                           reinterpret_cast<GDataEntry*>(NULL));
-    }
+    if (!params->callback.is_null())
+      params->callback.Run(error, NULL);
 
     return;
   }
 
   // Save file system metadata to disk.
   SaveFileSystemAsProto();
 
   // If we had someone to report this too, then this retrieval was done in a
   // context of search... so continue search.
   if (!params->callback.is_null()) {
@@ skipping 1057 matching lines @@
 
   FindEntryByPathAsyncOnUIThread(
       file_path,
       base::Bind(&GDataFileSystem::OnGetEntryInfo,
                  ui_weak_ptr_,
                  callback));
 }
 
 void GDataFileSystem::OnGetEntryInfo(const GetEntryInfoCallback& callback,
                                     base::PlatformFileError error,
-                                    const FilePath& directory_path,
                                     GDataEntry* entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (error != base::PLATFORM_FILE_OK) {
     if (!callback.is_null())
       callback.Run(error, FilePath(), scoped_ptr<GDataEntryProto>());
     return;
   }
   DCHECK(entry);
 
@@ skipping 27 matching lines @@
   GetFileInfoByPathAsyncOnUIThread(file_path, callback);
 }
 
 void GDataFileSystem::GetFileInfoByPathAsyncOnUIThread(
     const FilePath& file_path,
     const GetFileInfoCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   FindEntryByPathAsyncOnUIThread(
       file_path,
-      base::Bind(&GDataFileSystem::OnGetFileInfo,
-                 ui_weak_ptr_,
-                 callback));
+      base::Bind(&GDataFileSystem::OnGetFileInfo, ui_weak_ptr_, callback));
 }
 
 void GDataFileSystem::OnGetFileInfo(const GetFileInfoCallback& callback,
                                     base::PlatformFileError error,
-                                    const FilePath& directory_path,
                                     GDataEntry* entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (error != base::PLATFORM_FILE_OK) {
     if (!callback.is_null())
       callback.Run(error, scoped_ptr<GDataFileProto>());
     return;
   }
   DCHECK(entry);
 
@@ skipping 40 matching lines @@
 
   FindEntryByPathAsyncOnUIThread(
       file_path,
       base::Bind(&GDataFileSystem::OnReadDirectory,
                  ui_weak_ptr_,
                  callback));
 }
 
 void GDataFileSystem::OnReadDirectory(const ReadDirectoryCallback& callback,
                                       base::PlatformFileError error,
-                                      const FilePath& directory_path,
                                       GDataEntry* entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (error != base::PLATFORM_FILE_OK) {
     if (!callback.is_null())
       callback.Run(error, scoped_ptr<GDataDirectoryProto>());
     return;
   }
   DCHECK(entry);
 
@@ skipping 2587 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