Remove root resource id aliasing from DriveResourceMetadata.

chrome/browser/chromeos/drive/drive_resource_metadata_unittest.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 <algorithm>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 76 matching lines @@
                                  const std::string& parent_resource_id);
 
   virtual void SetUp() OVERRIDE {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
 
     base::ThreadRestrictions::SetIOAllowed(false);  // For strict thread check.
     scoped_refptr<base::SequencedWorkerPool> pool =
         content::BrowserThread::GetBlockingPool();
     blocking_task_runner_ =
         pool->GetSequencedTaskRunner(pool->GetSequenceToken());
-    resource_metadata_.reset(new DriveResourceMetadata(kTestRootResourceId,
-                                                       temp_dir_.path(),
+    resource_metadata_.reset(new DriveResourceMetadata(temp_dir_.path(),
                                                        blocking_task_runner_));
     Init(resource_metadata_.get());
   }
 
   virtual void TearDown() OVERRIDE {
     resource_metadata_.reset();
     base::ThreadRestrictions::SetIOAllowed(true);
   }
 
   // Gets the entry info by path synchronously. Returns NULL on failure.
@@ skipping 62 matching lines @@
 };
 
 // static
 void DriveResourceMetadataTest::Init(DriveResourceMetadata* resource_metadata) {
   DriveFileError error = DRIVE_FILE_ERROR_FAILED;
   resource_metadata->Initialize(
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   ASSERT_EQ(DRIVE_FILE_OK, error);
 
+  // Create mydrive root directory.
+  {
+    error = DRIVE_FILE_ERROR_FAILED;
+    base::FilePath drive_path;
+    resource_metadata->AddEntry(
+        util::CreateMyDriveRootEntry(kTestRootResourceId),
+        google_apis::test_util::CreateCopyResultCallback(&error, &drive_path));
+    google_apis::test_util::RunBlockingPoolTask();
+    ASSERT_EQ(DRIVE_FILE_OK, error);
+  }
+
   int sequence_id = 1;
   ASSERT_TRUE(AddDriveEntryProto(
       resource_metadata, sequence_id++, true, kTestRootResourceId));
   ASSERT_TRUE(AddDriveEntryProto(
       resource_metadata, sequence_id++, true, kTestRootResourceId));
   ASSERT_TRUE(AddDriveEntryProto(
       resource_metadata, sequence_id++, true, "resource_id:dir1"));
 
   ASSERT_TRUE(AddDriveEntryProto(
       resource_metadata, sequence_id++, false, "resource_id:dir1"));
@@ skipping 69 matching lines @@
 TEST_F(DriveResourceMetadataTest, VersionCheck) {
   // Set up the root directory.
   DriveRootDirectoryProto proto;
   DriveEntryProto* mutable_entry =
       proto.mutable_drive_directory()->mutable_drive_entry();
   mutable_entry->mutable_file_info()->set_is_directory(true);
   mutable_entry->set_resource_id(util::kDriveGrandRootSpecialResourceId);
   mutable_entry->set_title("drive");
 
   scoped_ptr<DriveResourceMetadata, test_util::DestroyHelperForTests>
-      resource_metadata(new DriveResourceMetadata(kTestRootResourceId,
-                                                  temp_dir_.path(),
+      resource_metadata(new DriveResourceMetadata(temp_dir_.path(),
                                                   blocking_task_runner_));
   ForceUsingMemoryStorage(resource_metadata.get());
 
   DriveFileError error = DRIVE_FILE_ERROR_FAILED;
   resource_metadata->Initialize(
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   ASSERT_EQ(DRIVE_FILE_OK, error);
 
   std::string serialized_proto;
@@ skipping 19 matching lines @@
   // Set a newer version, and serialize.
   proto.set_version(kProtoVersion + 1);
   EXPECT_TRUE(proto.SerializeToString(&serialized_proto));
   // This should fail as the version is newer.
   EXPECT_FALSE(ParseMetadataFromString(resource_metadata.get(),
                                        serialized_proto));
 }
 
 TEST_F(DriveResourceMetadataTest, LargestChangestamp) {
   scoped_ptr<DriveResourceMetadata, test_util::DestroyHelperForTests>
-      resource_metadata(new DriveResourceMetadata(kTestRootResourceId,
-                                                  temp_dir_.path(),
+      resource_metadata(new DriveResourceMetadata(temp_dir_.path(),
                                                   blocking_task_runner_));
   DriveFileError error = DRIVE_FILE_ERROR_FAILED;
   resource_metadata->Initialize(
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   ASSERT_EQ(DRIVE_FILE_OK, error);
 
   int64 in_changestamp = 123456;
   resource_metadata->SetLargestChangestamp(
       in_changestamp,
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_OK, error);
 
   int64 out_changestamp = 0;
   resource_metadata->GetLargestChangestamp(
       google_apis::test_util::CreateCopyResultCallback(&out_changestamp));
   google_apis::test_util::RunBlockingPoolTask();
   DCHECK_EQ(in_changestamp, out_changestamp);
 }
 
 TEST_F(DriveResourceMetadataTest, GetEntryInfoByResourceId_RootDirectory) {
   scoped_ptr<DriveResourceMetadata, test_util::DestroyHelperForTests>
-      resource_metadata(new DriveResourceMetadata(kTestRootResourceId,
-                                                  temp_dir_.path(),
+      resource_metadata(new DriveResourceMetadata(temp_dir_.path(),
                                                   blocking_task_runner_));
   DriveFileError error = DRIVE_FILE_ERROR_FAILED;
   resource_metadata->Initialize(
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   ASSERT_EQ(DRIVE_FILE_OK, error);
 
   base::FilePath drive_file_path;
   scoped_ptr<DriveEntryProto> entry_proto;
 
@@ skipping 903 matching lines @@
   base::FilePath drive_file_path;
   scoped_ptr<DriveEntryProto> entry_proto;
 
   // root should continue to exist.
   entry_proto = GetEntryInfoByPathSync(base::FilePath::FromUTF8Unsafe("drive"));
   ASSERT_TRUE(entry_proto.get());
   EXPECT_EQ("drive", entry_proto->base_name());
   ASSERT_TRUE(entry_proto->file_info().is_directory());
   EXPECT_EQ(util::kDriveGrandRootSpecialResourceId, entry_proto->resource_id());
 
-  // There is "root" and "other", which are both empty.
+  // There is "other", which are both empty.
   entries = ReadDirectoryByPathSync(base::FilePath::FromUTF8Unsafe("drive"));
   ASSERT_TRUE(entries.get());
-  EXPECT_EQ(2U, entries->size());
-
-  scoped_ptr<DriveEntryProtoVector> entries_in_mydrive =
-      ReadDirectoryByPathSync(base::FilePath::FromUTF8Unsafe("drive/root"));
-  ASSERT_TRUE(entries_in_mydrive.get());
-  EXPECT_TRUE(entries_in_mydrive->empty());
+  EXPECT_EQ(1U, entries->size());
 
   scoped_ptr<DriveEntryProtoVector> entries_in_other =
       ReadDirectoryByPathSync(base::FilePath::FromUTF8Unsafe("drive/other"));
   ASSERT_TRUE(entries_in_other.get());
   EXPECT_TRUE(entries_in_other->empty());
 }
 
 TEST_F(DriveResourceMetadataTest, IterateEntries) {
   int count = 0;
   bool completed = false;
   resource_metadata_->IterateEntries(
       base::Bind(&CountFile, &count),
       base::Bind(google_apis::test_util::CreateCopyResultCallback(&completed),
                  true));
   google_apis::test_util::RunBlockingPoolTask();
 
   EXPECT_EQ(7, count);
   EXPECT_TRUE(completed);
 }
 
 TEST_F(DriveResourceMetadataTest, PerDirectoryChangestamp) {
   const int kNewChangestamp = kTestChangestamp + 1;
   const char kSubDirectoryResourceId[] = "sub-directory-id";
 
   scoped_ptr<DriveResourceMetadata, test_util::DestroyHelperForTests>
       resource_metadata_original(new DriveResourceMetadata(
-          kTestRootResourceId, temp_dir_.path(), blocking_task_runner_));
+          temp_dir_.path(), blocking_task_runner_));
   ForceUsingMemoryStorage(resource_metadata_original.get());
 
   DriveFileError error = DRIVE_FILE_ERROR_FAILED;
   resource_metadata_original->Initialize(
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   ASSERT_EQ(DRIVE_FILE_OK, error);
 
   resource_metadata_original->SetLargestChangestamp(
       kNewChangestamp,
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_OK, error);
 
+  // Add "/drive/root" directory.
+  base::FilePath file_path;
+  resource_metadata_original->AddEntry(
+      util::CreateMyDriveRootEntry(kTestRootResourceId),
+      google_apis::test_util::CreateCopyResultCallback(&error, &file_path));
+  google_apis::test_util::RunBlockingPoolTask();
+  ASSERT_EQ(DRIVE_FILE_OK, error);
+
   // Add a sub directory.
   DriveEntryProto directory_entry;
   directory_entry.mutable_file_info()->set_is_directory(true);
   directory_entry.set_resource_id(kSubDirectoryResourceId);
   directory_entry.set_parent_resource_id(kTestRootResourceId);
   directory_entry.set_title("directory");
-  base::FilePath file_path;
   resource_metadata_original->AddEntry(
       directory_entry,
       google_apis::test_util::CreateCopyResultCallback(&error, &file_path));
+  google_apis::test_util::RunBlockingPoolTask();
+  ASSERT_EQ(DRIVE_FILE_OK, error);
+
   // At this point, both the root and the sub directory do not contain the
   // per-directory changestamp.
   resource_metadata_original->MaybeSave();
   google_apis::test_util::RunBlockingPoolTask();
 
   scoped_ptr<DriveResourceMetadata, test_util::DestroyHelperForTests>
-      resource_metadata(new DriveResourceMetadata(
-          util::kDriveGrandRootSpecialResourceId,
-          temp_dir_.path(),
-          blocking_task_runner_));
+      resource_metadata(new DriveResourceMetadata(temp_dir_.path(),
+                                                  blocking_task_runner_));
   ForceUsingMemoryStorage(resource_metadata.get());
 
   resource_metadata->Initialize(
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   ASSERT_EQ(DRIVE_FILE_OK, error);
 
   // Load. This should propagate the largest changestamp to every directory.
   resource_metadata->Load(
       google_apis::test_util::CreateCopyResultCallback(&error));
@@ skipping 17 matching lines @@
   google_apis::test_util::RunBlockingPoolTask();
   ASSERT_EQ(DRIVE_FILE_OK, error);
   EXPECT_EQ(kNewChangestamp,
             entry_proto->directory_specific_info().changestamp());
 }
 
 TEST_F(DriveResourceMetadataTest, SaveAndLoad) {
   // Save metadata and reset.
   resource_metadata_->MaybeSave();
 
-  resource_metadata_.reset(new DriveResourceMetadata(
-      util::kDriveGrandRootSpecialResourceId,
-      temp_dir_.path(),
-      blocking_task_runner_));
+  resource_metadata_.reset(new DriveResourceMetadata(temp_dir_.path(),
+                                                     blocking_task_runner_));
   DriveFileError error = DRIVE_FILE_ERROR_FAILED;
   resource_metadata_->Initialize(
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   ASSERT_EQ(DRIVE_FILE_OK, error);
 
   // Load metadata.
   resource_metadata_->Load(
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_OK, error);
 
   // Try to get some data.
   scoped_ptr<DriveEntryProto> entry = GetEntryInfoByPathSync(
       base::FilePath::FromUTF8Unsafe("drive/root/dir1/dir3/file9"));
   ASSERT_TRUE(entry.get());
   EXPECT_EQ("file9", entry->base_name());
   ASSERT_TRUE(!entry->file_info().is_directory());
   EXPECT_EQ("md5:file9", entry->file_specific_info().file_md5());
 }
 
 }  // namespace drive