chromeos: Return error from DriveResourceMetadata when there is no sufficient disk space

chrome/browser/chromeos/drive/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/drive_resource_metadata.h"
 
 #include "base/file_util.h"
 #include "base/stringprintf.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/sys_info.h"
 #include "chrome/browser/chromeos/drive/drive.pb.h"
 #include "chrome/browser/chromeos/drive/drive_file_system_util.h"
 #include "chrome/browser/chromeos/drive/drive_resource_metadata_storage.h"
 #include "content/public/browser/browser_thread.h"
 
 using content::BrowserThread;
 
 namespace drive {
 namespace {
 
@@ skipping 15 matching lines @@
 }
 
 // Runs |callback| with |result|. Used to implement GetChildDirectories().
 void RunGetChildDirectoriesCallbackWithResult(
     const GetChildDirectoriesCallback& callback,
     scoped_ptr<std::set<base::FilePath> > result) {
   DCHECK(!callback.is_null());
   callback.Run(*result);
 }
 
+// Returns true if enough disk space is avilable for DB operation.
+// TODO(hashimoto): Merge this with DriveCache's FreeDiskSpaceGetterInterface.
+bool EnoughDiskSpaceIsAvailableForDBOperation(const base::FilePath& path) {
+  const int64 kRequiredDiskSpaceInMB = 128;  // 128 MB seems to be large enough.
+  return base::SysInfo::AmountOfFreeDiskSpace(path) >=
+      kRequiredDiskSpaceInMB * (1 << 20);
+}
+
 }  // namespace
 
 std::string DirectoryFetchInfo::ToString() const {
   return ("resource_id: " + resource_id_ +
           ", changestamp: " + base::Int64ToString(changestamp_));
 }
 
 EntryInfoResult::EntryInfoResult() : error(DRIVE_FILE_ERROR_FAILED) {
 }
 
@@ skipping 139 matching lines @@
       callback);
 }
 
 DriveResourceMetadata::~DriveResourceMetadata() {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
 }
 
 DriveFileError DriveResourceMetadata::InitializeOnBlockingPool() {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
 
+  if (!EnoughDiskSpaceIsAvailableForDBOperation(data_directory_path_))
+    return DRIVE_FILE_ERROR_NO_SPACE;
+
   // Initialize the storage.
   if (!storage_->Initialize())
     return DRIVE_FILE_ERROR_FAILED;
 
   SetUpDefaultEntries();
 
   return DRIVE_FILE_OK;
 }
 
 void DriveResourceMetadata::SetUpDefaultEntries() {
@@ skipping 14 matching lines @@
 }
 
 void DriveResourceMetadata::DestroyOnBlockingPool() {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
   delete this;
 }
 
 void DriveResourceMetadata::ResetOnBlockingPool() {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
 
+  // TODO(hashimoto): Return DRIVE_FILE_ERROR_NO_SPACE here.
+  if (!EnoughDiskSpaceIsAvailableForDBOperation(data_directory_path_)) {
+    LOG(ERROR) << "Required disk space not available.";
+    return;
+  }
+
   RemoveAllOnBlockingPool();
   storage_->SetLargestChangestamp(0);
 }
 
 void DriveResourceMetadata::GetLargestChangestamp(
     const GetChangestampCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_,
@@ skipping 196 matching lines @@
 }
 
 int64 DriveResourceMetadata::GetLargestChangestampOnBlockingPool() {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
   return storage_->GetLargestChangestamp();
 }
 
 DriveFileError DriveResourceMetadata::SetLargestChangestampOnBlockingPool(
     int64 value) {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
+
+  if (!EnoughDiskSpaceIsAvailableForDBOperation(data_directory_path_))
+    return DRIVE_FILE_ERROR_NO_SPACE;
+
   storage_->SetLargestChangestamp(value);
   return DRIVE_FILE_OK;
 }
 
 DriveResourceMetadata::FileMoveResult
 DriveResourceMetadata::MoveEntryToDirectoryOnBlockingPool(
     const base::FilePath& file_path,
     const base::FilePath& directory_path) {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(!directory_path.empty());
   DCHECK(!file_path.empty());
 
+  if (!EnoughDiskSpaceIsAvailableForDBOperation(data_directory_path_))
+    return FileMoveResult(DRIVE_FILE_ERROR_NO_SPACE);
+
   scoped_ptr<DriveEntryProto> entry = FindEntryByPathSync(file_path);
   if (!entry)
     return FileMoveResult(DRIVE_FILE_ERROR_NOT_FOUND);
 
   // Cannot move an entry without its parent. (i.e. the root)
   if (entry->parent_resource_id().empty())
     return FileMoveResult(DRIVE_FILE_ERROR_INVALID_OPERATION);
 
   scoped_ptr<DriveEntryProto> destination = FindEntryByPathSync(directory_path);
   base::FilePath moved_file_path;
@@ skipping 15 matching lines @@
 
 DriveResourceMetadata::FileMoveResult
 DriveResourceMetadata::RenameEntryOnBlockingPool(
     const base::FilePath& file_path,
     const std::string& new_name) {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(!file_path.empty());
   DCHECK(!new_name.empty());
 
   DVLOG(1) << "RenameEntry " << file_path.value() << " to " << new_name;
+
+  if (!EnoughDiskSpaceIsAvailableForDBOperation(data_directory_path_))
+    return FileMoveResult(DRIVE_FILE_ERROR_NO_SPACE);
+
   scoped_ptr<DriveEntryProto> entry = FindEntryByPathSync(file_path);
   if (!entry)
     return FileMoveResult(DRIVE_FILE_ERROR_NOT_FOUND);
 
   if (base::FilePath::FromUTF8Unsafe(new_name) == file_path.BaseName())
     return FileMoveResult(DRIVE_FILE_ERROR_EXISTS);
 
   entry->set_title(new_name);
   scoped_ptr<GetEntryInfoWithFilePathResult> result =
       RefreshEntryOnBlockingPool(*entry);
   return FileMoveResult(result->error, result->path);
 }
 
 DriveResourceMetadata::FileMoveResult
 DriveResourceMetadata::RemoveEntryOnBlockingPool(
     const std::string& resource_id) {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
 
+  if (!EnoughDiskSpaceIsAvailableForDBOperation(data_directory_path_))
+    return FileMoveResult(DRIVE_FILE_ERROR_NO_SPACE);
+
   // Disallow deletion of special entries "/drive" and "/drive/other".
   if (util::IsSpecialResourceId(resource_id))
     return FileMoveResult(DRIVE_FILE_ERROR_ACCESS_DENIED);
 
   scoped_ptr<DriveEntryProto> entry = storage_->GetEntry(resource_id);
   if (!entry)
     return FileMoveResult(DRIVE_FILE_ERROR_NOT_FOUND);
 
   RemoveDirectoryChild(entry->resource_id());
   return FileMoveResult(DRIVE_FILE_OK,
@@ skipping 99 matching lines @@
                  first_path,
                  second_path,
                  callback));
 }
 
 scoped_ptr<DriveResourceMetadata::GetEntryInfoWithFilePathResult>
 DriveResourceMetadata::RefreshEntryOnBlockingPool(
     const DriveEntryProto& entry_proto) {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
 
+  if (!EnoughDiskSpaceIsAvailableForDBOperation(data_directory_path_)) {
+    return make_scoped_ptr(
+        new GetEntryInfoWithFilePathResult(DRIVE_FILE_ERROR_NO_SPACE));
+  }
+
   scoped_ptr<DriveEntryProto> entry =
       storage_->GetEntry(entry_proto.resource_id());
   if (!entry) {
     return make_scoped_ptr(
         new GetEntryInfoWithFilePathResult(DRIVE_FILE_ERROR_NOT_FOUND));
   }
 
   if (entry->parent_resource_id().empty() ||  // Rejct root.
       entry->file_info().is_directory() !=  // Reject incompatible input.
       entry_proto.file_info().is_directory()) {
@@ skipping 23 matching lines @@
                                          result_entry_proto.Pass()));
 }
 
 DriveResourceMetadata::FileMoveResult
 DriveResourceMetadata::RefreshDirectoryOnBlockingPool(
     const DirectoryFetchInfo& directory_fetch_info,
     const DriveEntryProtoMap& entry_proto_map) {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(!directory_fetch_info.empty());
 
+  if (!EnoughDiskSpaceIsAvailableForDBOperation(data_directory_path_))
+    return FileMoveResult(DRIVE_FILE_ERROR_NO_SPACE);
+
   scoped_ptr<DriveEntryProto> directory = storage_->GetEntry(
       directory_fetch_info.resource_id());
 
   if (!directory)
     return FileMoveResult(DRIVE_FILE_ERROR_NOT_FOUND);
 
   if (!directory->file_info().is_directory())
     return FileMoveResult(DRIVE_FILE_ERROR_NOT_A_DIRECTORY);
 
   directory->mutable_directory_specific_info()->set_changestamp(
       directory_fetch_info.changestamp());
   storage_->PutEntry(*directory);
 
   // First, go through the entry map. We'll handle existing entries and new
   // entries in the loop. We'll process deleted entries afterwards.
   for (DriveEntryProtoMap::const_iterator it = entry_proto_map.begin();
        it != entry_proto_map.end(); ++it) {
+    if (!EnoughDiskSpaceIsAvailableForDBOperation(data_directory_path_))
+      return FileMoveResult(DRIVE_FILE_ERROR_NO_SPACE);
+
     const DriveEntryProto& entry_proto = it->second;
     // Skip if the parent resource ID does not match. This is needed to
     // handle entries with multiple parents. For such entries, the first
     // parent is picked and other parents are ignored, hence some entries may
     // have a parent resource ID which does not match the target directory's.
     //
     // TODO(satorux): Move the filtering logic to somewhere more appropriate.
     // crbug.com/193525.
     if (entry_proto.parent_resource_id() !=
         directory_fetch_info.resource_id()) {
       DVLOG(1) << "Wrong-parent entry rejected: " << entry_proto.resource_id();
       continue;
     }
 
     scoped_ptr<DriveEntryProto> existing_entry =
         storage_->GetEntry(entry_proto.resource_id());
     if (existing_entry)
       DetachEntryFromDirectory(entry_proto.resource_id());
 
     AddEntryToDirectory(CreateEntryWithProperBaseName(entry_proto));
   }
 
   // Go through the existing entries and remove deleted entries.
   scoped_ptr<DriveEntryProtoVector> entries =
       DirectoryChildrenToProtoVector(directory->resource_id());
   for (size_t i = 0; i < entries->size(); ++i) {
+    if (!EnoughDiskSpaceIsAvailableForDBOperation(data_directory_path_))
+      return FileMoveResult(DRIVE_FILE_ERROR_NO_SPACE);
+
     const DriveEntryProto& entry_proto = entries->at(i);
     if (entry_proto_map.count(entry_proto.resource_id()) == 0)
       RemoveDirectoryChild(entry_proto.resource_id());
   }
 
   return FileMoveResult(DRIVE_FILE_OK, GetFilePath(directory->resource_id()));
 }
 
 DriveResourceMetadata::FileMoveResult
 DriveResourceMetadata::AddEntryOnBlockingPool(
     const DriveEntryProto& entry_proto) {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
 
+  if (!EnoughDiskSpaceIsAvailableForDBOperation(data_directory_path_))
+    return FileMoveResult(DRIVE_FILE_ERROR_NO_SPACE);
+
   scoped_ptr<DriveEntryProto> existing_entry =
       storage_->GetEntry(entry_proto.resource_id());
   if (existing_entry)
     return FileMoveResult(DRIVE_FILE_ERROR_EXISTS);
 
   scoped_ptr<DriveEntryProto> parent =
       GetDirectory(entry_proto.parent_resource_id());
   if (!parent)
     return FileMoveResult(DRIVE_FILE_ERROR_NOT_FOUND);
 
@@ skipping 51 matching lines @@
     if (entry->file_info().is_directory()) {
       child_directories->insert(GetFilePath(entry->resource_id()));
       GetDescendantDirectoryPaths(entry->resource_id(), child_directories);
     }
   }
 }
 
 void DriveResourceMetadata::RemoveAllOnBlockingPool() {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
 
+  // TODO(hashimoto): Return DRIVE_FILE_ERROR_NO_SPACE here.
+  if (!EnoughDiskSpaceIsAvailableForDBOperation(data_directory_path_)) {
+    LOG(ERROR) << "Required disk space not available.";
+    return;
+  }
+
   RemoveDirectoryChildren(util::kDriveGrandRootSpecialResourceId);
   SetUpDefaultEntries();
 }
 
 void DriveResourceMetadata::IterateEntriesOnBlockingPool(
     const IterateCallback& callback) {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(!callback.is_null());
 
   storage_->Iterate(callback);
@@ skipping 126 matching lines @@
   storage_->GetChildren(directory_resource_id, &children);
   for (size_t i = 0; i < children.size(); ++i) {
     scoped_ptr<DriveEntryProto> child = storage_->GetEntry(children[i]);
     DCHECK(child);
     entries->push_back(*child);
   }
   return entries.Pass();
 }
 
 }  // namespace drive