drive: Change FileCache::GetCacheEntry's return type to FileError

chrome/browser/chromeos/drive/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/drive/file_system.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/platform_file.h"
 #include "base/prefs/pref_service.h"
@@ skipping 46 matching lines @@
     return error;
 
   // For entries that will never be cached, use the original resource entry
   // as is.
   if (!entry->has_file_specific_info() ||
       entry->file_specific_info().is_hosted_document())
     return FILE_ERROR_OK;
 
   // When cache is not found, use the original resource entry as is.
   FileCacheEntry cache_entry;
-  if (!cache->GetCacheEntry(local_id, &cache_entry))
+  error = cache->GetCacheEntry(local_id, &cache_entry);
+  if (error == FILE_ERROR_NOT_FOUND)
     return FILE_ERROR_OK;
+  if (error != FILE_ERROR_OK)
+    return error;
 
   // When cache is non-dirty and obsolete (old hash), use the original entry.
   if (!cache_entry.is_dirty() &&
       entry->file_specific_info().md5() != cache_entry.md5())
     return FILE_ERROR_OK;
 
   // If there's a valid cache, obtain the file info from the cache file itself.
   base::FilePath local_cache_path;
   error = cache->GetFile(local_id, &local_cache_path);
   if (error != FILE_ERROR_OK)
@@ skipping 69 matching lines @@
 
 // Runs the callback with arguments.
 void RunMarkMountedCallback(const MarkMountedCallback& callback,
                             base::FilePath* cache_file_path,
                             FileError error) {
   DCHECK(!callback.is_null());
   callback.Run(error, *cache_file_path);
 }
 
 // Used to implement GetCacheEntry.
-bool GetCacheEntryInternal(internal::ResourceMetadata* resource_metadata,
-                                 internal::FileCache* cache,
-                                 const base::FilePath& drive_file_path,
-                                 FileCacheEntry* cache_entry) {
+FileError GetCacheEntryInternal(internal::ResourceMetadata* resource_metadata,
+                                internal::FileCache* cache,
+                                const base::FilePath& drive_file_path,
+                                FileCacheEntry* cache_entry) {
   std::string id;
-  if (resource_metadata->GetIdByPath(drive_file_path, &id) != FILE_ERROR_OK)
-    return false;
+  FileError error = resource_metadata->GetIdByPath(drive_file_path, &id);
+  if (error != FILE_ERROR_OK)
+    return error;
 
   return cache->GetCacheEntry(id, cache_entry);
 }
 
 // Runs the callback with arguments.
 void RunGetCacheEntryCallback(const GetCacheEntryCallback& callback,
                               const FileCacheEntry* cache_entry,
-                              bool success) {
+                              FileError error) {
   DCHECK(!callback.is_null());
-  callback.Run(success, *cache_entry);
+  callback.Run(error, *cache_entry);
 }
 
 // Callback for ResourceMetadata::GetLargestChangestamp.
 // |callback| must not be null.
 void OnGetLargestChangestamp(
     FileSystemMetadata metadata,  // Will be modified.
     const GetFilesystemMetadataCallback& callback,
     int64 largest_changestamp) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
@@ skipping 824 matching lines @@
       FROM_HERE,
       base::Bind(&GetPathFromResourceIdOnBlockingPool,
                  resource_metadata_,
                  resource_id,
                  file_path),
       base::Bind(&GetPathFromResourceIdAfterGetPath,
                  base::Owned(file_path),
                  callback));
 }
 }  // namespace drive