drive: Stop checking free disk space in ResourceMetadata::Initialize

chrome/browser/chromeos/drive/resource_metadata_storage.cc

 // Copyright 2013 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_storage.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/sequenced_task_runner.h"
 #include "base/threading/thread_restrictions.h"
 #include "chrome/browser/chromeos/drive/drive.pb.h"
+#include "third_party/leveldatabase/env_chromium.h"
 #include "third_party/leveldatabase/src/include/leveldb/db.h"
 #include "third_party/leveldatabase/src/include/leveldb/write_batch.h"
 
 namespace drive {
 namespace internal {
 
 namespace {
 
 // Enum to describe DB initialization status.
 enum DBInitStatus {
@@ skipping 93 matching lines @@
                                        arraysize(kIdEntryKeyPrefix) - 1);
   if (key.size() < 2 + expected_prefix.size())
     return false;
   const leveldb::Slice key_substring(key.data() + 1, expected_prefix.size());
   return key[0] == kDBKeyDelimeter &&
       key_substring.compare(expected_prefix) == 0 &&
       key[expected_prefix.size() + 1] == kDBKeyDelimeter;
 }
 
 // Converts leveldb::Status to DBInitStatus.
-DBInitStatus LevelDBStatusToDBInitStatus(const leveldb::Status status) {
+DBInitStatus LevelDBStatusToDBInitStatus(const leveldb::Status& status) {
   if (status.ok())
     return DB_INIT_SUCCESS;
   if (status.IsNotFound())
     return DB_INIT_NOT_FOUND;
   if (status.IsCorruption())
     return DB_INIT_CORRUPTION;
   if (status.IsIOError())
     return DB_INIT_IO_ERROR;
   return DB_INIT_FAILED;
 }
 
+// Converts leveldb::Status to FileError.
+FileError LevelDBStatusToFileError(const leveldb::Status& status) {
+  if (status.ok())
+    return FILE_ERROR_OK;
+  if (status.IsNotFound())
+    return FILE_ERROR_NOT_FOUND;
+  if (leveldb_env::IndicatesDiskFull(status))
+    return FILE_ERROR_NO_LOCAL_SPACE;
+  return FILE_ERROR_FAILED;
+}
+
 ResourceMetadataHeader GetDefaultHeaderEntry() {
   ResourceMetadataHeader header;
   header.set_version(ResourceMetadataStorage::kDBVersion);
   return header;
 }
 
 bool MoveIfPossible(const base::FilePath& from, const base::FilePath& to) {
   return !base::PathExists(from) || base::Move(from, to);
 }
 
@@ skipping 281 matching lines @@
     status = leveldb::DB::Open(options, resource_map_path.AsUTF8Unsafe(), &db);
     open_existing_result = LevelDBStatusToDBInitStatus(status);
   }
 
   if (open_existing_result == DB_INIT_SUCCESS) {
     resource_map_.reset(db);
 
     // Check the validity of existing DB.
     int db_version = -1;
     ResourceMetadataHeader header;
-    if (GetHeader(&header))
+    if (GetHeader(&header) == FILE_ERROR_OK)
       db_version = header.version();
 
     bool should_discard_db = true;
     if (db_version != kDBVersion) {
       open_existing_result = DB_INIT_INCOMPATIBLE;
       DVLOG(1) << "Reject incompatible DB.";
     } else if (!CheckValidity()) {
       open_existing_result = DB_INIT_BROKEN;
       LOG(ERROR) << "Reject invalid DB.";
     } else {
@@ skipping 21 matching lines @@
 
     // Create DB.
     options.max_open_files = 0;  // Use minimum.
     options.create_if_missing = true;
     options.error_if_exists = true;
 
     status = leveldb::DB::Open(options, resource_map_path.AsUTF8Unsafe(), &db);
     if (status.ok()) {
       resource_map_.reset(db);
 
-      if (PutHeader(GetDefaultHeaderEntry()) &&  // Set up header.
-          MoveIfPossible(preserved_resource_map_path,  // Trash the old DB.
+      // Set up header and trash the old DB.
+      if (PutHeader(GetDefaultHeaderEntry()) == FILE_ERROR_OK &&
+          MoveIfPossible(preserved_resource_map_path,
                          trashed_resource_map_path)) {
         init_result = open_existing_result == DB_INIT_NOT_FOUND ?
             DB_INIT_CREATED_NEW_DB : DB_INIT_REPLACED_EXISTING_DB_WITH_NEW_DB;
       } else {
         init_result = DB_INIT_FAILED;
         resource_map_.reset();
       }
     } else {
       LOG(ERROR) << "Failed to create resource map DB: " << status.ToString();
       init_result = LevelDBStatusToDBInitStatus(status);
@@ skipping 66 matching lines @@
         if (resource_map->Get(leveldb::ReadOptions(),
                               leveldb::Slice(id),
                               &serialized_entry).ok() &&
             entry.ParseFromString(serialized_entry))
           info->title = entry.title();
       }
     }
   }
 }
 
-bool ResourceMetadataStorage::SetLargestChangestamp(
+FileError ResourceMetadataStorage::SetLargestChangestamp(
     int64 largest_changestamp) {
   base::ThreadRestrictions::AssertIOAllowed();
 
   ResourceMetadataHeader header;
-  if (!GetHeader(&header)) {
+  FileError error = GetHeader(&header);
+  if (error != FILE_ERROR_OK) {
     DLOG(ERROR) << "Failed to get the header.";
-    return false;
+    return error;
   }
   header.set_largest_changestamp(largest_changestamp);
   return PutHeader(header);
 }
 
-int64 ResourceMetadataStorage::GetLargestChangestamp() {
+FileError ResourceMetadataStorage::GetLargestChangestamp(
+    int64* largest_changestamp) {
   base::ThreadRestrictions::AssertIOAllowed();
   ResourceMetadataHeader header;
-  if (!GetHeader(&header)) {
+  FileError error = GetHeader(&header);
+  if (error != FILE_ERROR_OK) {
     DLOG(ERROR) << "Failed to get the header.";
-    return 0;
+    return error;
   }
-  return header.largest_changestamp();
+  *largest_changestamp = header.largest_changestamp();
+  return FILE_ERROR_OK;
 }
 
-bool ResourceMetadataStorage::PutEntry(const ResourceEntry& entry) {
+FileError ResourceMetadataStorage::PutEntry(const ResourceEntry& entry) {
   base::ThreadRestrictions::AssertIOAllowed();
 
   const std::string& id = entry.local_id();
   DCHECK(!id.empty());
 
   // Try to get existing entry.
   std::string serialized_entry;
   leveldb::Status status = resource_map_->Get(leveldb::ReadOptions(),
                                               leveldb::Slice(id),
                                               &serialized_entry);
   if (!status.ok() && !status.IsNotFound())  // Unexpected errors.
-    return false;
+    return LevelDBStatusToFileError(status);
 
   ResourceEntry old_entry;
   if (status.ok() && !old_entry.ParseFromString(serialized_entry))
-    return false;
+    return FILE_ERROR_FAILED;
 
   // Construct write batch.
   leveldb::WriteBatch batch;
 
   // Remove from the old parent.
   if (!old_entry.parent_local_id().empty()) {
     batch.Delete(GetChildEntryKey(old_entry.parent_local_id(),
                                   old_entry.base_name()));
   }
   // Add to the new parent.
   if (!entry.parent_local_id().empty())
     batch.Put(GetChildEntryKey(entry.parent_local_id(), entry.base_name()), id);
 
   // Refresh resource-ID-to-local-ID mapping entry.
   if (old_entry.resource_id() != entry.resource_id()) {
     // Resource ID should not change.
     DCHECK(old_entry.resource_id().empty() || entry.resource_id().empty());
 
     if (!old_entry.resource_id().empty())
       batch.Delete(GetIdEntryKey(old_entry.resource_id()));
     if (!entry.resource_id().empty())
       batch.Put(GetIdEntryKey(entry.resource_id()), id);
   }
 
   // Put the entry itself.
   if (!entry.SerializeToString(&serialized_entry)) {
     DLOG(ERROR) << "Failed to serialize the entry: " << id;
-    return false;
+    return FILE_ERROR_FAILED;
   }
   batch.Put(id, serialized_entry);
 
   status = resource_map_->Write(leveldb::WriteOptions(), &batch);
-  return status.ok();
+  return LevelDBStatusToFileError(status);
 }
 
-bool ResourceMetadataStorage::GetEntry(const std::string& id,
-                                       ResourceEntry* out_entry) {
+FileError ResourceMetadataStorage::GetEntry(const std::string& id,
+                                            ResourceEntry* out_entry) {
   base::ThreadRestrictions::AssertIOAllowed();
   DCHECK(!id.empty());
 
   std::string serialized_entry;
   const leveldb::Status status = resource_map_->Get(leveldb::ReadOptions(),
                                                     leveldb::Slice(id),
                                                     &serialized_entry);
-  return status.ok() && out_entry->ParseFromString(serialized_entry);
+  if (!status.ok())
+    return LevelDBStatusToFileError(status);
+  return out_entry->ParseFromString(serialized_entry) ?
+      FILE_ERROR_OK : FILE_ERROR_FAILED;
 }
 
-bool ResourceMetadataStorage::RemoveEntry(const std::string& id) {
+FileError ResourceMetadataStorage::RemoveEntry(const std::string& id) {
   base::ThreadRestrictions::AssertIOAllowed();
   DCHECK(!id.empty());
 
   ResourceEntry entry;
-  if (!GetEntry(id, &entry))
-    return false;
+  FileError error = GetEntry(id, &entry);
+  if (error != FILE_ERROR_OK)
+    return error;
 
   leveldb::WriteBatch batch;
 
   // Remove from the parent.
   if (!entry.parent_local_id().empty())
     batch.Delete(GetChildEntryKey(entry.parent_local_id(), entry.base_name()));
 
   // Remove resource ID-local ID mapping entry.
   if (!entry.resource_id().empty())
     batch.Delete(GetIdEntryKey(entry.resource_id()));
 
   // Remove the entry itself.
   batch.Delete(id);
 
   const leveldb::Status status = resource_map_->Write(leveldb::WriteOptions(),
                                                       &batch);
-  return status.ok();
+  return LevelDBStatusToFileError(status);
 }
 
 scoped_ptr<ResourceMetadataStorage::Iterator>
 ResourceMetadataStorage::GetIterator() {
   base::ThreadRestrictions::AssertIOAllowed();
 
   scoped_ptr<leveldb::Iterator> it(
       resource_map_->NewIterator(leveldb::ReadOptions()));
   return make_scoped_ptr(new Iterator(it.Pass()));
 }
 
-std::string ResourceMetadataStorage::GetChild(const std::string& parent_id,
-                                              const std::string& child_name) {
+FileError ResourceMetadataStorage::GetChild(const std::string& parent_id,
+                                            const std::string& child_name,
+                                            std::string* child_id) {
   base::ThreadRestrictions::AssertIOAllowed();
   DCHECK(!parent_id.empty());
   DCHECK(!child_name.empty());
 
-  std::string child_id;
-  resource_map_->Get(leveldb::ReadOptions(),
-                     leveldb::Slice(GetChildEntryKey(parent_id, child_name)),
-                     &child_id);
-  return child_id;
+  const leveldb::Status status =
+      resource_map_->Get(
+          leveldb::ReadOptions(),
+          leveldb::Slice(GetChildEntryKey(parent_id, child_name)),
+          child_id);
+  return LevelDBStatusToFileError(status);
 }
 
-void ResourceMetadataStorage::GetChildren(const std::string& parent_id,
-                                          std::vector<std::string>* children) {
+FileError ResourceMetadataStorage::GetChildren(
+    const std::string& parent_id,
+    std::vector<std::string>* children) {
   base::ThreadRestrictions::AssertIOAllowed();
   DCHECK(!parent_id.empty());
 
   // Iterate over all entries with keys starting with |parent_id|.
   scoped_ptr<leveldb::Iterator> it(
       resource_map_->NewIterator(leveldb::ReadOptions()));
   for (it->Seek(parent_id);
        it->Valid() && it->key().starts_with(leveldb::Slice(parent_id));
        it->Next()) {
     if (IsChildEntryKey(it->key()))
       children->push_back(it->value().ToString());
   }
-  DCHECK(it->status().ok());
+  return LevelDBStatusToFileError(it->status());
 }
 
-bool ResourceMetadataStorage::PutCacheEntry(const std::string& id,
-                                            const FileCacheEntry& entry) {
+FileError ResourceMetadataStorage::PutCacheEntry(const std::string& id,
+                                                 const FileCacheEntry& entry) {
   base::ThreadRestrictions::AssertIOAllowed();
   DCHECK(!id.empty());
 
   std::string serialized_entry;
   if (!entry.SerializeToString(&serialized_entry)) {
     DLOG(ERROR) << "Failed to serialize the entry.";
-    return false;
+    return FILE_ERROR_FAILED;
   }
 
   const leveldb::Status status = resource_map_->Put(
       leveldb::WriteOptions(),
       leveldb::Slice(GetCacheEntryKey(id)),
       leveldb::Slice(serialized_entry));
-  return status.ok();
+  return LevelDBStatusToFileError(status);
 }
 
-bool ResourceMetadataStorage::GetCacheEntry(const std::string& id,
-                                            FileCacheEntry* out_entry) {
+FileError ResourceMetadataStorage::GetCacheEntry(const std::string& id,
+                                                 FileCacheEntry* out_entry) {
   base::ThreadRestrictions::AssertIOAllowed();
   DCHECK(!id.empty());
 
   std::string serialized_entry;
   const leveldb::Status status = resource_map_->Get(
       leveldb::ReadOptions(),
       leveldb::Slice(GetCacheEntryKey(id)),
       &serialized_entry);
-  return status.ok() && out_entry->ParseFromString(serialized_entry);
+  if (!status.ok())
+    return LevelDBStatusToFileError(status);
+  return out_entry->ParseFromString(serialized_entry) ?
+      FILE_ERROR_OK : FILE_ERROR_FAILED;
 }
 
-bool ResourceMetadataStorage::RemoveCacheEntry(const std::string& id) {
+FileError ResourceMetadataStorage::RemoveCacheEntry(const std::string& id) {
   base::ThreadRestrictions::AssertIOAllowed();
   DCHECK(!id.empty());
 
   const leveldb::Status status = resource_map_->Delete(
       leveldb::WriteOptions(),
       leveldb::Slice(GetCacheEntryKey(id)));
-  return status.ok();
+  return LevelDBStatusToFileError(status);
 }
 
 scoped_ptr<ResourceMetadataStorage::CacheEntryIterator>
 ResourceMetadataStorage::GetCacheEntryIterator() {
   base::ThreadRestrictions::AssertIOAllowed();
 
   scoped_ptr<leveldb::Iterator> it(
       resource_map_->NewIterator(leveldb::ReadOptions()));
   return make_scoped_ptr(new CacheEntryIterator(it.Pass()));
 }
 
 ResourceMetadataStorage::RecoveredCacheInfo::RecoveredCacheInfo()
     : is_dirty(false) {}
 
 ResourceMetadataStorage::RecoveredCacheInfo::~RecoveredCacheInfo() {}
 
-bool ResourceMetadataStorage::GetIdByResourceId(
+FileError ResourceMetadataStorage::GetIdByResourceId(
     const std::string& resource_id,
     std::string* out_id) {
   base::ThreadRestrictions::AssertIOAllowed();
   DCHECK(!resource_id.empty());
 
   const leveldb::Status status = resource_map_->Get(
       leveldb::ReadOptions(),
       leveldb::Slice(GetIdEntryKey(resource_id)),
       out_id);
-  return status.ok();
+  return LevelDBStatusToFileError(status);
 }
 
 ResourceMetadataStorage::~ResourceMetadataStorage() {
   base::ThreadRestrictions::AssertIOAllowed();
 }
 
 void ResourceMetadataStorage::DestroyOnBlockingPool() {
   delete this;
 }
 
 // static
 std::string ResourceMetadataStorage::GetChildEntryKey(
     const std::string& parent_id,
     const std::string& child_name) {
   DCHECK(!parent_id.empty());
   DCHECK(!child_name.empty());
 
   std::string key = parent_id;
   key.push_back(kDBKeyDelimeter);
   key.append(child_name);
   key.push_back(kDBKeyDelimeter);
   return key;
 }
 
-bool ResourceMetadataStorage::PutHeader(
+FileError ResourceMetadataStorage::PutHeader(
     const ResourceMetadataHeader& header) {
   base::ThreadRestrictions::AssertIOAllowed();
 
   std::string serialized_header;
   if (!header.SerializeToString(&serialized_header)) {
     DLOG(ERROR) << "Failed to serialize the header";
-    return false;
+    return FILE_ERROR_FAILED;
   }
 
   const leveldb::Status status = resource_map_->Put(
       leveldb::WriteOptions(),
       leveldb::Slice(GetHeaderDBKey()),
       leveldb::Slice(serialized_header));
-  return status.ok();
+  return LevelDBStatusToFileError(status);
 }
 
-bool ResourceMetadataStorage::GetHeader(ResourceMetadataHeader* header) {
+FileError ResourceMetadataStorage::GetHeader(ResourceMetadataHeader* header) {
   base::ThreadRestrictions::AssertIOAllowed();
 
   std::string serialized_header;
   const leveldb::Status status = resource_map_->Get(
       leveldb::ReadOptions(),
       leveldb::Slice(GetHeaderDBKey()),
       &serialized_header);
-  return status.ok() && header->ParseFromString(serialized_header);
+  if (!status.ok())
+    return LevelDBStatusToFileError(status);
+  return header->ParseFromString(serialized_header) ?
+      FILE_ERROR_OK : FILE_ERROR_FAILED;
 }
 
 bool ResourceMetadataStorage::CheckValidity() {
   base::ThreadRestrictions::AssertIOAllowed();
 
   // Perform read with checksums verification enalbed.
   leveldb::ReadOptions options;
   options.verify_checksums = true;
 
   scoped_ptr<leveldb::Iterator> it(resource_map_->NewIterator(options));
@@ skipping 95 matching lines @@
   if (!it->status().ok() || num_child_entries != num_entries_with_parent) {
     DLOG(ERROR) << "Error during checking resource map. status = "
                 << it->status().ToString();
     return false;
   }
   return true;
 }
 
 }  // namespace internal
 }  // namespace drive