gdata: Remove GDataFileSystem::GetFileFromCacheByResourceIdAndMd5Internal()

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 481 matching lines @@
   if (!callback.is_null())
     callback.Run(*error, resource_id, md5);
 }
 
 // Ditto for GetFileFromCacheCallback.
 void RunGetFileFromCacheCallbackHelper(
     const GetFileFromCacheCallback& callback,
     base::PlatformFileError* error,
     const std::string& resource_id,
     const std::string& md5,
-    const FilePath& gdata_file_path,
     FilePath* cache_file_path) {
   DCHECK(error);
   DCHECK(cache_file_path);
 
   if (!callback.is_null())
-    callback.Run(*error, resource_id, md5, gdata_file_path, *cache_file_path);
+    callback.Run(*error, resource_id, md5, *cache_file_path);
 }
 
 void RunGetCacheStateCallbackHelper(
     const GetCacheStateCallback& callback,
     base::PlatformFileError* error,
     int* cache_state) {
   DCHECK(error);
   DCHECK(cache_state);
 
   if (!callback.is_null())
@@ skipping 1235 matching lines @@
     return;
   }
 
   GetFileByPath(file_path, callback);
 }
 
 void GDataFileSystem::OnGetFileFromCache(const GetFileFromCacheParams& params,
                                          base::PlatformFileError error,
                                          const std::string& resource_id,
                                          const std::string& md5,
-                                         const FilePath& gdata_file_path,
                                          const FilePath& cache_file_path) {
   // Have we found the file in cache? If so, return it back to the caller.
   if (error == base::PLATFORM_FILE_OK) {
     if (!params.callback.is_null()) {
       params.proxy->PostTask(FROM_HERE,
                              base::Bind(params.callback,
                                         error,
                                         cache_file_path,
                                         params.mime_type,
                                         REGULAR_FILE));
@@ skipping 1445 matching lines @@
     DCHECK(sub_dir_type == GDataRootDirectory::CACHE_TYPE_PERSISTENT);
     base_name += FilePath::kExtensionSeparator;
     base_name += kLocallyModifiedFileExtension;
   } else if (!md5.empty()) {
     base_name += FilePath::kExtensionSeparator;
     base_name += GDataEntry::EscapeUtf8FileName(md5);
   }
   return cache_paths_[sub_dir_type].Append(base_name);
 }
 
-void GDataFileSystem::GetFileFromCacheByResourceIdAndMd5(
-    const std::string& resource_id,
-    const std::string& md5,
-    const GetFileFromCacheCallback& callback) {
-  GetFileFromCacheByResourceIdAndMd5Internal(
-      resource_id, md5, FilePath(), callback);
-}
-
 void GDataFileSystem::StoreToCache(const std::string& resource_id,
                                    const std::string& md5,
                                    const FilePath& source_path,
                                    FileOperationType file_operation_type,
                                    const CacheOperationCallback& callback) {
   InitializeCacheIfNecessary();
 
   base::PlatformFileError* error =
       new base::PlatformFileError(base::PLATFORM_FILE_OK);
   PostBlockingPoolSequencedTaskAndReply(
@@ skipping 78 matching lines @@
                  resource_id,
                  md5,
                  FILE_OPERATION_MOVE,
                  error,
                  cache_file_path),
       base::Bind(&RunGetFileFromCacheCallbackHelper,
                  callback,
                  base::Owned(error),
                  resource_id,
                  md5,
-                 FilePath() /* gdata_file_path */,
                  base::Owned(cache_file_path)));
 }
 
 void GDataFileSystem::CommitDirtyInCache(
     const std::string& resource_id,
     const std::string& md5,
     const CacheOperationCallback& callback) {
   InitializeCacheIfNecessary();
 
   base::PlatformFileError* error =
@@ skipping 99 matching lines @@
   // Lock to update cache map.
   base::AutoLock lock(lock_);
   root_->SetCacheMap(cache_map);
 
   NotifyCacheInitialized();
 }
 
 void GDataFileSystem::GetFileFromCacheOnIOThreadPool(
     const std::string& resource_id,
     const std::string& md5,
-    const FilePath& gdata_file_path,
     base::PlatformFileError* error,
     FilePath* cache_file_path) {
   DCHECK(error);
   DCHECK(cache_file_path);
 
   // Lock to access cache map.
   base::AutoLock lock(lock_);
 
   GDataRootDirectory::CacheEntry* entry = root_->GetCacheEntry(resource_id,
                                                                md5);
@@ skipping 757 matching lines @@
       cache_state = GDataFile::SetCachePresent(cache_state);
     }
 
     // Create and insert new entry into cache map.
     GDataRootDirectory::CacheEntry* entry = new GDataRootDirectory::CacheEntry(
         md5, sub_dir_type, cache_state);
     cache_map->insert(std::make_pair(resource_id, entry));
   }
 }
 
-void GDataFileSystem::GetFileFromCacheByResourceIdAndMd5Internal(
+void GDataFileSystem::GetFileFromCacheByResourceIdAndMd5(
     const std::string& resource_id,
     const std::string& md5,
-    const FilePath& gdata_file_path,
     const GetFileFromCacheCallback& callback) {
   InitializeCacheIfNecessary();
 
   base::PlatformFileError* error =
       new base::PlatformFileError(base::PLATFORM_FILE_OK);
   FilePath* cache_file_path = new FilePath;
   PostBlockingPoolSequencedTaskAndReply(
       kGDataFileSystemToken,
       FROM_HERE,
       base::Bind(&GDataFileSystem::GetFileFromCacheOnIOThreadPool,
                  base::Unretained(this),
                  resource_id,
                  md5,
-                 gdata_file_path,
                  error,
                  cache_file_path),
       base::Bind(&RunGetFileFromCacheCallbackHelper,
                  callback,
                  base::Owned(error),
                  resource_id,
                  md5,
-                 gdata_file_path,
                  base::Owned(cache_file_path)));
 }
 
 void GDataFileSystem::RunTaskOnIOThreadPool(const base::Closure& task) {
   task.Run();
 
   {
     base::AutoLock lock(num_pending_tasks_lock_);
     --num_pending_tasks_;
     // Signal when the last task is completed.
@@ skipping 51 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