drive: DriveIntegrationService owns ResourceMetadataStorage

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/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/sys_info.h"
 #include "chrome/browser/chromeos/drive/drive.pb.h"
@@ skipping 107 matching lines @@
 
 EntryInfoPairResult::EntryInfoPairResult() {
 }
 
 EntryInfoPairResult::~EntryInfoPairResult() {
 }
 
 namespace internal {
 
 ResourceMetadata::ResourceMetadata(
-    const base::FilePath& data_directory_path,
+    ResourceMetadataStorage* storage,
     scoped_refptr<base::SequencedTaskRunner> blocking_task_runner)
-    : data_directory_path_(data_directory_path),
-      blocking_task_runner_(blocking_task_runner),
-      storage_(new ResourceMetadataStorage(data_directory_path)),
+    : blocking_task_runner_(blocking_task_runner),
+      storage_(storage),
       weak_ptr_factory_(this) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 FileError ResourceMetadata::Initialize() {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
 
-  if (!EnoughDiskSpaceIsAvailableForDBOperation(data_directory_path_))
+  if (!EnoughDiskSpaceIsAvailableForDBOperation(storage_->directory_path()))
     return FILE_ERROR_NO_SPACE;
 
-  // Initialize the storage.
-  if (!storage_->Initialize())
-    return FILE_ERROR_FAILED;
-
   if (!SetUpDefaultEntries())
     return FILE_ERROR_FAILED;
 
   return FILE_ERROR_OK;
 }
 
 void ResourceMetadata::Destroy() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   weak_ptr_factory_.InvalidateWeakPtrs();
@@ skipping 10 matching lines @@
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_.get(),
       FROM_HERE,
       base::Bind(&ResourceMetadata::Reset, base::Unretained(this)),
       callback);
 }
 
 FileError ResourceMetadata::Reset() {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
 
-  if (!EnoughDiskSpaceIsAvailableForDBOperation(data_directory_path_))
+  if (!EnoughDiskSpaceIsAvailableForDBOperation(storage_->directory_path()))
     return FILE_ERROR_NO_SPACE;
 
   if (!storage_->SetLargestChangestamp(0) ||
       !RemoveEntryRecursively(util::kDriveGrandRootSpecialResourceId) ||
       !SetUpDefaultEntries())
     return FILE_ERROR_FAILED;
 
   return FILE_ERROR_OK;
 }
 
@@ skipping 54 matching lines @@
 }
 
 int64 ResourceMetadata::GetLargestChangestamp() {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
   return storage_->GetLargestChangestamp();
 }
 
 FileError ResourceMetadata::SetLargestChangestamp(int64 value) {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
 
-  if (!EnoughDiskSpaceIsAvailableForDBOperation(data_directory_path_))
+  if (!EnoughDiskSpaceIsAvailableForDBOperation(storage_->directory_path()))
     return FILE_ERROR_NO_SPACE;
 
   storage_->SetLargestChangestamp(value);
   return FILE_ERROR_OK;
 }
 
 void ResourceMetadata::AddEntryOnUIThread(const ResourceEntry& entry,
                                           const FileMoveCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   PostFileMoveTask(
       blocking_task_runner_.get(),
       base::Bind(&AddEntryWithFilePath, base::Unretained(this), entry),
       callback);
 }
 
 FileError ResourceMetadata::AddEntry(const ResourceEntry& entry) {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
 
-  if (!EnoughDiskSpaceIsAvailableForDBOperation(data_directory_path_))
+  if (!EnoughDiskSpaceIsAvailableForDBOperation(storage_->directory_path()))
     return FILE_ERROR_NO_SPACE;
 
   ResourceEntry existing_entry;
   if (storage_->GetEntry(entry.resource_id(), &existing_entry))
     return FILE_ERROR_EXISTS;
 
   ResourceEntry parent;
   if (!storage_->GetEntry(entry.parent_resource_id(), &parent) ||
       !parent.file_info().is_directory())
     return FILE_ERROR_NOT_FOUND;
@@ skipping 29 matching lines @@
                    base::Bind(&ResourceMetadata::RenameEntry,
                               base::Unretained(this),
                               file_path,
                               new_name),
                    callback);
 }
 
 FileError ResourceMetadata::RemoveEntry(const std::string& resource_id) {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
 
-  if (!EnoughDiskSpaceIsAvailableForDBOperation(data_directory_path_))
+  if (!EnoughDiskSpaceIsAvailableForDBOperation(storage_->directory_path()))
     return FILE_ERROR_NO_SPACE;
 
   // Disallow deletion of special entries "/drive" and "/drive/other".
   if (util::IsSpecialResourceId(resource_id))
     return FILE_ERROR_ACCESS_DENIED;
 
   ResourceEntry entry;
   if (!storage_->GetEntry(resource_id, &entry))
     return FILE_ERROR_NOT_FOUND;
 
@@ skipping 97 matching lines @@
     if (!storage_->GetEntry(children[i], &entries[i]))
       return FILE_ERROR_FAILED;
   }
   out_entries->swap(entries);
   return FILE_ERROR_OK;
 }
 
 FileError ResourceMetadata::RefreshEntry(const ResourceEntry& entry) {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
 
-  if (!EnoughDiskSpaceIsAvailableForDBOperation(data_directory_path_))
+  if (!EnoughDiskSpaceIsAvailableForDBOperation(storage_->directory_path()))
     return FILE_ERROR_NO_SPACE;
 
   ResourceEntry old_entry;
   if (!storage_->GetEntry(entry.resource_id(), &old_entry))
     return FILE_ERROR_NOT_FOUND;
 
   if (old_entry.parent_resource_id().empty() ||  // Reject root.
       old_entry.file_info().is_directory() !=  // Reject incompatible input.
       entry.file_info().is_directory())
     return FILE_ERROR_INVALID_OPERATION;
@@ skipping 70 matching lines @@
 
 FileError ResourceMetadata::MoveEntryToDirectory(
     const base::FilePath& file_path,
     const base::FilePath& directory_path,
     base::FilePath* out_file_path) {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(!directory_path.empty());
   DCHECK(!file_path.empty());
   DCHECK(out_file_path);
 
-  if (!EnoughDiskSpaceIsAvailableForDBOperation(data_directory_path_))
+  if (!EnoughDiskSpaceIsAvailableForDBOperation(storage_->directory_path()))
     return FILE_ERROR_NO_SPACE;
 
   ResourceEntry entry, destination;
   if (!FindEntryByPathSync(file_path, &entry) ||
       !FindEntryByPathSync(directory_path, &destination))
     return FILE_ERROR_NOT_FOUND;
   if (!destination.file_info().is_directory())
     return FILE_ERROR_NOT_A_DIRECTORY;
 
   entry.set_parent_resource_id(destination.resource_id());
 
   FileError error = RefreshEntry(entry);
   if (error == FILE_ERROR_OK)
     *out_file_path = GetFilePath(entry.resource_id());
   return error;
 }
 
 FileError ResourceMetadata::RenameEntry(
     const base::FilePath& file_path,
     const std::string& new_name,
     base::FilePath* out_file_path) {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(!file_path.empty());
   DCHECK(!new_name.empty());
   DCHECK(out_file_path);
 
   DVLOG(1) << "RenameEntry " << file_path.value() << " to " << new_name;
 
-  if (!EnoughDiskSpaceIsAvailableForDBOperation(data_directory_path_))
+  if (!EnoughDiskSpaceIsAvailableForDBOperation(storage_->directory_path()))
     return FILE_ERROR_NO_SPACE;
 
   ResourceEntry entry;
   if (!FindEntryByPathSync(file_path, &entry))
     return FILE_ERROR_NOT_FOUND;
 
   if (base::FilePath::FromUTF8Unsafe(new_name) == file_path.BaseName())
     return FILE_ERROR_EXISTS;
 
   entry.set_title(new_name);
@@ skipping 52 matching lines @@
           callback));
 }
 
 FileError ResourceMetadata::RefreshDirectory(
     const DirectoryFetchInfo& directory_fetch_info,
     const ResourceEntryMap& entry_map,
     base::FilePath* out_file_path) {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(!directory_fetch_info.empty());
 
-  if (!EnoughDiskSpaceIsAvailableForDBOperation(data_directory_path_))
+  if (!EnoughDiskSpaceIsAvailableForDBOperation(storage_->directory_path()))
     return FILE_ERROR_NO_SPACE;
 
   ResourceEntry directory;
   if (!storage_->GetEntry(directory_fetch_info.resource_id(), &directory))
     return FILE_ERROR_NOT_FOUND;
 
   if (!directory.file_info().is_directory())
     return 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 (ResourceEntryMap::const_iterator it = entry_map.begin();
        it != entry_map.end(); ++it) {
-    if (!EnoughDiskSpaceIsAvailableForDBOperation(data_directory_path_))
+    if (!EnoughDiskSpaceIsAvailableForDBOperation(storage_->directory_path()))
       return FILE_ERROR_NO_SPACE;
 
     const ResourceEntry& entry = 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.parent_resource_id() !=
         directory_fetch_info.resource_id()) {
       DVLOG(1) << "Wrong-parent entry rejected: " << entry.resource_id();
       continue;
     }
 
     if (!PutEntryUnderDirectory(CreateEntryWithProperBaseName(entry)))
       return FILE_ERROR_FAILED;
   }
 
   // Go through the existing entries and remove deleted entries.
   std::vector<std::string> children;
   storage_->GetChildren(directory.resource_id(), &children);
   for (size_t i = 0; i < children.size(); ++i) {
-    if (!EnoughDiskSpaceIsAvailableForDBOperation(data_directory_path_))
+    if (!EnoughDiskSpaceIsAvailableForDBOperation(storage_->directory_path()))
       return FILE_ERROR_NO_SPACE;
 
     if (entry_map.count(children[i]) == 0) {
       if (!RemoveEntryRecursively(children[i]))
         return FILE_ERROR_FAILED;
     }
   }
 
   if (out_file_path)
     *out_file_path = GetFilePath(directory.resource_id());
@@ skipping 99 matching lines @@
     for (size_t i = 0; i < children.size(); ++i) {
       if (!RemoveEntryRecursively(children[i]))
         return false;
     }
   }
   return storage_->RemoveEntry(resource_id);
 }
 
 }  // namespace internal
 }  // namespace drive