drive: Use "/drive/root" namespace and fix Files app and tests.

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 "chrome/browser/chromeos/drive/drive.pb.h"
@@ skipping 275 matching lines @@
   // Initialize the storage.
   if (!storage_->Initialize())
     return DRIVE_FILE_ERROR_FAILED;
 
   // Remove unneeded proto file.
   if (storage_->IsPersistentStorage()) {
     file_util::Delete(data_directory_path_.Append(kProtoFileName),
                       true /* recursive */);
   }
 
-  // Initialize the root entry.
-  if (!storage_->GetEntry(root_resource_id_)) {
+  // Initialize the grand root and "other" entries. "/drive" and "/drive/other".
+  // As an intermediate change, "/drive/root" is also added here.
+  // TODO(haruki): Move this initialization to change_list_loader where we
+  // can retrieve the root folder ID from the server.
+  if (!storage_->GetEntry(util::kDriveGrandRootSpecialResourceId)) {
     DriveEntryProto root;
     root.mutable_file_info()->set_is_directory(true);
-    root.set_resource_id(root_resource_id_);
+    root.set_resource_id(util::kDriveGrandRootSpecialResourceId);
     root.set_title(util::kDriveGrandRootDirName);
     storage_->PutEntry(CreateEntryWithProperBaseName(root));
   }
+  if (!storage_->GetEntry(util::kDriveOtherDirSpecialResourceId)) {
+    DriveEntryProto other_dir;
+    other_dir.mutable_file_info()->set_is_directory(true);
+    other_dir.set_resource_id(util::kDriveOtherDirSpecialResourceId);
+    other_dir.set_parent_resource_id(util::kDriveGrandRootSpecialResourceId);
+    other_dir.set_title(util::kDriveOtherDirName);
+    AddEntryToDirectory(other_dir);
+  }
+  if (!storage_->GetEntry(root_resource_id_)) {
+    DriveEntryProto mydrive_root;
+    mydrive_root.mutable_file_info()->set_is_directory(true);
+    mydrive_root.set_resource_id(root_resource_id_);
+    mydrive_root.set_parent_resource_id(util::kDriveGrandRootSpecialResourceId);
+    mydrive_root.set_title(util::kDriveMyDriveRootDirName);
+    AddEntryToDirectory(mydrive_root);
+  }
   return DRIVE_FILE_OK;
 }
 
 void DriveResourceMetadata::DestroyOnBlockingPool() {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
   delete this;
 }
 
 void DriveResourceMetadata::ResetOnBlockingPool() {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
 
-  RemoveDirectoryChildren(root_resource_id_);
+  RemoveDirectoryChildren(util::kDriveGrandRootSpecialResourceId);
+  InitializeOnBlockingPool();
   last_serialized_ = base::Time();
   serialized_size_ = 0;
   storage_->SetLargestChangestamp(0);
 }
 
 void DriveResourceMetadata::GetLargestChangestamp(
     const GetChangestampCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
   base::PostTaskAndReplyWithResult(
@@ skipping 266 matching lines @@
   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());
 
-  // Disallow deletion of root.
-  if (resource_id == root_resource_id_)
+  // 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,
                         GetFilePath(entry->parent_resource_id()));
 }
 
 scoped_ptr<DriveEntryProto> DriveResourceMetadata::FindEntryByPathSync(
     const base::FilePath& file_path) {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
   scoped_ptr<DriveEntryProto> current_dir =
-      storage_->GetEntry(root_resource_id_);
+      storage_->GetEntry(util::kDriveGrandRootSpecialResourceId);
   DCHECK(current_dir);
 
   if (file_path == GetFilePath(current_dir->resource_id()))
       return current_dir.Pass();
 
   std::vector<base::FilePath::StringType> components;
   file_path.GetComponents(&components);
 
   for (size_t i = 1; i < components.size() && current_dir; ++i) {
     const std::string component = base::FilePath(components[i]).AsUTF8Unsafe();
@@ skipping 96 matching lines @@
   }
 
   // Reject incompatible input.
   if (entry->file_info().is_directory() !=
       entry_proto.file_info().is_directory()) {
     return make_scoped_ptr(
         new GetEntryInfoWithFilePathResult(DRIVE_FILE_ERROR_INVALID_OPERATION));
   }
 
   // Update data.
-  if (entry->resource_id() != root_resource_id_) {
+  if (!util::IsSpecialResourceId(entry->resource_id())) {
     scoped_ptr<DriveEntryProto> new_parent =
         GetDirectory(entry_proto.parent_resource_id());
 
     if (!new_parent) {
       return make_scoped_ptr(
           new GetEntryInfoWithFilePathResult(DRIVE_FILE_ERROR_NOT_FOUND));
     }
 
     // Remove from the old parent, update the entry, and add it to the new
     // parent.
@@ skipping 144 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());
 
-  RemoveDirectoryChildren(root_resource_id_);
+  RemoveDirectoryChildren(util::kDriveGrandRootSpecialResourceId);
+  InitializeOnBlockingPool();
 }
 
 void DriveResourceMetadata::MaybeSaveOnBlockingPool() {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
 
   if (storage_->IsPersistentStorage() ||
       !ShouldSerializeFileSystemNow(serialized_size_, last_serialized_))
     return;
 
   const base::FilePath path = data_directory_path_.Append(kProtoFileName);
 
   DriveRootDirectoryProto proto;
-  DirectoryToProto(root_resource_id_, proto.mutable_drive_directory());
+  DirectoryToProto(util::kDriveGrandRootSpecialResourceId,
+                   proto.mutable_drive_directory());
   proto.set_largest_changestamp(storage_->GetLargestChangestamp());
   proto.set_version(kProtoVersion);
 
   scoped_ptr<std::string> serialized_proto(new std::string());
   const bool ok = proto.SerializeToString(serialized_proto.get());
   DCHECK(ok);
 
   last_serialized_ = base::Time::Now();
   serialized_size_ = serialized_proto->size();
   WriteStringToFile(path, serialized_proto.Pass());
@@ skipping 120 matching lines @@
 
 void DriveResourceMetadata::AddDescendantsFromProto(
     const DriveDirectoryProto& proto) {
   DCHECK(blocking_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(proto.drive_entry().file_info().is_directory());
   DCHECK(!proto.drive_entry().has_file_specific_info());
 
 #if !defined(NDEBUG)
   std::vector<std::string> children;
   storage_->GetChildren(proto.drive_entry().resource_id(), &children);
-  DCHECK(children.empty());
+  DCHECK(proto.drive_entry().resource_id() ==
+             util::kDriveGrandRootSpecialResourceId ||
+         children.empty());
 #endif
 
   // Add child files.
   for (int i = 0; i < proto.child_files_size(); ++i) {
     DriveEntryProto file(CreateEntryWithProperBaseName(proto.child_files(i)));
     DCHECK_EQ(proto.drive_entry().resource_id(), file.parent_resource_id());
     AddEntryToDirectory(file);
   }
   // Add child directories recursively.
   for (int i = 0; i < proto.child_directories_size(); ++i) {
@@ skipping 88 matching lines @@
 
   // An old proto file might not have per-directory changestamps. Add them if
   // needed.
   const DriveDirectoryProto& root = proto.drive_directory();
   if (!root.drive_entry().directory_specific_info().has_changestamp()) {
     AddPerDirectoryChangestamps(proto.mutable_drive_directory(),
                                 proto.largest_changestamp());
   }
 
   if (proto.drive_directory().drive_entry().resource_id() !=
-      root_resource_id_) {
+      util::kDriveGrandRootSpecialResourceId) {
     LOG(ERROR) << "Incompatible proto detected (incompatible root ID): "
                << proto.drive_directory().drive_entry().resource_id();
     return false;
   }
 
   storage_->PutEntry(
       CreateEntryWithProperBaseName(proto.drive_directory().drive_entry()));
   AddDescendantsFromProto(proto.drive_directory());
 
   storage_->SetLargestChangestamp(proto.largest_changestamp());
 
   return true;
 }
 
 }  // namespace drive