drive: Change the return type of ResourceMetadata's methods to FileError

chrome/browser/chromeos/drive/resource_metadata.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/resource_metadata.h"
 
 #include "base/guid.h"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
@@ skipping 180 matching lines @@
     return error;
   }
   return FILE_ERROR_OK;
 }
 
 void ResourceMetadata::DestroyOnBlockingPool() {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
   delete this;
 }
 
-int64 ResourceMetadata::GetLargestChangestamp() {
+FileError ResourceMetadata::GetLargestChangestamp(int64* out_value) {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
-  int64 value = 0;
-  storage_->GetLargestChangestamp(&value);
-  return value;
+  return storage_->GetLargestChangestamp(out_value);
 }
 
 FileError ResourceMetadata::SetLargestChangestamp(int64 value) {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
 
   if (!EnoughDiskSpaceIsAvailableForDBOperation(storage_->directory_path()))
     return FILE_ERROR_NO_LOCAL_SPACE;
 
   return storage_->SetLargestChangestamp(value);
 }
@@ skipping 167 matching lines @@
   if (error != FILE_ERROR_OK)
     return error;
 
   if (!new_parent.file_info().is_directory())
     return FILE_ERROR_NOT_A_DIRECTORY;
 
   // Remove from the old parent and add it to the new parent with the new data.
   return PutEntryUnderDirectory(entry);
 }
 
-void ResourceMetadata::GetSubDirectoriesRecursively(
+FileError ResourceMetadata::GetSubDirectoriesRecursively(
     const std::string& id,
     std::set<base::FilePath>* sub_directories) {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
 
   std::vector<std::string> children;
-  if (storage_->GetChildren(id, &children) != FILE_ERROR_OK)
-    return;
+  FileError error = storage_->GetChildren(id, &children);
+  if (error != FILE_ERROR_OK)
+    return error;
   for (size_t i = 0; i < children.size(); ++i) {
     ResourceEntry entry;
-    if (storage_->GetEntry(children[i], &entry) != FILE_ERROR_OK)
-      return;
+    error = storage_->GetEntry(children[i], &entry);
+    if (error != FILE_ERROR_OK)
+      return error;
     if (entry.file_info().is_directory()) {
-      sub_directories->insert(GetFilePath(children[i]));
+      base::FilePath path;
+      error = GetFilePath(children[i], &path);
+      if (error != FILE_ERROR_OK)
+        return error;
+      sub_directories->insert(path);
       GetSubDirectoriesRecursively(children[i], sub_directories);
     }
   }
+  return FILE_ERROR_OK;
 }
 
-std::string ResourceMetadata::GetChildId(const std::string& parent_local_id,
-                                         const std::string& base_name) {
+FileError ResourceMetadata::GetChildId(const std::string& parent_local_id,
+                                       const std::string& base_name,
+                                       std::string* out_child_id) {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
-  std::string child_local_id;
-  storage_->GetChild(parent_local_id, base_name, &child_local_id);
-  return child_local_id;
+  return storage_->GetChild(parent_local_id, base_name, out_child_id);
 }
 
 scoped_ptr<ResourceMetadata::Iterator> ResourceMetadata::GetIterator() {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
 
   return storage_->GetIterator();
 }
 
-base::FilePath ResourceMetadata::GetFilePath(const std::string& id) {
+FileError ResourceMetadata::GetFilePath(const std::string& id,
+                                        base::FilePath* out_file_path) {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
 
+  ResourceEntry entry;
+  FileError error = storage_->GetEntry(id, &entry);
+  if (error != FILE_ERROR_OK)
+    return error;
+
   base::FilePath path;
-  ResourceEntry entry;
-  if (storage_->GetEntry(id, &entry) == FILE_ERROR_OK) {
-    if (!entry.parent_local_id().empty()) {
-      path = GetFilePath(entry.parent_local_id());
-    } else if (entry.local_id() != util::kDriveGrandRootLocalId) {
-      DVLOG(1) << "Entries not under the grand root don't have paths.";
-      return base::FilePath();
-    }
-    path = path.Append(base::FilePath::FromUTF8Unsafe(entry.base_name()));
+  if (!entry.parent_local_id().empty()) {
+    error = GetFilePath(entry.parent_local_id(), &path);
+    if (error != FILE_ERROR_OK)
+      return error;
+  } else if (entry.local_id() != util::kDriveGrandRootLocalId) {
+    DVLOG(1) << "Entries not under the grand root don't have paths.";
+    return FILE_ERROR_NOT_FOUND;
   }
-  return path;
+  path = path.Append(base::FilePath::FromUTF8Unsafe(entry.base_name()));
+  *out_file_path = path;
+  return FILE_ERROR_OK;
 }
 
 FileError ResourceMetadata::GetIdByPath(const base::FilePath& file_path,
                                         std::string* out_id) {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
 
   // Start from the root.
   std::vector<base::FilePath::StringType> components;
   file_path.GetComponents(&components);
   if (components.empty() || components[0] != util::kDriveGrandRootDirName)
@@ skipping 101 matching lines @@
 FileError ResourceMetadata::RemoveEntryRecursively(const std::string& id) {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
 
   ResourceEntry entry;
   FileError error = storage_->GetEntry(id, &entry);
   if (error != FILE_ERROR_OK)
     return error;
 
   if (entry.file_info().is_directory()) {
     std::vector<std::string> children;
-    storage_->GetChildren(id, &children);
+    error = storage_->GetChildren(id, &children);
+    if (error != FILE_ERROR_OK)
+      return error;
     for (size_t i = 0; i < children.size(); ++i) {
       error = RemoveEntryRecursively(children[i]);
       if (error != FILE_ERROR_OK)
         return error;
     }
   }
   return storage_->RemoveEntry(id);
 }
 
 }  // namespace internal
 }  // namespace drive