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

chrome/browser/chromeos/drive/drive_file_system_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_file_system.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 290 matching lines @@
     return GetCacheEntryFromOriginThread(resource_id, md5, &cache_entry);
   }
 
   // Flag for specifying the timestamp of the test filesystem cache.
   enum SaveTestFileSystemParam {
     USE_OLD_TIMESTAMP,
     USE_SERVER_TIMESTAMP,
   };
 
   // Saves a file representing a filesystem with directories:
-  // drive, drive/Dir1, drive/Dir1/SubDir2
+  // drive/root, drive/root/Dir1, drive/root/Dir1/SubDir2
   // and files
-  // drive/File1, drive/Dir1/File2, drive/Dir1/SubDir2/File3.
+  // drive/root/File1, drive/root/Dir1/File2, drive/root/Dir1/SubDir2/File3.
   // If |use_up_to_date_timestamp| is true, sets the changestamp to 654321,
   // equal to that of "account_metadata.json" test data, indicating the cache is
   // holding the latest file system info.
   bool SaveTestFileSystem(SaveTestFileSystemParam param) {
     // Destroy the existing resource metadata to close DB.
     resource_metadata_.reset();
 
     const std::string root_resource_id =
         fake_drive_service_->GetRootResourceId();
     scoped_ptr<DriveResourceMetadata, test_util::DestroyHelperForTests>
         resource_metadata(new DriveResourceMetadata(
             root_resource_id,
             cache_->GetCacheDirectoryPath(DriveCache::CACHE_TYPE_META),
             blocking_task_runner_));
 
     DriveFileError error = DRIVE_FILE_ERROR_FAILED;
     resource_metadata->Initialize(
         google_apis::test_util::CreateCopyResultCallback(&error));
     google_apis::test_util::RunBlockingPoolTask();
     if (error != DRIVE_FILE_OK)
       return false;
 
     resource_metadata->SetLargestChangestamp(
         param == USE_SERVER_TIMESTAMP ? 654321 : 1,
         google_apis::test_util::CreateCopyResultCallback(&error));
     google_apis::test_util::RunBlockingPoolTask();
     if (error != DRIVE_FILE_OK)
       return false;
 
-    // drive/File1
+    // drive/root is already prepared by DriveResourceMetadata.
+    // TODO(haruki): Create drive/root here when we start creating it in
+    // ChangeListLoader.
+    base::FilePath file_path;
+
+    // drive/root/File1
     DriveEntryProto file1;
     file1.set_title("File1");
     file1.set_resource_id("resource_id:File1");
     file1.set_parent_resource_id(root_resource_id);
     file1.mutable_file_specific_info()->set_file_md5("md5");
     file1.mutable_file_info()->set_is_directory(false);
     file1.mutable_file_info()->set_size(1048576);
-    base::FilePath file_path;
     resource_metadata->AddEntry(
         file1,
         google_apis::test_util::CreateCopyResultCallback(&error, &file_path));
     google_apis::test_util::RunBlockingPoolTask();
     if (error != DRIVE_FILE_OK)
       return false;
 
-    // drive/Dir1
+    // drive/root/Dir1
     DriveEntryProto dir1;
     dir1.set_title("Dir1");
     dir1.set_resource_id("resource_id:Dir1");
     dir1.set_parent_resource_id(root_resource_id);
     dir1.mutable_file_info()->set_is_directory(true);
     resource_metadata->AddEntry(
         dir1,
         google_apis::test_util::CreateCopyResultCallback(&error, &file_path));
     google_apis::test_util::RunBlockingPoolTask();
     if (error != DRIVE_FILE_OK)
       return false;
 
-    // drive/Dir1/File2
+    // drive/root/Dir1/File2
     DriveEntryProto file2;
     file2.set_title("File2");
     file2.set_resource_id("resource_id:File2");
     file2.set_parent_resource_id(dir1.resource_id());
     file2.mutable_file_specific_info()->set_file_md5("md5");
     file2.mutable_file_info()->set_is_directory(false);
     file2.mutable_file_info()->set_size(555);
     resource_metadata->AddEntry(
         file2,
         google_apis::test_util::CreateCopyResultCallback(&error, &file_path));
     google_apis::test_util::RunBlockingPoolTask();
     if (error != DRIVE_FILE_OK)
       return false;
 
-    // drive/Dir1/SubDir2
+    // drive/root/Dir1/SubDir2
     DriveEntryProto dir2;
     dir2.set_title("SubDir2");
     dir2.set_resource_id("resource_id:SubDir2");
     dir2.set_parent_resource_id(dir1.resource_id());
     dir2.mutable_file_info()->set_is_directory(true);
     resource_metadata->AddEntry(
         dir2,
         google_apis::test_util::CreateCopyResultCallback(&error, &file_path));
     google_apis::test_util::RunBlockingPoolTask();
     if (error != DRIVE_FILE_OK)
       return false;
 
-    // drive/Dir1/SubDir2/File3
+    // drive/root/Dir1/SubDir2/File3
     DriveEntryProto file3;
     file3.set_title("File3");
     file3.set_resource_id("resource_id:File3");
     file3.set_parent_resource_id(dir2.resource_id());
     file3.mutable_file_specific_info()->set_file_md5("md5");
     file3.mutable_file_info()->set_is_directory(false);
     file3.mutable_file_info()->set_size(12345);
     resource_metadata->AddEntry(
         file3,
         google_apis::test_util::CreateCopyResultCallback(&error, &file_path));
@@ skipping 66 matching lines @@
   ASSERT_FALSE(entries->empty());
 
   (*counter)++;
   if (*counter >= expected_counter)
     message_loop->Quit();
 }
 
 TEST_F(DriveFileSystemTest, DuplicatedAsyncInitialization) {
   // The root directory will be loaded that triggers the event.
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
-      Eq(base::FilePath(FILE_PATH_LITERAL("drive"))))).Times(1);
+      Eq(base::FilePath(FILE_PATH_LITERAL("drive/root"))))).Times(1);
 
   int counter = 0;
   ReadDirectoryWithSettingCallback callback = base::Bind(
       &AsyncInitializationCallback,
       &counter,
       2,
       &message_loop_);
 
   file_system_->ReadDirectoryByPath(
-      base::FilePath(FILE_PATH_LITERAL("drive")), callback);
+      base::FilePath(FILE_PATH_LITERAL("drive/root")), callback);
   file_system_->ReadDirectoryByPath(
-      base::FilePath(FILE_PATH_LITERAL("drive")), callback);
+      base::FilePath(FILE_PATH_LITERAL("drive/root")), callback);
   message_loop_.Run();  // Wait to get our result
   EXPECT_EQ(2, counter);
 
   // ReadDirectoryByPath() was called twice, but the account metadata should
   // only be loaded once. In the past, there was a bug that caused it to be
   // loaded twice.
   EXPECT_EQ(1, fake_drive_service_->about_resource_load_count());
   // On the other hand, the resource list could be loaded twice. One for
   // just the directory contents, and one for the entire resource list.
   //
   // The |callback| function gets called back soon after the directory content
   // is loaded, and the full resource load is done in background asynchronously.
   // So it depends on timing whether we receive the full resource load request
   // at this point.
   EXPECT_TRUE(fake_drive_service_->resource_list_load_count() == 1 ||
               fake_drive_service_->resource_list_load_count() == 2)
       << ": " << fake_drive_service_->resource_list_load_count();
 }
 
-TEST_F(DriveFileSystemTest, GetRootEntry) {
-  const base::FilePath kFilePath = base::FilePath(FILE_PATH_LITERAL("drive"));
+TEST_F(DriveFileSystemTest, GetGrandRootEntry) {
+  const base::FilePath kFilePath =
+      base::FilePath(FILE_PATH_LITERAL("drive"));
+  scoped_ptr<DriveEntryProto> entry = GetEntryInfoByPathSync(kFilePath);
+  ASSERT_TRUE(entry.get());
+  EXPECT_EQ(util::kDriveGrandRootSpecialResourceId, entry->resource_id());
+
+  // Getting the grand root entry should not cause the resource load to happen.
+  EXPECT_EQ(0, fake_drive_service_->about_resource_load_count());
+  EXPECT_EQ(0, fake_drive_service_->resource_list_load_count());
+}
+
+TEST_F(DriveFileSystemTest, GetMyDriveRootEntry) {
+  const base::FilePath kFilePath =
+      base::FilePath(FILE_PATH_LITERAL("drive/root"));
   scoped_ptr<DriveEntryProto> entry = GetEntryInfoByPathSync(kFilePath);
   ASSERT_TRUE(entry.get());
   EXPECT_EQ(fake_drive_service_->GetRootResourceId(), entry->resource_id());
 
-  // Getting the root entry should not cause the resource load to happen.
+  // Getting the "My Drive" root entry should not cause the resource load to
+  // happen.
+  EXPECT_EQ(0, fake_drive_service_->about_resource_load_count());
+  EXPECT_EQ(0, fake_drive_service_->resource_list_load_count());
+}
+
+TEST_F(DriveFileSystemTest, GetOtherDirEntry) {
+  const base::FilePath kFilePath =
+      base::FilePath(FILE_PATH_LITERAL("drive/other"));
+  scoped_ptr<DriveEntryProto> entry = GetEntryInfoByPathSync(kFilePath);
+  ASSERT_TRUE(entry.get());
+  EXPECT_EQ(util::kDriveOtherDirSpecialResourceId, entry->resource_id());
+
+  // Getting the "other" directory entry should not cause the resource load to
+  // happen.
   EXPECT_EQ(0, fake_drive_service_->about_resource_load_count());
   EXPECT_EQ(0, fake_drive_service_->resource_list_load_count());
 }
 
 TEST_F(DriveFileSystemTest, GetNonRootEntry) {
   const base::FilePath kFilePath =
-      base::FilePath(FILE_PATH_LITERAL("drive/whatever.txt"));
+      base::FilePath(FILE_PATH_LITERAL("drive/root/whatever.txt"));
   scoped_ptr<DriveEntryProto> entry = GetEntryInfoByPathSync(kFilePath);
   // The entry should not exist as the resource metadata only contains the
   // root entry now.
   ASSERT_FALSE(entry.get());
 
   // The resource load should happen because non-root entry is requested.
   EXPECT_EQ(1, fake_drive_service_->about_resource_load_count());
   EXPECT_EQ(1, fake_drive_service_->resource_list_load_count());
 }
 
 TEST_F(DriveFileSystemTest, SearchRootDirectory) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
-  const base::FilePath kFilePath = base::FilePath(FILE_PATH_LITERAL("drive"));
+  const base::FilePath kFilePath =
+      base::FilePath(FILE_PATH_LITERAL("drive/root"));
   scoped_ptr<DriveEntryProto> entry = GetEntryInfoByPathSync(kFilePath);
   ASSERT_TRUE(entry.get());
   EXPECT_EQ(fake_drive_service_->GetRootResourceId(), entry->resource_id());
 
   // The changestamp should be propagated to the root directory.
   EXPECT_EQ(fake_drive_service_->largest_changestamp(),
             entry->directory_specific_info().changestamp());
 }
 
 TEST_F(DriveFileSystemTest, SearchExistingFile) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
   const base::FilePath kFilePath = base::FilePath(
-      FILE_PATH_LITERAL("drive/File 1.txt"));
+      FILE_PATH_LITERAL("drive/root/File 1.txt"));
   scoped_ptr<DriveEntryProto> entry = GetEntryInfoByPathSync(kFilePath);
   ASSERT_TRUE(entry.get());
   EXPECT_EQ("file:2_file_resource_id", entry->resource_id());
 }
 
 TEST_F(DriveFileSystemTest, SearchExistingDocument) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
   const base::FilePath kFilePath = base::FilePath(
-      FILE_PATH_LITERAL("drive/Document 1.gdoc"));
+      FILE_PATH_LITERAL("drive/root/Document 1.gdoc"));
   scoped_ptr<DriveEntryProto> entry = GetEntryInfoByPathSync(kFilePath);
   ASSERT_TRUE(entry.get());
   EXPECT_EQ("document:5_document_resource_id", entry->resource_id());
 }
 
 TEST_F(DriveFileSystemTest, SearchNonExistingFile) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
   const base::FilePath kFilePath = base::FilePath(
-      FILE_PATH_LITERAL("drive/nonexisting.file"));
+      FILE_PATH_LITERAL("drive/root/nonexisting.file"));
   scoped_ptr<DriveEntryProto> entry = GetEntryInfoByPathSync(kFilePath);
   ASSERT_FALSE(entry.get());
 }
 
 TEST_F(DriveFileSystemTest, SearchEncodedFileNames) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
   const base::FilePath kFilePath1 = base::FilePath(
-      FILE_PATH_LITERAL("drive/Slash / in file 1.txt"));
+      FILE_PATH_LITERAL("drive/root/Slash / in file 1.txt"));
   scoped_ptr<DriveEntryProto> entry = GetEntryInfoByPathSync(kFilePath1);
   ASSERT_FALSE(entry.get());
 
   const base::FilePath kFilePath2 = base::FilePath::FromUTF8Unsafe(
-      "drive/Slash \xE2\x88\x95 in file 1.txt");
+      "drive/root/Slash \xE2\x88\x95 in file 1.txt");
   entry = GetEntryInfoByPathSync(kFilePath2);
   ASSERT_TRUE(entry.get());
   EXPECT_EQ("file:slash_file_resource_id", entry->resource_id());
 
   const base::FilePath kFilePath3 = base::FilePath::FromUTF8Unsafe(
-      "drive/Slash \xE2\x88\x95 in directory/Slash SubDir File.txt");
+      "drive/root/Slash \xE2\x88\x95 in directory/Slash SubDir File.txt");
   entry = GetEntryInfoByPathSync(kFilePath3);
   ASSERT_TRUE(entry.get());
   EXPECT_EQ("file:slash_subdir_file", entry->resource_id());
 }
 
 TEST_F(DriveFileSystemTest, SearchEncodedFileNamesLoadingRoot) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
   const base::FilePath kFilePath1 = base::FilePath(
-      FILE_PATH_LITERAL("drive/Slash / in file 1.txt"));
+      FILE_PATH_LITERAL("drive/root/Slash / in file 1.txt"));
   scoped_ptr<DriveEntryProto> entry = GetEntryInfoByPathSync(kFilePath1);
   ASSERT_FALSE(entry.get());
 
   const base::FilePath kFilePath2 = base::FilePath::FromUTF8Unsafe(
-      "drive/Slash \xE2\x88\x95 in file 1.txt");
+      "drive/root/Slash \xE2\x88\x95 in file 1.txt");
   entry = GetEntryInfoByPathSync(kFilePath2);
   ASSERT_TRUE(entry.get());
   EXPECT_EQ("file:slash_file_resource_id", entry->resource_id());
 
   const base::FilePath kFilePath3 = base::FilePath::FromUTF8Unsafe(
-      "drive/Slash \xE2\x88\x95 in directory/Slash SubDir File.txt");
+      "drive/root/Slash \xE2\x88\x95 in directory/Slash SubDir File.txt");
   entry = GetEntryInfoByPathSync(kFilePath3);
   ASSERT_TRUE(entry.get());
   EXPECT_EQ("file:slash_subdir_file", entry->resource_id());
 }
 
 TEST_F(DriveFileSystemTest, SearchDuplicateNames) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
   const base::FilePath kFilePath1 = base::FilePath(
-      FILE_PATH_LITERAL("drive/Duplicate Name.txt"));
+      FILE_PATH_LITERAL("drive/root/Duplicate Name.txt"));
   scoped_ptr<DriveEntryProto> entry = GetEntryInfoByPathSync(kFilePath1);
   ASSERT_TRUE(entry.get());
   const std::string resource_id1 = entry->resource_id();
 
   const base::FilePath kFilePath2 = base::FilePath(
-      FILE_PATH_LITERAL("drive/Duplicate Name (2).txt"));
+      FILE_PATH_LITERAL("drive/root/Duplicate Name (2).txt"));
   entry = GetEntryInfoByPathSync(kFilePath2);
   ASSERT_TRUE(entry.get());
   const std::string resource_id2 = entry->resource_id();
 
   // The entries are de-duped non-deterministically, so we shouldn't rely on the
   // names matching specific resource ids.
   const std::string file3_resource_id = "file:3_file_resource_id";
   const std::string file4_resource_id = "file:4_file_resource_id";
   EXPECT_TRUE(file3_resource_id == resource_id1 ||
               file3_resource_id == resource_id2);
   EXPECT_TRUE(file4_resource_id == resource_id1 ||
               file4_resource_id == resource_id2);
 }
 
 TEST_F(DriveFileSystemTest, SearchExistingDirectory) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
   const base::FilePath kFilePath = base::FilePath(
-      FILE_PATH_LITERAL("drive/Directory 1"));
+      FILE_PATH_LITERAL("drive/root/Directory 1"));
   scoped_ptr<DriveEntryProto> entry = GetEntryInfoByPathSync(kFilePath);
   ASSERT_TRUE(entry.get());
   ASSERT_EQ("folder:1_folder_resource_id", entry->resource_id());
 
   // The changestamp should be propagated to the directory.
   EXPECT_EQ(fake_drive_service_->largest_changestamp(),
             entry->directory_specific_info().changestamp());
 }
 
 TEST_F(DriveFileSystemTest, SearchInSubdir) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
   const base::FilePath kFilePath = base::FilePath(
-      FILE_PATH_LITERAL("drive/Directory 1/SubDirectory File 1.txt"));
+      FILE_PATH_LITERAL("drive/root/Directory 1/SubDirectory File 1.txt"));
   scoped_ptr<DriveEntryProto> entry = GetEntryInfoByPathSync(kFilePath);
   ASSERT_TRUE(entry.get());
   ASSERT_EQ("file:subdirectory_file_1_id", entry->resource_id());
 }
 
 // Check the reconstruction of the directory structure from only the root feed.
 TEST_F(DriveFileSystemTest, SearchInSubSubdir) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
   const base::FilePath kFilePath = base::FilePath(
-      FILE_PATH_LITERAL("drive/Directory 1/Sub Directory Folder/"
+      FILE_PATH_LITERAL("drive/root/Directory 1/Sub Directory Folder/"
                         "Sub Sub Directory Folder"));
   scoped_ptr<DriveEntryProto> entry = GetEntryInfoByPathSync(kFilePath);
   ASSERT_TRUE(entry.get());
   ASSERT_EQ("folder:sub_sub_directory_folder_id", entry->resource_id());
 }
 
 TEST_F(DriveFileSystemTest, ReadDirectoryByPath_Root) {
-  // The root directory will be loaded that triggers the event.
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
-      Eq(base::FilePath(FILE_PATH_LITERAL("drive"))))).Times(1);
+      Eq(base::FilePath(FILE_PATH_LITERAL("drive/root"))))).Times(1);
 
   // ReadDirectoryByPath() should kick off the resource list loading.
   scoped_ptr<DriveEntryProtoVector> entries(
-      ReadDirectoryByPathSync(base::FilePath::FromUTF8Unsafe("drive")));
+      ReadDirectoryByPathSync(base::FilePath::FromUTF8Unsafe("drive/root")));
   // The root directory should be read correctly.
   ASSERT_TRUE(entries.get());
   EXPECT_EQ(8U, entries->size());
 }
 
 TEST_F(DriveFileSystemTest, ReadDirectoryByPath_NonRootDirectory) {
   // ReadDirectoryByPath() should kick off the resource list loading.
   scoped_ptr<DriveEntryProtoVector> entries(
       ReadDirectoryByPathSync(
-          base::FilePath::FromUTF8Unsafe("drive/Directory 1")));
+          base::FilePath::FromUTF8Unsafe("drive/root/Directory 1")));
   // The non root directory should also be read correctly.
   // There was a bug (crbug.com/181487), which broke this behavior.
   // Make sure this is fixed.
   ASSERT_TRUE(entries.get());
   EXPECT_EQ(3U, entries->size());
 }
 
 TEST_F(DriveFileSystemTest, FilePathTests) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
   EXPECT_TRUE(
-      EntryExists(base::FilePath(FILE_PATH_LITERAL("drive/File 1.txt"))));
+      EntryExists(base::FilePath(FILE_PATH_LITERAL("drive/root/File 1.txt"))));
   EXPECT_TRUE(
-      EntryExists(base::FilePath(FILE_PATH_LITERAL("drive/Directory 1"))));
-  EXPECT_TRUE(EntryExists(
-      base::FilePath(
-          FILE_PATH_LITERAL("drive/Directory 1/SubDirectory File 1.txt"))));
+      EntryExists(base::FilePath(FILE_PATH_LITERAL("drive/root/Directory 1"))));
+  EXPECT_TRUE(EntryExists(base::FilePath(
+      FILE_PATH_LITERAL("drive/root/Directory 1/SubDirectory File 1.txt"))));
 }
 
 TEST_F(DriveFileSystemTest, ChangeFeed_AddAndDeleteFileInRoot) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
-      Eq(base::FilePath(FILE_PATH_LITERAL("drive"))))).Times(2);
+      Eq(base::FilePath(FILE_PATH_LITERAL("drive/root"))))).Times(2);
 
   ASSERT_TRUE(LoadChangeFeed("chromeos/gdata/delta_file_added_in_root.json"));
-  EXPECT_TRUE(
-      EntryExists(base::FilePath(FILE_PATH_LITERAL("drive/Added file.gdoc"))));
+  EXPECT_TRUE(EntryExists(
+      base::FilePath(FILE_PATH_LITERAL("drive/root/Added file.gdoc"))));
 
   ASSERT_TRUE(LoadChangeFeed("chromeos/gdata/delta_file_deleted_in_root.json"));
-  EXPECT_FALSE(
-      EntryExists(base::FilePath(FILE_PATH_LITERAL("drive/Added file.gdoc"))));
+  EXPECT_FALSE(EntryExists(
+      base::FilePath(FILE_PATH_LITERAL("drive/root/Added file.gdoc"))));
 }
 
 
 TEST_F(DriveFileSystemTest, ChangeFeed_AddAndDeleteFileFromExistingDirectory) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
   EXPECT_TRUE(
-      EntryExists(base::FilePath(FILE_PATH_LITERAL("drive/Directory 1"))));
+      EntryExists(base::FilePath(FILE_PATH_LITERAL("drive/root/Directory 1"))));
 
   // Add file to an existing directory.
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
-      Eq(base::FilePath(FILE_PATH_LITERAL("drive"))))).Times(1);
+      Eq(base::FilePath(FILE_PATH_LITERAL("drive/root"))))).Times(1);
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
-      Eq(base::FilePath(FILE_PATH_LITERAL("drive/Directory 1"))))).Times(1);
+      Eq(base::FilePath(FILE_PATH_LITERAL("drive/root/Directory 1")))))
+      .Times(1);
   ASSERT_TRUE(
       LoadChangeFeed("chromeos/gdata/delta_file_added_in_directory.json"));
   EXPECT_TRUE(EntryExists(base::FilePath(
-      FILE_PATH_LITERAL("drive/Directory 1/Added file.gdoc"))));
+      FILE_PATH_LITERAL("drive/root/Directory 1/Added file.gdoc"))));
 
   // Remove that file from the directory.
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
-      Eq(base::FilePath(FILE_PATH_LITERAL("drive/Directory 1"))))).Times(1);
+      Eq(base::FilePath(FILE_PATH_LITERAL("drive/root/Directory 1")))))
+      .Times(1);
   ASSERT_TRUE(
       LoadChangeFeed("chromeos/gdata/delta_file_deleted_in_directory.json"));
   EXPECT_TRUE(
-      EntryExists(base::FilePath(FILE_PATH_LITERAL("drive/Directory 1"))));
+      EntryExists(base::FilePath(FILE_PATH_LITERAL("drive/root/Directory 1"))));
   EXPECT_FALSE(EntryExists(base::FilePath(
-      FILE_PATH_LITERAL("drive/Directory 1/Added file.gdoc"))));
+      FILE_PATH_LITERAL("drive/root/Directory 1/Added file.gdoc"))));
 }
 
 TEST_F(DriveFileSystemTest, ChangeFeed_AddFileToNewDirectory) {
   ASSERT_TRUE(LoadRootFeedDocument());
   // Add file to a new directory.
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
-      Eq(base::FilePath(FILE_PATH_LITERAL("drive"))))).Times(1);
+      Eq(base::FilePath(FILE_PATH_LITERAL("drive/root"))))).Times(1);
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
-      Eq(base::FilePath(FILE_PATH_LITERAL("drive/New Directory"))))).Times(1);
+      Eq(base::FilePath(FILE_PATH_LITERAL("drive/root/New Directory")))))
+      .Times(1);
 
   ASSERT_TRUE(
       LoadChangeFeed("chromeos/gdata/delta_file_added_in_new_directory.json"));
 
   EXPECT_TRUE(
-      EntryExists(base::FilePath(FILE_PATH_LITERAL("drive/New Directory"))));
+      EntryExists(base::FilePath(
+          FILE_PATH_LITERAL("drive/root/New Directory"))));
   EXPECT_TRUE(EntryExists(base::FilePath(
-      FILE_PATH_LITERAL("drive/New Directory/File in new dir.gdoc"))));
+      FILE_PATH_LITERAL("drive/root/New Directory/File in new dir.gdoc"))));
 }
 
 TEST_F(DriveFileSystemTest, ChangeFeed_AddFileToNewButDeletedDirectory) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
   // This feed contains the following updates:
   // 1) A new PDF file is added to a new directory
   // 2) but the new directory is marked "deleted" (i.e. moved to Trash)
   // Hence, the PDF file should be just ignored.
   ASSERT_TRUE(LoadChangeFeed(
       "chromeos/gdata/delta_file_added_in_new_but_deleted_directory.json"));
 }
 
 TEST_F(DriveFileSystemTest, ChangeFeed_DirectoryMovedFromRootToDirectory) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
   EXPECT_TRUE(EntryExists(base::FilePath(FILE_PATH_LITERAL(
-      "drive/Directory 2"))));
+      "drive/root/Directory 2"))));
   EXPECT_TRUE(EntryExists(base::FilePath(FILE_PATH_LITERAL(
-      "drive/Directory 1"))));
+      "drive/root/Directory 1"))));
   EXPECT_TRUE(EntryExists(base::FilePath(FILE_PATH_LITERAL(
-      "drive/Directory 1/SubDirectory File 1.txt"))));
+      "drive/root/Directory 1/SubDirectory File 1.txt"))));
   EXPECT_TRUE(EntryExists(base::FilePath(FILE_PATH_LITERAL(
-      "drive/Directory 1/Sub Directory Folder"))));
+      "drive/root/Directory 1/Sub Directory Folder"))));
   EXPECT_TRUE(EntryExists(base::FilePath(FILE_PATH_LITERAL(
-      "drive/Directory 1/Sub Directory Folder/Sub Sub Directory Folder"))));
+      "drive/root/Directory 1/Sub Directory Folder/"
+      "Sub Sub Directory Folder"))));
 
-  // This will move "Directory 1" from "drive/" to "drive/Directory 2/".
+  // This will move "Directory 1" from "drive/root/" to
+  // "drive/root/Directory 2/".
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
-      Eq(base::FilePath(FILE_PATH_LITERAL("drive"))))).Times(1);
+      Eq(base::FilePath(FILE_PATH_LITERAL("drive/root"))))).Times(1);
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
-      Eq(base::FilePath(FILE_PATH_LITERAL("drive/Directory 1"))))).Times(1);
+      Eq(base::FilePath(FILE_PATH_LITERAL("drive/root/Directory 1")))))
+      .Times(1);
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
-      Eq(base::FilePath(FILE_PATH_LITERAL("drive/Directory 2"))))).Times(1);
+      Eq(base::FilePath(FILE_PATH_LITERAL("drive/root/Directory 2")))))
+      .Times(1);
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
-      Eq(base::FilePath(FILE_PATH_LITERAL("drive/Directory 2/Directory 1")))))
-      .Times(1);
+      Eq(base::FilePath(
+          FILE_PATH_LITERAL("drive/root/Directory 2/Directory 1"))))).Times(1);
   ASSERT_TRUE(LoadChangeFeed(
       "chromeos/gdata/delta_dir_moved_from_root_to_directory.json"));
 
   EXPECT_TRUE(EntryExists(base::FilePath(FILE_PATH_LITERAL(
-      "drive/Directory 2"))));
+      "drive/root/Directory 2"))));
   EXPECT_FALSE(EntryExists(base::FilePath(FILE_PATH_LITERAL(
-      "drive/Directory 1"))));
+      "drive/root/Directory 1"))));
   EXPECT_TRUE(EntryExists(base::FilePath(FILE_PATH_LITERAL(
-      "drive/Directory 2/Directory 1"))));
+      "drive/root/Directory 2/Directory 1"))));
   EXPECT_TRUE(EntryExists(base::FilePath(FILE_PATH_LITERAL(
-      "drive/Directory 2/Directory 1/SubDirectory File 1.txt"))));
+      "drive/root/Directory 2/Directory 1/SubDirectory File 1.txt"))));
   EXPECT_TRUE(EntryExists(base::FilePath(FILE_PATH_LITERAL(
-      "drive/Directory 2/Directory 1/Sub Directory Folder"))));
+      "drive/root/Directory 2/Directory 1/Sub Directory Folder"))));
   EXPECT_TRUE(EntryExists(base::FilePath(FILE_PATH_LITERAL(
-      "drive/Directory 2/Directory 1/Sub Directory Folder/"
+      "drive/root/Directory 2/Directory 1/Sub Directory Folder/"
       "Sub Sub Directory Folder"))));
 }
 
 TEST_F(DriveFileSystemTest, ChangeFeed_FileMovedFromDirectoryToRoot) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
   EXPECT_TRUE(EntryExists(base::FilePath(FILE_PATH_LITERAL(
-      "drive/Directory 1"))));
+      "drive/root/Directory 1"))));
   EXPECT_TRUE(EntryExists(base::FilePath(FILE_PATH_LITERAL(
-      "drive/Directory 1/Sub Directory Folder"))));
+      "drive/root/Directory 1/Sub Directory Folder"))));
   EXPECT_TRUE(EntryExists(base::FilePath(FILE_PATH_LITERAL(
-      "drive/Directory 1/Sub Directory Folder/Sub Sub Directory Folder"))));
+      "drive/root/Directory 1/Sub Directory Folder/"
+      "Sub Sub Directory Folder"))));
   EXPECT_TRUE(EntryExists(base::FilePath(FILE_PATH_LITERAL(
-      "drive/Directory 1/SubDirectory File 1.txt"))));
+      "drive/root/Directory 1/SubDirectory File 1.txt"))));
 
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
-      Eq(base::FilePath(FILE_PATH_LITERAL("drive"))))).Times(1);
+      Eq(base::FilePath(FILE_PATH_LITERAL("drive/root"))))).Times(1);
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
-      Eq(base::FilePath(FILE_PATH_LITERAL("drive/Directory 1"))))).Times(1);
+      Eq(base::FilePath(FILE_PATH_LITERAL("drive/root/Directory 1")))))
+      .Times(1);
   ASSERT_TRUE(LoadChangeFeed(
       "chromeos/gdata/delta_file_moved_from_directory_to_root.json"));
 
   EXPECT_TRUE(EntryExists(base::FilePath(FILE_PATH_LITERAL(
-      "drive/Directory 1"))));
+      "drive/root/Directory 1"))));
   EXPECT_TRUE(EntryExists(base::FilePath(FILE_PATH_LITERAL(
-      "drive/Directory 1/Sub Directory Folder"))));
+      "drive/root/Directory 1/Sub Directory Folder"))));
   EXPECT_TRUE(EntryExists(base::FilePath(FILE_PATH_LITERAL(
-      "drive/Directory 1/Sub Directory Folder/Sub Sub Directory Folder"))));
+      "drive/root/Directory 1/Sub Directory Folder/"
+      "Sub Sub Directory Folder"))));
   EXPECT_FALSE(EntryExists(base::FilePath(FILE_PATH_LITERAL(
-      "drive/Directory 1/SubDirectory File 1.txt"))));
+      "drive/root/Directory 1/SubDirectory File 1.txt"))));
   EXPECT_TRUE(EntryExists(base::FilePath(FILE_PATH_LITERAL(
-      "drive/SubDirectory File 1.txt"))));
+      "drive/root/SubDirectory File 1.txt"))));
 }
 
 TEST_F(DriveFileSystemTest, ChangeFeed_FileRenamedInDirectory) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
   EXPECT_TRUE(EntryExists(base::FilePath(FILE_PATH_LITERAL(
-      "drive/Directory 1"))));
+      "drive/root/Directory 1"))));
   EXPECT_TRUE(EntryExists(base::FilePath(FILE_PATH_LITERAL(
-      "drive/Directory 1/SubDirectory File 1.txt"))));
+      "drive/root/Directory 1/SubDirectory File 1.txt"))));
 
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
-      Eq(base::FilePath(FILE_PATH_LITERAL("drive"))))).Times(1);
+      Eq(base::FilePath(FILE_PATH_LITERAL("drive/root"))))).Times(1);
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
-      Eq(base::FilePath(FILE_PATH_LITERAL("drive/Directory 1"))))).Times(1);
+      Eq(base::FilePath(FILE_PATH_LITERAL("drive/root/Directory 1")))))
+      .Times(1);
   ASSERT_TRUE(LoadChangeFeed(
       "chromeos/gdata/delta_file_renamed_in_directory.json"));
 
   EXPECT_TRUE(EntryExists(base::FilePath(FILE_PATH_LITERAL(
-      "drive/Directory 1"))));
+      "drive/root/Directory 1"))));
   EXPECT_FALSE(EntryExists(base::FilePath(FILE_PATH_LITERAL(
-      "drive/Directory 1/SubDirectory File 1.txt"))));
+      "drive/root/Directory 1/SubDirectory File 1.txt"))));
   EXPECT_TRUE(EntryExists(base::FilePath(FILE_PATH_LITERAL(
-      "drive/Directory 1/New SubDirectory File 1.txt"))));
+      "drive/root/Directory 1/New SubDirectory File 1.txt"))));
 }
 
 TEST_F(DriveFileSystemTest, CachedFeedLoading) {
   ASSERT_TRUE(SaveTestFileSystem(USE_OLD_TIMESTAMP));
   // Tests that cached data can be loaded even if the server is not reachable.
   fake_drive_service_->set_offline(true);
 
-  EXPECT_TRUE(EntryExists(base::FilePath(FILE_PATH_LITERAL("drive/File1"))));
-  EXPECT_TRUE(EntryExists(base::FilePath(FILE_PATH_LITERAL("drive/Dir1"))));
+  EXPECT_TRUE(EntryExists(base::FilePath(
+      FILE_PATH_LITERAL("drive/root/File1"))));
+  EXPECT_TRUE(EntryExists(base::FilePath(
+      FILE_PATH_LITERAL("drive/root/Dir1"))));
   EXPECT_TRUE(
-      EntryExists(base::FilePath(FILE_PATH_LITERAL("drive/Dir1/File2"))));
-  EXPECT_TRUE(
-      EntryExists(base::FilePath(FILE_PATH_LITERAL("drive/Dir1/SubDir2"))));
+      EntryExists(base::FilePath(FILE_PATH_LITERAL("drive/root/Dir1/File2"))));
+  EXPECT_TRUE(EntryExists(base::FilePath(
+      FILE_PATH_LITERAL("drive/root/Dir1/SubDir2"))));
   EXPECT_TRUE(EntryExists(
-      base::FilePath(FILE_PATH_LITERAL("drive/Dir1/SubDir2/File3"))));
+      base::FilePath(FILE_PATH_LITERAL("drive/root/Dir1/SubDir2/File3"))));
 }
 
 TEST_F(DriveFileSystemTest, CachedFeedLoadingThenServerFeedLoading) {
   ASSERT_TRUE(SaveTestFileSystem(USE_SERVER_TIMESTAMP));
 
   // Kicks loading of cached file system and query for server update.
   EXPECT_TRUE(ReadDirectoryByPathSync(util::GetDriveMyDriveRootPath()));
 
   // SaveTestFileSystem and "account_metadata.json" have the same changestamp,
   // so no request for new feeds (i.e., call to GetResourceList) should happen.
@@ skipping 36 matching lines @@
   EXPECT_EQ(1, fake_drive_service_->resource_list_load_count());
 }
 
 TEST_F(DriveFileSystemTest, TransferFileFromLocalToRemote_RegularFile) {
   fake_free_disk_space_getter_->set_fake_free_disk_space(kLotsOfSpace);
 
   ASSERT_TRUE(LoadRootFeedDocument());
 
   // We'll add a file to the Drive root directory.
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
-      Eq(base::FilePath(FILE_PATH_LITERAL("drive"))))).Times(1);
+      Eq(base::FilePath(FILE_PATH_LITERAL("drive/root"))))).Times(1);
 
   // Prepare a local file.
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   const base::FilePath local_src_file_path =
       temp_dir.path().AppendASCII("local.txt");
   const std::string kContent = "hello";
   file_util::WriteFile(local_src_file_path, kContent.data(), kContent.size());
 
   // Confirm that the remote file does not exist.
   const base::FilePath remote_dest_file_path(
-      FILE_PATH_LITERAL("drive/remote.txt"));
+      FILE_PATH_LITERAL("drive/root/remote.txt"));
   EXPECT_FALSE(EntryExists(remote_dest_file_path));
 
   // Transfer the local file to Drive.
   DriveFileError error = DRIVE_FILE_ERROR_FAILED;
   file_system_->TransferFileFromLocalToRemote(
       local_src_file_path,
       remote_dest_file_path,
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
 
@@ skipping 15 matching lines @@
   const std::string kEditUrl =
       "https://3_document_self_link/document:5_document_resource_id";
   const std::string kResourceId = "document:5_document_resource_id";
   const std::string kContent =
       base::StringPrintf("{\"url\": \"%s\", \"resource_id\": \"%s\"}",
                          kEditUrl.c_str(), kResourceId.c_str());
   file_util::WriteFile(local_src_file_path, kContent.data(), kContent.size());
 
   // Confirm that the remote file does not exist.
   const base::FilePath remote_dest_file_path(
-      FILE_PATH_LITERAL("drive/Directory 1/Document 1.gdoc"));
+      FILE_PATH_LITERAL("drive/root/Directory 1/Document 1.gdoc"));
   EXPECT_FALSE(EntryExists(remote_dest_file_path));
 
   // We'll add a file to the Drive root and then move to "Directory 1".
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
-      Eq(base::FilePath(FILE_PATH_LITERAL("drive"))))).Times(1);
+      Eq(base::FilePath(FILE_PATH_LITERAL("drive/root"))))).Times(1);
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
-      Eq(base::FilePath(FILE_PATH_LITERAL("drive/Directory 1"))))).Times(1);
+      Eq(base::FilePath(FILE_PATH_LITERAL("drive/root/Directory 1")))))
+      .Times(1);
 
   // We'll copy a hosted document using CopyHostedDocument.
   // ".gdoc" suffix should be stripped when copying.
   scoped_ptr<base::Value> value =
       google_apis::test_util::LoadJSONFile(
           "chromeos/gdata/uploaded_document.json");
   scoped_ptr<google_apis::ResourceEntry> resource_entry =
       google_apis::ResourceEntry::ExtractAndParse(*value);
 
 
@@ skipping 10 matching lines @@
   // Now the remote file should exist.
   EXPECT_TRUE(EntryExists(remote_dest_file_path));
 }
 
 TEST_F(DriveFileSystemTest, TransferFileFromRemoteToLocal_RegularFile) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
   // The transfered file is cached and the change of "offline available"
   // attribute is notified.
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
-      Eq(base::FilePath(FILE_PATH_LITERAL("drive"))))).Times(1);
+      Eq(base::FilePath(FILE_PATH_LITERAL("drive/root"))))).Times(1);
 
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   base::FilePath local_dest_file_path =
       temp_dir.path().AppendASCII("local_copy.txt");
 
-  base::FilePath remote_src_file_path(FILE_PATH_LITERAL("drive/File 1.txt"));
+  base::FilePath remote_src_file_path(
+      FILE_PATH_LITERAL("drive/root/File 1.txt"));
   scoped_ptr<DriveEntryProto> file = GetEntryInfoByPathSync(
       remote_src_file_path);
   const int64 file_size = file->file_info().size();
 
   // Pretend we have enough space.
   fake_free_disk_space_getter_->set_fake_free_disk_space(
       file_size + kMinFreeSpace);
 
   DriveFileError error = DRIVE_FILE_ERROR_FAILED;
   file_system_->TransferFileFromRemoteToLocal(
@@ skipping 25 matching lines @@
 }
 
 TEST_F(DriveFileSystemTest, TransferFileFromRemoteToLocal_HostedDocument) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   base::FilePath local_dest_file_path =
       temp_dir.path().AppendASCII("local_copy.txt");
   base::FilePath remote_src_file_path(
-      FILE_PATH_LITERAL("drive/Document 1.gdoc"));
+      FILE_PATH_LITERAL("drive/root/Document 1.gdoc"));
   DriveFileError error = DRIVE_FILE_ERROR_FAILED;
   file_system_->TransferFileFromRemoteToLocal(
       remote_src_file_path,
       local_dest_file_path,
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
 
   EXPECT_EQ(DRIVE_FILE_OK, error);
 
   scoped_ptr<DriveEntryProto> entry_proto = GetEntryInfoByPathSync(
       remote_src_file_path);
   ASSERT_TRUE(entry_proto.get());
   VerifyHostedDocumentJSONFile(*entry_proto, local_dest_file_path);
 }
 
 TEST_F(DriveFileSystemTest, CopyNotExistingFile) {
-  base::FilePath src_file_path(FILE_PATH_LITERAL("drive/Dummy file.txt"));
-  base::FilePath dest_file_path(FILE_PATH_LITERAL("drive/Test.log"));
+  base::FilePath src_file_path(FILE_PATH_LITERAL("drive/root/Dummy file.txt"));
+  base::FilePath dest_file_path(FILE_PATH_LITERAL("drive/root/Test.log"));
 
   ASSERT_TRUE(LoadRootFeedDocument());
 
   EXPECT_FALSE(EntryExists(src_file_path));
 
   DriveFileError error = DRIVE_FILE_OK;
   file_system_->Copy(
       src_file_path,
       dest_file_path,
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_ERROR_NOT_FOUND, error);
 
   EXPECT_FALSE(EntryExists(src_file_path));
   EXPECT_FALSE(EntryExists(dest_file_path));
 }
 
 TEST_F(DriveFileSystemTest, CopyFileToNonExistingDirectory) {
-  base::FilePath src_file_path(FILE_PATH_LITERAL("drive/File 1.txt"));
-  base::FilePath dest_parent_path(FILE_PATH_LITERAL("drive/Dummy"));
-  base::FilePath dest_file_path(FILE_PATH_LITERAL("drive/Dummy/Test.log"));
+  base::FilePath src_file_path(FILE_PATH_LITERAL("drive/root/File 1.txt"));
+  base::FilePath dest_parent_path(FILE_PATH_LITERAL("drive/root/Dummy"));
+  base::FilePath dest_file_path(FILE_PATH_LITERAL("drive/root/Dummy/Test.log"));
 
   ASSERT_TRUE(LoadRootFeedDocument());
 
   ASSERT_TRUE(EntryExists(src_file_path));
   scoped_ptr<DriveEntryProto> src_entry_proto = GetEntryInfoByPathSync(
       src_file_path);
   ASSERT_TRUE(src_entry_proto.get());
   std::string src_file_path_resource_id =
       src_entry_proto->resource_id();
   EXPECT_FALSE(src_entry_proto->edit_url().empty());
 
   EXPECT_FALSE(EntryExists(dest_parent_path));
 
   DriveFileError error = DRIVE_FILE_OK;
   file_system_->Move(
       src_file_path,
       dest_file_path,
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_ERROR_NOT_FOUND, error);
 
   EXPECT_TRUE(EntryExists(src_file_path));
   EXPECT_FALSE(EntryExists(dest_parent_path));
   EXPECT_FALSE(EntryExists(dest_file_path));
 }
 
 // Test the case where the parent of |dest_file_path| is an existing file,
 // not a directory.
 TEST_F(DriveFileSystemTest, CopyFileToInvalidPath) {
-  base::FilePath src_file_path(FILE_PATH_LITERAL("drive/Document 1.gdoc"));
+  base::FilePath src_file_path(FILE_PATH_LITERAL("drive/root/Document 1.gdoc"));
   base::FilePath dest_parent_path(
-      FILE_PATH_LITERAL("drive/Duplicate Name.txt"));
+      FILE_PATH_LITERAL("drive/root/Duplicate Name.txt"));
   base::FilePath dest_file_path(FILE_PATH_LITERAL(
-      "drive/Duplicate Name.txt/Document 1.gdoc"));
+      "drive/root/Duplicate Name.txt/Document 1.gdoc"));
 
   ASSERT_TRUE(LoadRootFeedDocument());
 
   ASSERT_TRUE(EntryExists(src_file_path));
   scoped_ptr<DriveEntryProto> src_entry_proto = GetEntryInfoByPathSync(
       src_file_path);
   ASSERT_TRUE(src_entry_proto.get());
   std::string src_file_resource_id =
       src_entry_proto->resource_id();
   EXPECT_FALSE(src_entry_proto->edit_url().empty());
@@ skipping 13 matching lines @@
 
   EXPECT_TRUE(EntryExists(src_file_path));
   EXPECT_TRUE(EntryExists(src_file_path));
   EXPECT_TRUE(EntryExists(dest_parent_path));
 
   EXPECT_FALSE(EntryExists(dest_file_path));
 }
 
 TEST_F(DriveFileSystemTest, RenameFile) {
   const base::FilePath src_file_path(
-      FILE_PATH_LITERAL("drive/Directory 1/SubDirectory File 1.txt"));
-  const base::FilePath src_parent_path(FILE_PATH_LITERAL("drive/Directory 1"));
+      FILE_PATH_LITERAL("drive/root/Directory 1/SubDirectory File 1.txt"));
+  const base::FilePath src_parent_path(
+      FILE_PATH_LITERAL("drive/root/Directory 1"));
   const base::FilePath dest_file_path(
-      FILE_PATH_LITERAL("drive/Directory 1/Test.log"));
+      FILE_PATH_LITERAL("drive/root/Directory 1/Test.log"));
 
   ASSERT_TRUE(LoadRootFeedDocument());
 
   ASSERT_TRUE(EntryExists(src_file_path));
   scoped_ptr<DriveEntryProto> src_entry_proto = GetEntryInfoByPathSync(
       src_file_path);
   ASSERT_TRUE(src_entry_proto.get());
   std::string src_file_resource_id =
       src_entry_proto->resource_id();
 
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
-      Eq(base::FilePath(FILE_PATH_LITERAL("drive/Directory 1"))))).Times(1);
+      Eq(base::FilePath(FILE_PATH_LITERAL("drive/root/Directory 1")))))
+      .Times(1);
 
   DriveFileError error = DRIVE_FILE_ERROR_FAILED;
   file_system_->Move(
       src_file_path,
       dest_file_path,
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_OK, error);
 
   EXPECT_FALSE(EntryExists(src_file_path));
   EXPECT_TRUE(EntryExists(dest_file_path));
   EXPECT_EQ(src_file_resource_id, GetResourceIdByPath(dest_file_path));
 }
 
 TEST_F(DriveFileSystemTest, MoveFileFromRootToSubDirectory) {
-  base::FilePath src_file_path(FILE_PATH_LITERAL("drive/File 1.txt"));
-  base::FilePath dest_parent_path(FILE_PATH_LITERAL("drive/Directory 1"));
+  base::FilePath src_file_path(FILE_PATH_LITERAL("drive/root/File 1.txt"));
+  base::FilePath dest_parent_path(FILE_PATH_LITERAL("drive/root/Directory 1"));
   base::FilePath dest_file_path(
-      FILE_PATH_LITERAL("drive/Directory 1/Test.log"));
+      FILE_PATH_LITERAL("drive/root/Directory 1/Test.log"));
 
   ASSERT_TRUE(LoadRootFeedDocument());
 
   ASSERT_TRUE(EntryExists(src_file_path));
   scoped_ptr<DriveEntryProto> src_entry_proto = GetEntryInfoByPathSync(
       src_file_path);
   ASSERT_TRUE(src_entry_proto.get());
   std::string src_file_resource_id =
       src_entry_proto->resource_id();
   EXPECT_FALSE(src_entry_proto->edit_url().empty());
 
   ASSERT_TRUE(EntryExists(dest_parent_path));
   scoped_ptr<DriveEntryProto> dest_parent_proto = GetEntryInfoByPathSync(
       dest_parent_path);
   ASSERT_TRUE(dest_parent_proto.get());
   ASSERT_TRUE(dest_parent_proto->file_info().is_directory());
   EXPECT_FALSE(dest_parent_proto->download_url().empty());
 
   // Expect notification for both source and destination directories.
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
-      Eq(base::FilePath(FILE_PATH_LITERAL("drive"))))).Times(1);
+      Eq(base::FilePath(FILE_PATH_LITERAL("drive/root"))))).Times(1);
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
-      Eq(base::FilePath(FILE_PATH_LITERAL("drive/Directory 1"))))).Times(1);
+      Eq(base::FilePath(FILE_PATH_LITERAL("drive/root/Directory 1")))))
+      .Times(1);
 
   DriveFileError error = DRIVE_FILE_ERROR_FAILED;
   file_system_->Move(
       src_file_path,
       dest_file_path,
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_OK, error);
 
   EXPECT_FALSE(EntryExists(src_file_path));
   EXPECT_TRUE(EntryExists(dest_file_path));
   EXPECT_EQ(src_file_resource_id, GetResourceIdByPath(dest_file_path));
 }
 
 TEST_F(DriveFileSystemTest, MoveFileFromSubDirectoryToRoot) {
-  base::FilePath src_parent_path(FILE_PATH_LITERAL("drive/Directory 1"));
+  base::FilePath src_parent_path(FILE_PATH_LITERAL("drive/root/Directory 1"));
   base::FilePath src_file_path(
-      FILE_PATH_LITERAL("drive/Directory 1/SubDirectory File 1.txt"));
-  base::FilePath dest_file_path(FILE_PATH_LITERAL("drive/Test.log"));
+      FILE_PATH_LITERAL("drive/root/Directory 1/SubDirectory File 1.txt"));
+  base::FilePath dest_file_path(FILE_PATH_LITERAL("drive/root/Test.log"));
 
   ASSERT_TRUE(LoadRootFeedDocument());
 
   ASSERT_TRUE(EntryExists(src_file_path));
   scoped_ptr<DriveEntryProto> src_entry_proto = GetEntryInfoByPathSync(
       src_file_path);
   ASSERT_TRUE(src_entry_proto.get());
   std::string src_file_resource_id =
       src_entry_proto->resource_id();
   EXPECT_FALSE(src_entry_proto->edit_url().empty());
 
   ASSERT_TRUE(EntryExists(src_parent_path));
   scoped_ptr<DriveEntryProto> src_parent_proto = GetEntryInfoByPathSync(
       src_parent_path);
   ASSERT_TRUE(src_parent_proto.get());
   ASSERT_TRUE(src_parent_proto->file_info().is_directory());
   EXPECT_FALSE(src_parent_proto->download_url().empty());
 
   // Expect notification for both source and destination directories.
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
-      Eq(base::FilePath(FILE_PATH_LITERAL("drive"))))).Times(1);
+      Eq(base::FilePath(FILE_PATH_LITERAL("drive/root"))))).Times(1);
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
-      Eq(base::FilePath(FILE_PATH_LITERAL("drive/Directory 1"))))).Times(1);
+      Eq(base::FilePath(FILE_PATH_LITERAL("drive/root/Directory 1")))))
+      .Times(1);
 
   DriveFileError error = DRIVE_FILE_ERROR_FAILED;
   file_system_->Move(
       src_file_path,
       dest_file_path,
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_OK, error);
 
   EXPECT_FALSE(EntryExists(src_file_path));
   ASSERT_TRUE(EntryExists(dest_file_path));
   EXPECT_EQ(src_file_resource_id, GetResourceIdByPath(dest_file_path));
 }
 
 TEST_F(DriveFileSystemTest, MoveFileBetweenSubDirectories) {
-  base::FilePath src_parent_path(FILE_PATH_LITERAL("drive/Directory 1"));
+  base::FilePath src_parent_path(FILE_PATH_LITERAL("drive/root/Directory 1"));
   base::FilePath src_file_path(
-      FILE_PATH_LITERAL("drive/Directory 1/SubDirectory File 1.txt"));
-  base::FilePath dest_parent_path(FILE_PATH_LITERAL("drive/New Folder 1"));
+      FILE_PATH_LITERAL("drive/root/Directory 1/SubDirectory File 1.txt"));
+  base::FilePath dest_parent_path(FILE_PATH_LITERAL("drive/root/New Folder 1"));
   base::FilePath dest_file_path(
-      FILE_PATH_LITERAL("drive/New Folder 1/Test.log"));
-  base::FilePath interim_file_path(FILE_PATH_LITERAL("drive/Test.log"));
+      FILE_PATH_LITERAL("drive/root/New Folder 1/Test.log"));
+  base::FilePath interim_file_path(FILE_PATH_LITERAL("drive/root/Test.log"));
 
   ASSERT_TRUE(LoadRootFeedDocument());
 
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
-      Eq(base::FilePath(FILE_PATH_LITERAL("drive"))))).Times(1);
+      Eq(base::FilePath(FILE_PATH_LITERAL("drive/root"))))).Times(1);
 
   AddDirectoryFromFile(dest_parent_path,
                        "chromeos/gdata/directory_entry_atom.json");
 
   ASSERT_TRUE(EntryExists(src_file_path));
   scoped_ptr<DriveEntryProto> src_entry_proto = GetEntryInfoByPathSync(
       src_file_path);
   ASSERT_TRUE(src_entry_proto.get());
   std::string src_file_resource_id =
       src_entry_proto->resource_id();
@@ skipping 10 matching lines @@
   scoped_ptr<DriveEntryProto> dest_parent_proto = GetEntryInfoByPathSync(
       dest_parent_path);
   ASSERT_TRUE(dest_parent_proto.get());
   ASSERT_TRUE(dest_parent_proto->file_info().is_directory());
   EXPECT_FALSE(dest_parent_proto->download_url().empty());
 
   EXPECT_FALSE(EntryExists(interim_file_path));
 
   // Expect notification for both source and destination directories.
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
-      Eq(base::FilePath(FILE_PATH_LITERAL("drive/Directory 1"))))).Times(1);
+      Eq(base::FilePath(FILE_PATH_LITERAL("drive/root/Directory 1")))))
+      .Times(1);
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
-      Eq(base::FilePath(FILE_PATH_LITERAL("drive/New Folder 1"))))).Times(1);
+      Eq(base::FilePath(FILE_PATH_LITERAL("drive/root/New Folder 1")))))
+      .Times(1);
 
   DriveFileError error = DRIVE_FILE_ERROR_FAILED;
   file_system_->Move(
       src_file_path,
       dest_file_path,
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_OK, error);
 
   EXPECT_FALSE(EntryExists(src_file_path));
   EXPECT_FALSE(EntryExists(interim_file_path));
 
   EXPECT_FALSE(EntryExists(src_file_path));
   EXPECT_TRUE(EntryExists(dest_file_path));
   EXPECT_EQ(src_file_resource_id, GetResourceIdByPath(dest_file_path));
 }
 
 TEST_F(DriveFileSystemTest, MoveNotExistingFile) {
-  base::FilePath src_file_path(FILE_PATH_LITERAL("drive/Dummy file.txt"));
-  base::FilePath dest_file_path(FILE_PATH_LITERAL("drive/Test.log"));
+  base::FilePath src_file_path(FILE_PATH_LITERAL("drive/root/Dummy file.txt"));
+  base::FilePath dest_file_path(FILE_PATH_LITERAL("drive/root/Test.log"));
 
   ASSERT_TRUE(LoadRootFeedDocument());
 
   EXPECT_FALSE(EntryExists(src_file_path));
 
   DriveFileError error = DRIVE_FILE_OK;
   file_system_->Move(
       src_file_path,
       dest_file_path,
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_ERROR_NOT_FOUND, error);
 
   EXPECT_FALSE(EntryExists(src_file_path));
   EXPECT_FALSE(EntryExists(dest_file_path));
 }
 
 TEST_F(DriveFileSystemTest, MoveFileToNonExistingDirectory) {
-  base::FilePath src_file_path(FILE_PATH_LITERAL("drive/File 1.txt"));
-  base::FilePath dest_parent_path(FILE_PATH_LITERAL("drive/Dummy"));
-  base::FilePath dest_file_path(FILE_PATH_LITERAL("drive/Dummy/Test.log"));
+  base::FilePath src_file_path(FILE_PATH_LITERAL("drive/root/File 1.txt"));
+  base::FilePath dest_parent_path(FILE_PATH_LITERAL("drive/root/Dummy"));
+  base::FilePath dest_file_path(FILE_PATH_LITERAL("drive/root/Dummy/Test.log"));
 
   ASSERT_TRUE(LoadRootFeedDocument());
 
   ASSERT_TRUE(EntryExists(src_file_path));
   scoped_ptr<DriveEntryProto> src_entry_proto = GetEntryInfoByPathSync(
       src_file_path);
   ASSERT_TRUE(src_entry_proto.get());
   std::string src_file_resource_id =
       src_entry_proto->resource_id();
   EXPECT_FALSE(src_entry_proto->edit_url().empty());
 
   EXPECT_FALSE(EntryExists(dest_parent_path));
 
   DriveFileError error = DRIVE_FILE_OK;
   file_system_->Move(
       src_file_path,
       dest_file_path,
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_ERROR_NOT_FOUND, error);
 
   EXPECT_FALSE(EntryExists(dest_parent_path));
   EXPECT_FALSE(EntryExists(dest_file_path));
 }
 
 // Test the case where the parent of |dest_file_path| is a existing file,
 // not a directory.
 TEST_F(DriveFileSystemTest, MoveFileToInvalidPath) {
-  base::FilePath src_file_path(FILE_PATH_LITERAL("drive/File 1.txt"));
+  base::FilePath src_file_path(FILE_PATH_LITERAL("drive/root/File 1.txt"));
   base::FilePath dest_parent_path(
-      FILE_PATH_LITERAL("drive/Duplicate Name.txt"));
+      FILE_PATH_LITERAL("drive/root/Duplicate Name.txt"));
   base::FilePath dest_file_path(FILE_PATH_LITERAL(
-      "drive/Duplicate Name.txt/Test.log"));
+      "drive/root/Duplicate Name.txt/Test.log"));
 
   ASSERT_TRUE(LoadRootFeedDocument());
 
   ASSERT_TRUE(EntryExists(src_file_path));
   scoped_ptr<DriveEntryProto> src_entry_proto = GetEntryInfoByPathSync(
       src_file_path);
   ASSERT_TRUE(src_entry_proto.get());
   std::string src_file_resource_id =
       src_entry_proto->resource_id();
   EXPECT_FALSE(src_entry_proto->edit_url().empty());
@@ skipping 12 matching lines @@
   EXPECT_EQ(DRIVE_FILE_ERROR_NOT_A_DIRECTORY, error);
 
   EXPECT_TRUE(EntryExists(src_file_path));
   EXPECT_TRUE(EntryExists(dest_parent_path));
   EXPECT_FALSE(EntryExists(dest_file_path));
 }
 
 TEST_F(DriveFileSystemTest, RemoveEntries) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
-  base::FilePath nonexisting_file(FILE_PATH_LITERAL("drive/Dummy file.txt"));
-  base::FilePath file_in_root(FILE_PATH_LITERAL("drive/File 1.txt"));
-  base::FilePath dir_in_root(FILE_PATH_LITERAL("drive/Directory 1"));
+  base::FilePath nonexisting_file(
+      FILE_PATH_LITERAL("drive/root/Dummy file.txt"));
+  base::FilePath file_in_root(FILE_PATH_LITERAL("drive/root/File 1.txt"));
+  base::FilePath dir_in_root(FILE_PATH_LITERAL("drive/root/Directory 1"));
   base::FilePath file_in_subdir(
-      FILE_PATH_LITERAL("drive/Directory 1/SubDirectory File 1.txt"));
+      FILE_PATH_LITERAL("drive/root/Directory 1/SubDirectory File 1.txt"));
 
   ASSERT_TRUE(EntryExists(file_in_root));
   scoped_ptr<DriveEntryProto> file_in_root_proto = GetEntryInfoByPathSync(
       file_in_root);
   ASSERT_TRUE(file_in_root_proto.get());
 
   ASSERT_TRUE(EntryExists(dir_in_root));
   scoped_ptr<DriveEntryProto> dir_in_root_proto = GetEntryInfoByPathSync(
       dir_in_root);
   ASSERT_TRUE(dir_in_root_proto.get());
   ASSERT_TRUE(dir_in_root_proto->file_info().is_directory());
 
   ASSERT_TRUE(EntryExists(file_in_subdir));
   scoped_ptr<DriveEntryProto> file_in_subdir_proto = GetEntryInfoByPathSync(
       file_in_subdir);
   ASSERT_TRUE(file_in_subdir_proto.get());
 
   // Once for file in root and once for file...
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
-      Eq(base::FilePath(FILE_PATH_LITERAL("drive"))))).Times(2);
+      Eq(base::FilePath(FILE_PATH_LITERAL("drive/root"))))).Times(2);
 
   // Remove first file in root.
   EXPECT_TRUE(RemoveEntry(file_in_root));
   EXPECT_FALSE(EntryExists(file_in_root));
   EXPECT_TRUE(EntryExists(dir_in_root));
   EXPECT_TRUE(EntryExists(file_in_subdir));
 
   // Remove directory.
   EXPECT_TRUE(RemoveEntry(dir_in_root));
   EXPECT_FALSE(EntryExists(file_in_root));
   EXPECT_FALSE(EntryExists(dir_in_root));
   EXPECT_FALSE(EntryExists(file_in_subdir));
 
   // Try removing file in already removed subdirectory.
   EXPECT_FALSE(RemoveEntry(file_in_subdir));
 
   // Try removing non-existing file.
   EXPECT_FALSE(RemoveEntry(nonexisting_file));
 
   // Try removing root file element.
-  EXPECT_FALSE(RemoveEntry(base::FilePath(FILE_PATH_LITERAL("drive"))));
+  EXPECT_FALSE(RemoveEntry(base::FilePath(FILE_PATH_LITERAL("drive/root"))));
 
   // Need this to ensure OnDirectoryChanged() is run.
   google_apis::test_util::RunBlockingPoolTask();
 }
 
 TEST_F(DriveFileSystemTest, CreateDirectory) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
-      Eq(base::FilePath(FILE_PATH_LITERAL("drive"))))).Times(1);
+      Eq(base::FilePath(FILE_PATH_LITERAL("drive/root"))))).Times(1);
 
   // Create directory in root.
-  base::FilePath dir_path(FILE_PATH_LITERAL("drive/New Folder 1"));
+  base::FilePath dir_path(FILE_PATH_LITERAL("drive/root/New Folder 1"));
   EXPECT_FALSE(EntryExists(dir_path));
   AddDirectoryFromFile(dir_path, "chromeos/gdata/directory_entry_atom.json");
   EXPECT_TRUE(EntryExists(dir_path));
 
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
-      Eq(base::FilePath(FILE_PATH_LITERAL("drive/New Folder 1"))))).Times(1);
+      Eq(base::FilePath(FILE_PATH_LITERAL("drive/root/New Folder 1")))))
+      .Times(1);
 
   // Create directory in a sub directory.
   base::FilePath subdir_path(
-      FILE_PATH_LITERAL("drive/New Folder 1/New Folder 2"));
+      FILE_PATH_LITERAL("drive/root/New Folder 1/New Folder 2"));
   EXPECT_FALSE(EntryExists(subdir_path));
   AddDirectoryFromFile(subdir_path,
                        "chromeos/gdata/directory_entry_atom2.json");
   EXPECT_TRUE(EntryExists(subdir_path));
 }
 
 // Create a directory through the document service
 TEST_F(DriveFileSystemTest, CreateDirectoryWithService) {
   ASSERT_TRUE(LoadRootFeedDocument());
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
-      Eq(base::FilePath(FILE_PATH_LITERAL("drive"))))).Times(1);
+      Eq(base::FilePath(FILE_PATH_LITERAL("drive/root"))))).Times(1);
 
   DriveFileError error = DRIVE_FILE_ERROR_FAILED;
   file_system_->CreateDirectory(
-      base::FilePath(FILE_PATH_LITERAL("drive/Sample Directory Title")),
+      base::FilePath(FILE_PATH_LITERAL("drive/root/Sample Directory Title")),
       false,  // is_exclusive
       true,  // is_recursive
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
 
   EXPECT_EQ(DRIVE_FILE_OK, error);
 }
 
 TEST_F(DriveFileSystemTest, GetFileByPath_FromGData_EnoughSpace) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
   // The transfered file is cached and the change of "offline available"
   // attribute is notified.
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
-      Eq(base::FilePath(FILE_PATH_LITERAL("drive"))))).Times(1);
+      Eq(base::FilePath(FILE_PATH_LITERAL("drive/root"))))).Times(1);
 
-  base::FilePath file_in_root(FILE_PATH_LITERAL("drive/File 1.txt"));
+  base::FilePath file_in_root(FILE_PATH_LITERAL("drive/root/File 1.txt"));
   scoped_ptr<DriveEntryProto> entry_proto(GetEntryInfoByPathSync(file_in_root));
   const int64 file_size = entry_proto->file_info().size();
 
   // Pretend we have enough space.
   fake_free_disk_space_getter_->set_fake_free_disk_space(
       file_size + kMinFreeSpace);
 
   DriveFileError error = DRIVE_FILE_ERROR_FAILED;
   base::FilePath file_path;
   std::string mime_type;
   DriveFileType file_type;
   file_system_->GetFileByPath(file_in_root,
                               google_apis::test_util::CreateCopyResultCallback(
                                   &error, &file_path, &mime_type, &file_type));
   google_apis::test_util::RunBlockingPoolTask();
 
   EXPECT_EQ(DRIVE_FILE_OK, error);
   EXPECT_EQ(REGULAR_FILE, file_type);
 }
 
 TEST_F(DriveFileSystemTest, GetFileByPath_FromGData_NoSpaceAtAll) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
-  base::FilePath file_in_root(FILE_PATH_LITERAL("drive/File 1.txt"));
+  base::FilePath file_in_root(FILE_PATH_LITERAL("drive/root/File 1.txt"));
   scoped_ptr<DriveEntryProto> entry_proto(GetEntryInfoByPathSync(file_in_root));
 
   // Pretend we have no space at all.
   fake_free_disk_space_getter_->set_fake_free_disk_space(0);
 
   DriveFileError error = DRIVE_FILE_OK;
   base::FilePath file_path;
   std::string mime_type;
   DriveFileType file_type;
   file_system_->GetFileByPath(file_in_root,
                               google_apis::test_util::CreateCopyResultCallback(
                                   &error, &file_path, &mime_type, &file_type));
   google_apis::test_util::RunBlockingPoolTask();
 
   EXPECT_EQ(DRIVE_FILE_ERROR_NO_SPACE, error);
 }
 
 TEST_F(DriveFileSystemTest, GetFileByPath_FromGData_NoEnoughSpaceButCanFreeUp) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
   // The transfered file is cached and the change of "offline available"
   // attribute is notified.
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
-      Eq(base::FilePath(FILE_PATH_LITERAL("drive"))))).Times(1);
+      Eq(base::FilePath(FILE_PATH_LITERAL("drive/root"))))).Times(1);
 
-  base::FilePath file_in_root(FILE_PATH_LITERAL("drive/File 1.txt"));
+  base::FilePath file_in_root(FILE_PATH_LITERAL("drive/root/File 1.txt"));
   scoped_ptr<DriveEntryProto> entry_proto(GetEntryInfoByPathSync(file_in_root));
   const int64 file_size = entry_proto->file_info().size();
 
   // Pretend we have no space first (checked before downloading a file),
   // but then start reporting we have space. This is to emulate that
   // the disk space was freed up by removing temporary files.
   fake_free_disk_space_getter_->set_fake_free_disk_space(
       file_size + kMinFreeSpace);
   fake_free_disk_space_getter_->set_fake_free_disk_space(0);
   fake_free_disk_space_getter_->set_fake_free_disk_space(
@@ skipping 29 matching lines @@
   EXPECT_EQ(DRIVE_FILE_OK, error);
   EXPECT_EQ(REGULAR_FILE, file_type);
 
   // The cache entry should be removed in order to free up space.
   ASSERT_FALSE(CacheEntryExists("<resource_id>", "<md5>"));
 }
 
 TEST_F(DriveFileSystemTest, GetFileByPath_FromGData_EnoughSpaceButBecomeFull) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
-  base::FilePath file_in_root(FILE_PATH_LITERAL("drive/File 1.txt"));
+  base::FilePath file_in_root(FILE_PATH_LITERAL("drive/root/File 1.txt"));
   scoped_ptr<DriveEntryProto> entry_proto(GetEntryInfoByPathSync(file_in_root));
   const int64 file_size = entry_proto->file_info().size();
 
   // Pretend we have enough space first (checked before downloading a file),
   // but then start reporting we have not enough space. This is to emulate that
   // the disk space becomes full after the file is downloaded for some reason
   // (ex. the actual file was larger than the expected size).
   fake_free_disk_space_getter_->set_fake_free_disk_space(
       file_size + kMinFreeSpace);
   fake_free_disk_space_getter_->set_fake_free_disk_space(kMinFreeSpace - 1);
   fake_free_disk_space_getter_->set_fake_free_disk_space(kMinFreeSpace - 1);
 
   DriveFileError error = DRIVE_FILE_OK;
   base::FilePath file_path;
   std::string mime_type;
   DriveFileType file_type;
   file_system_->GetFileByPath(file_in_root,
                               google_apis::test_util::CreateCopyResultCallback(
                                   &error, &file_path, &mime_type, &file_type));
   google_apis::test_util::RunBlockingPoolTask();
 
   EXPECT_EQ(DRIVE_FILE_ERROR_NO_SPACE, error);
 }
 
 TEST_F(DriveFileSystemTest, GetFileByPath_FromCache) {
   fake_free_disk_space_getter_->set_fake_free_disk_space(kLotsOfSpace);
 
   ASSERT_TRUE(LoadRootFeedDocument());
 
-  base::FilePath file_in_root(FILE_PATH_LITERAL("drive/File 1.txt"));
+  base::FilePath file_in_root(FILE_PATH_LITERAL("drive/root/File 1.txt"));
   scoped_ptr<DriveEntryProto> entry_proto(GetEntryInfoByPathSync(file_in_root));
 
   // Store something as cached version of this file.
   DriveFileError error = DRIVE_FILE_OK;
   cache_->Store(entry_proto->resource_id(),
                 entry_proto->file_specific_info().file_md5(),
                 google_apis::test_util::GetTestFilePath(
                     "chromeos/gdata/root_feed.json"),
                 DriveCache::FILE_OPERATION_COPY,
                 google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_OK, error);
 
   base::FilePath file_path;
   std::string mime_type;
   DriveFileType file_type;
   file_system_->GetFileByPath(file_in_root,
                               google_apis::test_util::CreateCopyResultCallback(
                                   &error, &file_path, &mime_type, &file_type));
   google_apis::test_util::RunBlockingPoolTask();
 
   EXPECT_EQ(DRIVE_FILE_OK, error);
   EXPECT_EQ(REGULAR_FILE, file_type);
 }
 
 TEST_F(DriveFileSystemTest, GetFileByPath_HostedDocument) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
-  base::FilePath file_in_root(FILE_PATH_LITERAL("drive/Document 1.gdoc"));
+  base::FilePath file_in_root(FILE_PATH_LITERAL("drive/root/Document 1.gdoc"));
   scoped_ptr<DriveEntryProto> src_entry_proto =
       GetEntryInfoByPathSync(file_in_root);
   ASSERT_TRUE(src_entry_proto.get());
 
   DriveFileError error = DRIVE_FILE_ERROR_FAILED;
   base::FilePath file_path;
   std::string mime_type;
   DriveFileType file_type;
   file_system_->GetFileByPath(file_in_root,
                               google_apis::test_util::CreateCopyResultCallback(
                                   &error, &file_path, &mime_type, &file_type));
   google_apis::test_util::RunBlockingPoolTask();
 
   EXPECT_EQ(HOSTED_DOCUMENT, file_type);
   EXPECT_FALSE(file_path.empty());
 
   ASSERT_TRUE(src_entry_proto.get());
   VerifyHostedDocumentJSONFile(*src_entry_proto, file_path);
 }
 
 TEST_F(DriveFileSystemTest, GetFileByResourceId) {
   fake_free_disk_space_getter_->set_fake_free_disk_space(kLotsOfSpace);
 
   // The transfered file is cached and the change of "offline available"
   // attribute is notified.
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
-      Eq(base::FilePath(FILE_PATH_LITERAL("drive"))))).Times(1);
+      Eq(base::FilePath(FILE_PATH_LITERAL("drive/root"))))).Times(1);
 
   ASSERT_TRUE(LoadRootFeedDocument());
 
-  base::FilePath file_in_root(FILE_PATH_LITERAL("drive/File 1.txt"));
+  base::FilePath file_in_root(FILE_PATH_LITERAL("drive/root/File 1.txt"));
   scoped_ptr<DriveEntryProto> entry_proto(GetEntryInfoByPathSync(file_in_root));
 
   DriveFileError error = DRIVE_FILE_OK;
   base::FilePath file_path;
   std::string mime_type;
   DriveFileType file_type;
   file_system_->GetFileByResourceId(
       entry_proto->resource_id(),
       DriveClientContext(USER_INITIATED),
       google_apis::test_util::CreateCopyResultCallback(
           &error, &file_path, &mime_type, &file_type),
       google_apis::GetContentCallback());
   google_apis::test_util::RunBlockingPoolTask();
 
   EXPECT_EQ(DRIVE_FILE_OK, error);
   EXPECT_EQ(REGULAR_FILE, file_type);
 }
 
 TEST_F(DriveFileSystemTest, CancelGetFile) {
-  base::FilePath cancel_file_path(FILE_PATH_LITERAL("drive/File 1.txt"));
+  base::FilePath cancel_file_path(FILE_PATH_LITERAL("drive/root/File 1.txt"));
   file_system_->CancelGetFile(cancel_file_path);
   EXPECT_EQ(cancel_file_path, fake_drive_service_->last_cancelled_file());
 }
 
 TEST_F(DriveFileSystemTest, GetFileByResourceId_FromCache) {
   fake_free_disk_space_getter_->set_fake_free_disk_space(kLotsOfSpace);
 
   ASSERT_TRUE(LoadRootFeedDocument());
 
-  base::FilePath file_in_root(FILE_PATH_LITERAL("drive/File 1.txt"));
+  base::FilePath file_in_root(FILE_PATH_LITERAL("drive/root/File 1.txt"));
   scoped_ptr<DriveEntryProto> entry_proto(GetEntryInfoByPathSync(file_in_root));
 
   // Store something as cached version of this file.
   DriveFileError error = DRIVE_FILE_ERROR_FAILED;
   cache_->Store(entry_proto->resource_id(),
                 entry_proto->file_specific_info().file_md5(),
                 google_apis::test_util::GetTestFilePath(
                     "chromeos/gdata/root_feed.json"),
                 DriveCache::FILE_OPERATION_COPY,
                 google_apis::test_util::CreateCopyResultCallback(&error));
@@ skipping 18 matching lines @@
   EXPECT_EQ(DRIVE_FILE_OK, error);
   EXPECT_EQ(REGULAR_FILE, file_type);
 }
 
 TEST_F(DriveFileSystemTest, UpdateFileByResourceId_PersistentFile) {
   fake_free_disk_space_getter_->set_fake_free_disk_space(kLotsOfSpace);
 
   ASSERT_TRUE(LoadRootFeedDocument());
 
   // This is a file defined in root_feed.json.
-  const base::FilePath kFilePath(FILE_PATH_LITERAL("drive/File 1.txt"));
+  const base::FilePath kFilePath(FILE_PATH_LITERAL("drive/root/File 1.txt"));
   const std::string kResourceId("file:2_file_resource_id");
   const std::string kMd5("3b4382ebefec6e743578c76bbd0575ce");
 
   // Pin the file so it'll be store in "persistent" directory.
   EXPECT_CALL(*mock_cache_observer_, OnCachePinned(kResourceId, kMd5)).Times(1);
   DriveFileError error = DRIVE_FILE_OK;
   cache_->Pin(kResourceId, kMd5,
               google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_OK, error);
@@ skipping 23 matching lines @@
   EXPECT_EQ(DRIVE_FILE_OK, error);
 
   // We'll notify the directory change to the observer upon completion.
   EXPECT_CALL(*mock_directory_observer_,
               OnDirectoryChanged(Eq(util::GetDriveMyDriveRootPath())))
       .Times(1);
 
   // Check the number of files in the root directory. We'll compare the
   // number after updating a file.
   scoped_ptr<DriveEntryProtoVector> root_directory_entries(
-      ReadDirectoryByPathSync(base::FilePath::FromUTF8Unsafe("drive")));
+      ReadDirectoryByPathSync(base::FilePath::FromUTF8Unsafe("drive/root")));
   ASSERT_TRUE(root_directory_entries.get());
   const int num_files_in_root = CountFiles(*root_directory_entries);
 
   // The callback will be called upon completion of
   // UpdateFileByResourceId().
   file_system_->UpdateFileByResourceId(
       kResourceId,
       DriveClientContext(USER_INITIATED),
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_OK, error);
 
   // Make sure that the number of files did not change (i.e. we updated an
   // existing file, rather than adding a new file. The number of files
   // increases if we don't handle the file update right).
   EXPECT_EQ(num_files_in_root, CountFiles(*root_directory_entries));
 }
 
 TEST_F(DriveFileSystemTest, UpdateFileByResourceId_NonexistentFile) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
   // This is nonexistent in root_feed.json.
-  const base::FilePath kFilePath(FILE_PATH_LITERAL("drive/Nonexistent.txt"));
+  const base::FilePath kFilePath(
+      FILE_PATH_LITERAL("drive/root/Nonexistent.txt"));
   const std::string kResourceId("file:nonexistent_resource_id");
   const std::string kMd5("nonexistent_md5");
 
   // The callback will be called upon completion of
   // UpdateFileByResourceId().
   DriveFileError error = DRIVE_FILE_OK;
   file_system_->UpdateFileByResourceId(
       kResourceId,
       DriveClientContext(USER_INITIATED),
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_ERROR_NOT_FOUND, error);
 }
 
 TEST_F(DriveFileSystemTest, ContentSearch) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
   const SearchResultPair kExpectedResults[] = {
-    { "drive/Directory 1/Sub Directory Folder/Sub Sub Directory Folder",
+    { "drive/root/Directory 1/Sub Directory Folder/Sub Sub Directory Folder",
       true },
-    { "drive/Directory 1/Sub Directory Folder", true },
-    { "drive/Directory 1/SubDirectory File 1.txt", false },
-    { "drive/Directory 1", true },
-    { "drive/Directory 2", true },
+    { "drive/root/Directory 1/Sub Directory Folder", true },
+    { "drive/root/Directory 1/SubDirectory File 1.txt", false },
+    { "drive/root/Directory 1", true },
+    { "drive/root/Directory 2", true },
   };
 
   SearchCallback callback = base::Bind(&DriveSearchCallback,
       &message_loop_,
       kExpectedResults, ARRAYSIZE_UNSAFE(kExpectedResults),
       GURL());
 
   file_system_->Search("Directory", GURL(), callback);
   message_loop_.Run();  // Wait to get our result.
 }
 
 TEST_F(DriveFileSystemTest, ContentSearchWithNewEntry) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
   // Create a new directory in the drive service.
   google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
   scoped_ptr<google_apis::ResourceEntry> resource_entry;
   fake_drive_service_->AddNewDirectory(
       fake_drive_service_->GetRootResourceId(),  // Add to the root directory.
       "New Directory 1!",
       google_apis::test_util::CreateCopyResultCallback(
           &error, &resource_entry));
   message_loop_.RunUntilIdle();
 
   // As the result of the first Search(), only entries in the current file
   // system snapshot are expected to be returned (i.e. "New Directory 1!"
   // shouldn't be included in the search result even though it matches
   // "Directory 1".
   const SearchResultPair kExpectedResults[] = {
-    { "drive/Directory 1", true }
+    { "drive/root/Directory 1", true }
   };
 
   // At the same time, unknown entry should trigger delta feed request.
   // This will cause notification to directory observers (e.g., File Browser)
   // so that they can request search again.
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(_))
       .Times(AtLeast(1));
 
   SearchCallback callback = base::Bind(&DriveSearchCallback,
       &message_loop_,
@@ skipping 44 matching lines @@
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_OK, error);
 }
 
 TEST_F(DriveFileSystemTest, OpenAndCloseFile) {
   ASSERT_TRUE(LoadRootFeedDocument());
 
   // The transfered file is cached and the change of "offline available"
   // attribute is notified.
   EXPECT_CALL(*mock_directory_observer_, OnDirectoryChanged(
-      Eq(base::FilePath(FILE_PATH_LITERAL("drive"))))).Times(1);
+      Eq(base::FilePath(FILE_PATH_LITERAL("drive/root"))))).Times(1);
 
-  const base::FilePath kFileInRoot(FILE_PATH_LITERAL("drive/File 1.txt"));
+  const base::FilePath kFileInRoot(FILE_PATH_LITERAL("drive/root/File 1.txt"));
   scoped_ptr<DriveEntryProto> entry_proto(GetEntryInfoByPathSync(kFileInRoot));
   const int64 file_size = entry_proto->file_info().size();
   const std::string& file_resource_id =
       entry_proto->resource_id();
   const std::string& file_md5 = entry_proto->file_specific_info().file_md5();
 
   // A dirty file is created on close.
   EXPECT_CALL(*mock_cache_observer_, OnCacheCommitted(file_resource_id))
       .Times(1);
 
   // Pretend we have enough space.
   fake_free_disk_space_getter_->set_fake_free_disk_space(
       file_size + kMinFreeSpace);
 
-  // Open kFileInRoot ("drive/File 1.txt").
+  // Open kFileInRoot ("drive/root/File 1.txt").
   DriveFileError error = DRIVE_FILE_ERROR_FAILED;
   base::FilePath file_path;
   file_system_->OpenFile(
       kFileInRoot,
       google_apis::test_util::CreateCopyResultCallback(&error, &file_path));
   google_apis::test_util::RunBlockingPoolTask();
   const base::FilePath opened_file_path = file_path;
 
   // Verify that the file was properly opened.
   EXPECT_EQ(DRIVE_FILE_OK, error);
@@ skipping 22 matching lines @@
   EXPECT_TRUE(cache_entry.is_persistent());
 
   base::FilePath cache_file_path;
   cache_->GetFile(file_resource_id, file_md5,
                   google_apis::test_util::CreateCopyResultCallback(
                       &error, &cache_file_path));
   google_apis::test_util::RunBlockingPoolTask();
   EXPECT_EQ(DRIVE_FILE_OK, error);
   EXPECT_EQ(cache_file_path, opened_file_path);
 
-  // Close kFileInRoot ("drive/File 1.txt").
+  // Close kFileInRoot ("drive/root/File 1.txt").
   file_system_->CloseFile(
       kFileInRoot,
       google_apis::test_util::CreateCopyResultCallback(&error));
   google_apis::test_util::RunBlockingPoolTask();
 
   // Verify that the file was properly closed.
   EXPECT_EQ(DRIVE_FILE_OK, error);
 
   // Verify that the cache state was changed as expected.
   EXPECT_TRUE(GetCacheEntryFromOriginThread(file_resource_id, file_md5,
@@ skipping 32 matching lines @@
 
   // An app for foo.exe should now be found, as the registry was loaded.
   drive_webapps_registry_->GetWebAppsForFile(
       base::FilePath(FILE_PATH_LITERAL("foo.exe")),
       "" /* mime_type */,
       &apps);
   EXPECT_EQ(1U, apps.size());
 }
 
 }   // namespace drive