Drop prefixes from test data resource IDs

chrome/browser/drive/fake_drive_service_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/drive/fake_drive_service.h"
 
 #include <string>
 #include <vector>
 
 #include "base/file_util.h"
@@ skipping 147 matching lines @@
   EXPECT_EQ(8U, file_list->items().size());
   EXPECT_EQ(1, fake_service_.directory_load_count());
 }
 
 TEST_F(FakeDriveServiceTest, GetFileListInDirectory_InNonRootDirectory) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   scoped_ptr<FileList> file_list;
   fake_service_.GetFileListInDirectory(
-      "folder:1_folder_resource_id",
+      "1_folder_resource_id",
       test_util::CreateCopyResultCallback(&error, &file_list));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   ASSERT_TRUE(file_list);
   // Do some sanity check. There is three entries in 1_folder_resource_id
   // directory.
   EXPECT_EQ(3U, file_list->items().size());
   EXPECT_EQ(1, fake_service_.directory_load_count());
 }
@@ skipping 85 matching lines @@
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(GDATA_NO_CONNECTION, error);
   EXPECT_FALSE(file_list);
 }
 
 TEST_F(FakeDriveServiceTest, Search_Deleted) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
-  fake_service_.DeleteResource("file:2_file_resource_id",
+  fake_service_.DeleteResource("2_file_resource_id",
                                std::string(),  // etag
                                test_util::CreateCopyResultCallback(&error));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(HTTP_NO_CONTENT, error);
 
   error = GDATA_OTHER_ERROR;
   scoped_ptr<FileList> file_list;
   fake_service_.Search(
       "File",  // search_query
       test_util::CreateCopyResultCallback(&error, &file_list));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   ASSERT_TRUE(file_list);
   // Do some sanity check. There are 4 entries that contain "File" in their
   // titles and one of them is deleted.
   EXPECT_EQ(3U, file_list->items().size());
 }
 
 TEST_F(FakeDriveServiceTest, Search_Trashed) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
-  fake_service_.TrashResource("file:2_file_resource_id",
+  fake_service_.TrashResource("2_file_resource_id",
                               test_util::CreateCopyResultCallback(&error));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(HTTP_SUCCESS, error);
 
   error = GDATA_OTHER_ERROR;
   scoped_ptr<FileList> file_list;
   fake_service_.Search(
       "File",  // search_query
       test_util::CreateCopyResultCallback(&error, &file_list));
   base::RunLoop().RunUntilIdle();
@@ skipping 116 matching lines @@
       654321,  // start_changestamp
       test_util::CreateCopyResultCallback(&error, &change_list));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(GDATA_NO_CONNECTION, error);
   EXPECT_FALSE(change_list);
 }
 
 TEST_F(FakeDriveServiceTest, GetChangeList_DeletedEntry) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
-  ASSERT_TRUE(Exists("file:2_file_resource_id"));
+  ASSERT_TRUE(Exists("2_file_resource_id"));
   const int64 old_largest_change_id =
       fake_service_.about_resource().largest_change_id();
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
-  fake_service_.DeleteResource("file:2_file_resource_id",
+  fake_service_.DeleteResource("2_file_resource_id",
                                std::string(),  // etag
                                test_util::CreateCopyResultCallback(&error));
   base::RunLoop().RunUntilIdle();
   ASSERT_EQ(HTTP_NO_CONTENT, error);
-  ASSERT_FALSE(Exists("file:2_file_resource_id"));
+  ASSERT_FALSE(Exists("2_file_resource_id"));
 
   // Get the resource list newer than old_largest_change_id.
   error = GDATA_OTHER_ERROR;
   scoped_ptr<ChangeList> change_list;
   fake_service_.GetChangeList(
       old_largest_change_id + 1,
       test_util::CreateCopyResultCallback(&error, &change_list));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   ASSERT_TRUE(change_list);
   EXPECT_EQ(fake_service_.about_resource().largest_change_id(),
             change_list->largest_change_id());
   // The result should only contain the deleted file.
   ASSERT_EQ(1U, change_list->items().size());
   const ChangeResource& item = *change_list->items()[0];
-  EXPECT_EQ("file:2_file_resource_id", item.file_id());
+  EXPECT_EQ("2_file_resource_id", item.file_id());
   EXPECT_FALSE(item.file());
   EXPECT_TRUE(item.is_deleted());
   EXPECT_EQ(1, fake_service_.change_list_load_count());
 }
 
 TEST_F(FakeDriveServiceTest, GetChangeList_TrashedEntry) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
-  ASSERT_TRUE(Exists("file:2_file_resource_id"));
+  ASSERT_TRUE(Exists("2_file_resource_id"));
   const int64 old_largest_change_id =
       fake_service_.about_resource().largest_change_id();
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
-  fake_service_.TrashResource("file:2_file_resource_id",
+  fake_service_.TrashResource("2_file_resource_id",
                               test_util::CreateCopyResultCallback(&error));
   base::RunLoop().RunUntilIdle();
   ASSERT_EQ(HTTP_SUCCESS, error);
-  ASSERT_FALSE(Exists("file:2_file_resource_id"));
+  ASSERT_FALSE(Exists("2_file_resource_id"));
 
   // Get the resource list newer than old_largest_change_id.
   error = GDATA_OTHER_ERROR;
   scoped_ptr<ChangeList> change_list;
   fake_service_.GetChangeList(
       old_largest_change_id + 1,
       test_util::CreateCopyResultCallback(&error, &change_list));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   ASSERT_TRUE(change_list);
   EXPECT_EQ(fake_service_.about_resource().largest_change_id(),
             change_list->largest_change_id());
   // The result should only contain the trashed file.
   ASSERT_EQ(1U, change_list->items().size());
   const ChangeResource& item = *change_list->items()[0];
-  EXPECT_EQ("file:2_file_resource_id", item.file_id());
+  EXPECT_EQ("2_file_resource_id", item.file_id());
   ASSERT_TRUE(item.file());
   EXPECT_TRUE(item.file()->labels().is_trashed());
   EXPECT_EQ(1, fake_service_.change_list_load_count());
 }
 
 TEST_F(FakeDriveServiceTest, GetRemainingFileList_GetAllFileList) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
   fake_service_.set_default_max_results(6);
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
@@ skipping 250 matching lines @@
       test_util::CreateCopyResultCallback(&error, &app_list));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(GDATA_NO_CONNECTION, error);
   EXPECT_FALSE(app_list);
 }
 
 TEST_F(FakeDriveServiceTest, GetFileResource_ExistingFile) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
-  const std::string kResourceId = "file:2_file_resource_id";
+  const std::string kResourceId = "2_file_resource_id";
   GDataErrorCode error = GDATA_OTHER_ERROR;
   scoped_ptr<FileResource> entry;
   fake_service_.GetFileResource(
       kResourceId, test_util::CreateCopyResultCallback(&error, &entry));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   ASSERT_TRUE(entry);
   // Do some sanity check.
   EXPECT_EQ(kResourceId, entry->file_id());
 }
 
 TEST_F(FakeDriveServiceTest, GetFileResource_NonexistingFile) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
-  const std::string kResourceId = "file:nonexisting_resource_id";
+  const std::string kResourceId = "nonexisting_resource_id";
   GDataErrorCode error = GDATA_OTHER_ERROR;
   scoped_ptr<FileResource> entry;
   fake_service_.GetFileResource(
       kResourceId, test_util::CreateCopyResultCallback(&error, &entry));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_NOT_FOUND, error);
   ASSERT_FALSE(entry);
 }
 
 TEST_F(FakeDriveServiceTest, GetFileResource_Offline) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
   fake_service_.set_offline(true);
 
-  const std::string kResourceId = "file:2_file_resource_id";
+  const std::string kResourceId = "2_file_resource_id";
   GDataErrorCode error = GDATA_OTHER_ERROR;
   scoped_ptr<FileResource> entry;
   fake_service_.GetFileResource(
       kResourceId, test_util::CreateCopyResultCallback(&error, &entry));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(GDATA_NO_CONNECTION, error);
   EXPECT_FALSE(entry);
 }
 
 TEST_F(FakeDriveServiceTest, GetShareUrl) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
-  const std::string kResourceId = "file:2_file_resource_id";
+  const std::string kResourceId = "2_file_resource_id";
   GDataErrorCode error = GDATA_OTHER_ERROR;
   GURL share_url;
   fake_service_.GetShareUrl(
       kResourceId,
       GURL(),  // embed origin
       test_util::CreateCopyResultCallback(&error, &share_url));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_FALSE(share_url.is_empty());
 }
 
 TEST_F(FakeDriveServiceTest, DeleteResource_ExistingFile) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
-  // Resource "file:2_file_resource_id" should now exist.
-  ASSERT_TRUE(Exists("file:2_file_resource_id"));
+  // Resource "2_file_resource_id" should now exist.
+  ASSERT_TRUE(Exists("2_file_resource_id"));
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
-  fake_service_.DeleteResource("file:2_file_resource_id",
+  fake_service_.DeleteResource("2_file_resource_id",
                                std::string(),  // etag
                                test_util::CreateCopyResultCallback(&error));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_NO_CONTENT, error);
-  // Resource "file:2_file_resource_id" should be gone now.
-  EXPECT_FALSE(Exists("file:2_file_resource_id"));
+  // Resource "2_file_resource_id" should be gone now.
+  EXPECT_FALSE(Exists("2_file_resource_id"));
 
   error = GDATA_OTHER_ERROR;
-  fake_service_.DeleteResource("file:2_file_resource_id",
+  fake_service_.DeleteResource("2_file_resource_id",
                                std::string(),  // etag
                                test_util::CreateCopyResultCallback(&error));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(HTTP_NOT_FOUND, error);
-  EXPECT_FALSE(Exists("file:2_file_resource_id"));
+  EXPECT_FALSE(Exists("2_file_resource_id"));
 }
 
 TEST_F(FakeDriveServiceTest, DeleteResource_NonexistingFile) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
-  fake_service_.DeleteResource("file:nonexisting_resource_id",
+  fake_service_.DeleteResource("nonexisting_resource_id",
                                std::string(),  // etag
                                test_util::CreateCopyResultCallback(&error));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_NOT_FOUND, error);
 }
 
 TEST_F(FakeDriveServiceTest, DeleteResource_ETagMatch) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
-  // Resource "file:2_file_resource_id" should now exist.
-  scoped_ptr<FileResource> entry = FindEntry("file:2_file_resource_id");
+  // Resource "2_file_resource_id" should now exist.
+  scoped_ptr<FileResource> entry = FindEntry("2_file_resource_id");
   ASSERT_TRUE(entry);
   ASSERT_FALSE(entry->labels().is_trashed());
   ASSERT_FALSE(entry->etag().empty());
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
-  fake_service_.DeleteResource("file:2_file_resource_id",
+  fake_service_.DeleteResource("2_file_resource_id",
                                entry->etag() + "_mismatch",
                                test_util::CreateCopyResultCallback(&error));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_PRECONDITION, error);
-  // Resource "file:2_file_resource_id" should still exist.
-  EXPECT_TRUE(Exists("file:2_file_resource_id"));
+  // Resource "2_file_resource_id" should still exist.
+  EXPECT_TRUE(Exists("2_file_resource_id"));
 
   error = GDATA_OTHER_ERROR;
-  fake_service_.DeleteResource("file:2_file_resource_id",
+  fake_service_.DeleteResource("2_file_resource_id",
                                entry->etag(),
                                test_util::CreateCopyResultCallback(&error));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(HTTP_NO_CONTENT, error);
-  // Resource "file:2_file_resource_id" should be gone now.
-  EXPECT_FALSE(Exists("file:2_file_resource_id"));
+  // Resource "2_file_resource_id" should be gone now.
+  EXPECT_FALSE(Exists("2_file_resource_id"));
 }
 
 TEST_F(FakeDriveServiceTest, DeleteResource_Offline) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
   fake_service_.set_offline(true);
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
-  fake_service_.DeleteResource("file:2_file_resource_id",
+  fake_service_.DeleteResource("2_file_resource_id",
                                std::string(),  // etag
                                test_util::CreateCopyResultCallback(&error));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(GDATA_NO_CONNECTION, error);
 }
 
 TEST_F(FakeDriveServiceTest, TrashResource_ExistingFile) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
-  // Resource "file:2_file_resource_id" should now exist.
-  ASSERT_TRUE(Exists("file:2_file_resource_id"));
+  // Resource "2_file_resource_id" should now exist.
+  ASSERT_TRUE(Exists("2_file_resource_id"));
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
-  fake_service_.TrashResource("file:2_file_resource_id",
+  fake_service_.TrashResource("2_file_resource_id",
                               test_util::CreateCopyResultCallback(&error));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_SUCCESS, error);
-  // Resource "file:2_file_resource_id" should be gone now.
-  EXPECT_FALSE(Exists("file:2_file_resource_id"));
+  // Resource "2_file_resource_id" should be gone now.
+  EXPECT_FALSE(Exists("2_file_resource_id"));
 
   error = GDATA_OTHER_ERROR;
-  fake_service_.TrashResource("file:2_file_resource_id",
+  fake_service_.TrashResource("2_file_resource_id",
                               test_util::CreateCopyResultCallback(&error));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(HTTP_NOT_FOUND, error);
-  EXPECT_FALSE(Exists("file:2_file_resource_id"));
+  EXPECT_FALSE(Exists("2_file_resource_id"));
 }
 
 TEST_F(FakeDriveServiceTest, TrashResource_NonexistingFile) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
-  fake_service_.TrashResource("file:nonexisting_resource_id",
+  fake_service_.TrashResource("nonexisting_resource_id",
                               test_util::CreateCopyResultCallback(&error));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_NOT_FOUND, error);
 }
 
 TEST_F(FakeDriveServiceTest, TrashResource_Offline) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
   fake_service_.set_offline(true);
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
-  fake_service_.TrashResource("file:2_file_resource_id",
+  fake_service_.TrashResource("2_file_resource_id",
                               test_util::CreateCopyResultCallback(&error));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(GDATA_NO_CONNECTION, error);
 }
 
 TEST_F(FakeDriveServiceTest, DownloadFile_ExistingFile) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 
   std::vector<test_util::ProgressInfo> download_progress_values;
 
   const base::FilePath kOutputFilePath =
       temp_dir.path().AppendASCII("whatever.txt");
   GDataErrorCode error = GDATA_OTHER_ERROR;
   base::FilePath output_file_path;
   test_util::TestGetContentCallback get_content_callback;
   fake_service_.DownloadFile(
       kOutputFilePath,
-      "file:2_file_resource_id",
+      "2_file_resource_id",
       test_util::CreateCopyResultCallback(&error, &output_file_path),
       get_content_callback.callback(),
       base::Bind(&test_util::AppendProgressCallbackResult,
                  &download_progress_values));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_EQ(output_file_path, kOutputFilePath);
   std::string content;
   ASSERT_TRUE(base::ReadFileToString(output_file_path, &content));
@@ skipping 10 matching lines @@
 
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 
   const base::FilePath kOutputFilePath =
       temp_dir.path().AppendASCII("whatever.txt");
   GDataErrorCode error = GDATA_OTHER_ERROR;
   base::FilePath output_file_path;
   fake_service_.DownloadFile(
       kOutputFilePath,
-      "file:non_existent_file_resource_id",
+      "non_existent_file_resource_id",
       test_util::CreateCopyResultCallback(&error, &output_file_path),
       GetContentCallback(),
       ProgressCallback());
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_NOT_FOUND, error);
 }
 
 TEST_F(FakeDriveServiceTest, DownloadFile_Offline) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
   fake_service_.set_offline(true);
 
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 
   const base::FilePath kOutputFilePath =
       temp_dir.path().AppendASCII("whatever.txt");
   GDataErrorCode error = GDATA_OTHER_ERROR;
   base::FilePath output_file_path;
   fake_service_.DownloadFile(
       kOutputFilePath,
-      "file:2_file_resource_id",
+      "2_file_resource_id",
       test_util::CreateCopyResultCallback(&error, &output_file_path),
       GetContentCallback(),
       ProgressCallback());
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(GDATA_NO_CONNECTION, error);
 }
 
 TEST_F(FakeDriveServiceTest, CopyResource) {
   const base::Time::Exploded kModifiedDate = {2012, 7, 0, 19, 15, 59, 13, 123};
 
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
   int64 old_largest_change_id = GetLargestChangeByAboutResource();
 
-  const std::string kResourceId = "file:2_file_resource_id";
-  const std::string kParentResourceId = "folder:2_folder_resource_id";
+  const std::string kResourceId = "2_file_resource_id";
+  const std::string kParentResourceId = "2_folder_resource_id";
   GDataErrorCode error = GDATA_OTHER_ERROR;
   scoped_ptr<FileResource> entry;
   fake_service_.CopyResource(
       kResourceId,
       kParentResourceId,
       "new title",
       base::Time::FromUTCExploded(kModifiedDate),
       test_util::CreateCopyResultCallback(&error, &entry));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   ASSERT_TRUE(entry);
   // The copied entry should have the new resource ID and the title.
   EXPECT_NE(kResourceId, entry->file_id());
   EXPECT_EQ("new title", entry->title());
   EXPECT_EQ(base::Time::FromUTCExploded(kModifiedDate), entry->modified_date());
   EXPECT_TRUE(HasParent(entry->file_id(), kParentResourceId));
   // Should be incremented as a new hosted document was created.
   EXPECT_EQ(old_largest_change_id + 1,
             fake_service_.about_resource().largest_change_id());
   EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource());
 }
 
 TEST_F(FakeDriveServiceTest, CopyResource_NonExisting) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
-  const std::string kResourceId = "document:nonexisting_resource_id";
+  const std::string kResourceId = "nonexisting_resource_id";
   GDataErrorCode error = GDATA_OTHER_ERROR;
   scoped_ptr<FileResource> entry;
   fake_service_.CopyResource(
       kResourceId,
-      "folder:1_folder_resource_id",
+      "1_folder_resource_id",
       "new title",
       base::Time(),
       test_util::CreateCopyResultCallback(&error, &entry));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_NOT_FOUND, error);
 }
 
 TEST_F(FakeDriveServiceTest, CopyResource_EmptyParentResourceId) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
   int64 old_largest_change_id = GetLargestChangeByAboutResource();
 
-  const std::string kResourceId = "file:2_file_resource_id";
+  const std::string kResourceId = "2_file_resource_id";
   GDataErrorCode error = GDATA_OTHER_ERROR;
   scoped_ptr<FileResource> entry;
   fake_service_.CopyResource(
       kResourceId,
       std::string(),
       "new title",
       base::Time(),
       test_util::CreateCopyResultCallback(&error, &entry));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   ASSERT_TRUE(entry);
   // The copied entry should have the new resource ID and the title.
   EXPECT_NE(kResourceId, entry->file_id());
   EXPECT_EQ("new title", entry->title());
   EXPECT_TRUE(HasParent(kResourceId, fake_service_.GetRootResourceId()));
   // Should be incremented as a new hosted document was created.
   EXPECT_EQ(old_largest_change_id + 1,
             fake_service_.about_resource().largest_change_id());
   EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource());
 }
 
 TEST_F(FakeDriveServiceTest, CopyResource_Offline) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
   fake_service_.set_offline(true);
 
-  const std::string kResourceId = "file:2_file_resource_id";
+  const std::string kResourceId = "2_file_resource_id";
   GDataErrorCode error = GDATA_OTHER_ERROR;
   scoped_ptr<FileResource> entry;
   fake_service_.CopyResource(
       kResourceId,
-      "folder:1_folder_resource_id",
+      "1_folder_resource_id",
       "new title",
       base::Time(),
       test_util::CreateCopyResultCallback(&error, &entry));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(GDATA_NO_CONNECTION, error);
   EXPECT_FALSE(entry);
 }
 
 TEST_F(FakeDriveServiceTest, UpdateResource) {
   const base::Time::Exploded kModifiedDate = {2012, 7, 0, 19, 15, 59, 13, 123};
   const base::Time::Exploded kViewedDate = {2013, 8, 1, 20, 16, 00, 14, 234};
 
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
   int64 old_largest_change_id = GetLargestChangeByAboutResource();
 
-  const std::string kResourceId = "file:2_file_resource_id";
-  const std::string kParentResourceId = "folder:2_folder_resource_id";
+  const std::string kResourceId = "2_file_resource_id";
+  const std::string kParentResourceId = "2_folder_resource_id";
   GDataErrorCode error = GDATA_OTHER_ERROR;
   scoped_ptr<FileResource> entry;
   fake_service_.UpdateResource(
       kResourceId,
       kParentResourceId,
       "new title",
       base::Time::FromUTCExploded(kModifiedDate),
       base::Time::FromUTCExploded(kViewedDate),
       test_util::CreateCopyResultCallback(&error, &entry));
   base::RunLoop().RunUntilIdle();
@@ skipping 10 matching lines @@
   EXPECT_TRUE(HasParent(kResourceId, kParentResourceId));
   // Should be incremented as a new hosted document was created.
   EXPECT_EQ(old_largest_change_id + 1,
             fake_service_.about_resource().largest_change_id());
   EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource());
 }
 
 TEST_F(FakeDriveServiceTest, UpdateResource_NonExisting) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
-  const std::string kResourceId = "document:nonexisting_resource_id";
+  const std::string kResourceId = "nonexisting_resource_id";
   GDataErrorCode error = GDATA_OTHER_ERROR;
   scoped_ptr<FileResource> entry;
   fake_service_.UpdateResource(
       kResourceId,
-      "folder:1_folder_resource_id",
+      "1_folder_resource_id",
       "new title",
       base::Time(),
       base::Time(),
       test_util::CreateCopyResultCallback(&error, &entry));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_NOT_FOUND, error);
 }
 
 TEST_F(FakeDriveServiceTest, UpdateResource_EmptyParentResourceId) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
   int64 old_largest_change_id = GetLargestChangeByAboutResource();
 
-  const std::string kResourceId = "file:2_file_resource_id";
+  const std::string kResourceId = "2_file_resource_id";
 
   // Just make sure that the resource is under root.
   ASSERT_TRUE(HasParent(kResourceId, "fake_root"));
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   scoped_ptr<FileResource> entry;
   fake_service_.UpdateResource(
       kResourceId,
       std::string(),
       "new title",
@@ skipping 11 matching lines @@
   // Should be incremented as a new hosted document was created.
   EXPECT_EQ(old_largest_change_id + 1,
             fake_service_.about_resource().largest_change_id());
   EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource());
 }
 
 TEST_F(FakeDriveServiceTest, UpdateResource_Offline) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
   fake_service_.set_offline(true);
 
-  const std::string kResourceId = "file:2_file_resource_id";
+  const std::string kResourceId = "2_file_resource_id";
   GDataErrorCode error = GDATA_OTHER_ERROR;
   scoped_ptr<FileResource> entry;
   fake_service_.UpdateResource(
       kResourceId,
       std::string(),
       "new title",
       base::Time(),
       base::Time(),
       test_util::CreateCopyResultCallback(&error, &entry));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(GDATA_NO_CONNECTION, error);
   EXPECT_FALSE(entry);
 }
 
 TEST_F(FakeDriveServiceTest, RenameResource_ExistingFile) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
   int64 old_largest_change_id = GetLargestChangeByAboutResource();
 
-  const std::string kResourceId = "file:2_file_resource_id";
+  const std::string kResourceId = "2_file_resource_id";
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   fake_service_.RenameResource(kResourceId,
                                "new title",
                                test_util::CreateCopyResultCallback(&error));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_SUCCESS, error);
 
   scoped_ptr<FileResource> entry = FindEntry(kResourceId);
   ASSERT_TRUE(entry);
   EXPECT_EQ("new title", entry->title());
   // Should be incremented as a file was renamed.
   EXPECT_EQ(old_largest_change_id + 1,
             fake_service_.about_resource().largest_change_id());
   EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource());
 }
 
 TEST_F(FakeDriveServiceTest, RenameResource_NonexistingFile) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
-  const std::string kResourceId = "file:nonexisting_file";
+  const std::string kResourceId = "nonexisting_file";
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   fake_service_.RenameResource(kResourceId,
                                "new title",
                                test_util::CreateCopyResultCallback(&error));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_NOT_FOUND, error);
 }
 
 TEST_F(FakeDriveServiceTest, RenameResource_Offline) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
   fake_service_.set_offline(true);
 
-  const std::string kResourceId = "file:2_file_resource_id";
+  const std::string kResourceId = "2_file_resource_id";
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   fake_service_.RenameResource(kResourceId,
                                "new title",
                                test_util::CreateCopyResultCallback(&error));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(GDATA_NO_CONNECTION, error);
 }
 
 TEST_F(FakeDriveServiceTest, AddResourceToDirectory_FileInRootDirectory) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
   int64 old_largest_change_id = GetLargestChangeByAboutResource();
 
-  const std::string kResourceId = "file:2_file_resource_id";
+  const std::string kResourceId = "2_file_resource_id";
   const std::string kOldParentResourceId = fake_service_.GetRootResourceId();
-  const std::string kNewParentResourceId = "folder:1_folder_resource_id";
+  const std::string kNewParentResourceId = "1_folder_resource_id";
 
   // Here's the original parent link.
   EXPECT_TRUE(HasParent(kResourceId, kOldParentResourceId));
   EXPECT_FALSE(HasParent(kResourceId, kNewParentResourceId));
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   fake_service_.AddResourceToDirectory(
       kNewParentResourceId,
       kResourceId,
       test_util::CreateCopyResultCallback(&error));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_SUCCESS, error);
 
   // The parent link should now be changed.
   EXPECT_TRUE(HasParent(kResourceId, kOldParentResourceId));
   EXPECT_TRUE(HasParent(kResourceId, kNewParentResourceId));
   // Should be incremented as a file was moved.
   EXPECT_EQ(old_largest_change_id + 1,
             fake_service_.about_resource().largest_change_id());
   EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource());
 }
 
 TEST_F(FakeDriveServiceTest, AddResourceToDirectory_FileInNonRootDirectory) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
   int64 old_largest_change_id = GetLargestChangeByAboutResource();
 
-  const std::string kResourceId = "file:subdirectory_file_1_id";
-  const std::string kOldParentResourceId = "folder:1_folder_resource_id";
-  const std::string kNewParentResourceId = "folder:2_folder_resource_id";
+  const std::string kResourceId = "subdirectory_file_1_id";
+  const std::string kOldParentResourceId = "1_folder_resource_id";
+  const std::string kNewParentResourceId = "2_folder_resource_id";
 
   // Here's the original parent link.
   EXPECT_TRUE(HasParent(kResourceId, kOldParentResourceId));
   EXPECT_FALSE(HasParent(kResourceId, kNewParentResourceId));
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   fake_service_.AddResourceToDirectory(
       kNewParentResourceId,
       kResourceId,
       test_util::CreateCopyResultCallback(&error));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_SUCCESS, error);
 
   // The parent link should now be changed.
   EXPECT_TRUE(HasParent(kResourceId, kOldParentResourceId));
   EXPECT_TRUE(HasParent(kResourceId, kNewParentResourceId));
   // Should be incremented as a file was moved.
   EXPECT_EQ(old_largest_change_id + 1,
             fake_service_.about_resource().largest_change_id());
   EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource());
 }
 
 TEST_F(FakeDriveServiceTest, AddResourceToDirectory_NonexistingFile) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
-  const std::string kResourceId = "file:nonexisting_file";
-  const std::string kNewParentResourceId = "folder:1_folder_resource_id";
+  const std::string kResourceId = "nonexisting_file";
+  const std::string kNewParentResourceId = "1_folder_resource_id";
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   fake_service_.AddResourceToDirectory(
       kNewParentResourceId,
       kResourceId,
       test_util::CreateCopyResultCallback(&error));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_NOT_FOUND, error);
 }
 
 TEST_F(FakeDriveServiceTest, AddResourceToDirectory_OrphanFile) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
   int64 old_largest_change_id = GetLargestChangeByAboutResource();
 
-  const std::string kResourceId = "file:1_orphanfile_resource_id";
-  const std::string kNewParentResourceId = "folder:1_folder_resource_id";
+  const std::string kResourceId = "1_orphanfile_resource_id";
+  const std::string kNewParentResourceId = "1_folder_resource_id";
 
   // The file does not belong to any directory, even to the root.
   EXPECT_FALSE(HasParent(kResourceId, kNewParentResourceId));
   EXPECT_FALSE(HasParent(kResourceId, fake_service_.GetRootResourceId()));
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   fake_service_.AddResourceToDirectory(
       kNewParentResourceId,
       kResourceId,
       test_util::CreateCopyResultCallback(&error));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_SUCCESS, error);
 
   // The parent link should now be changed.
   EXPECT_TRUE(HasParent(kResourceId, kNewParentResourceId));
   EXPECT_FALSE(HasParent(kResourceId, fake_service_.GetRootResourceId()));
   // Should be incremented as a file was moved.
   EXPECT_EQ(old_largest_change_id + 1,
             fake_service_.about_resource().largest_change_id());
   EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource());
 }
 
 TEST_F(FakeDriveServiceTest, AddResourceToDirectory_Offline) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
   fake_service_.set_offline(true);
 
-  const std::string kResourceId = "file:2_file_resource_id";
-  const std::string kNewParentResourceId = "folder:1_folder_resource_id";
+  const std::string kResourceId = "2_file_resource_id";
+  const std::string kNewParentResourceId = "1_folder_resource_id";
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   fake_service_.AddResourceToDirectory(
       kNewParentResourceId,
       kResourceId,
       test_util::CreateCopyResultCallback(&error));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(GDATA_NO_CONNECTION, error);
 }
 
 TEST_F(FakeDriveServiceTest, RemoveResourceFromDirectory_ExistingFile) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
   int64 old_largest_change_id = GetLargestChangeByAboutResource();
 
-  const std::string kResourceId = "file:subdirectory_file_1_id";
-  const std::string kParentResourceId = "folder:1_folder_resource_id";
+  const std::string kResourceId = "subdirectory_file_1_id";
+  const std::string kParentResourceId = "1_folder_resource_id";
 
   scoped_ptr<FileResource> entry = FindEntry(kResourceId);
   ASSERT_TRUE(entry);
   // The entry should have a parent now.
   ASSERT_FALSE(entry->parents().empty());
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   fake_service_.RemoveResourceFromDirectory(
       kParentResourceId,
       kResourceId,
       test_util::CreateCopyResultCallback(&error));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_NO_CONTENT, error);
 
   entry = FindEntry(kResourceId);
   ASSERT_TRUE(entry);
   // The entry should have no parent now.
   ASSERT_TRUE(entry->parents().empty());
   // Should be incremented as a file was moved to the root directory.
   EXPECT_EQ(old_largest_change_id + 1,
             fake_service_.about_resource().largest_change_id());
   EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource());
 }
 
 TEST_F(FakeDriveServiceTest, RemoveResourceFromDirectory_NonexistingFile) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
-  const std::string kResourceId = "file:nonexisting_file";
-  const std::string kParentResourceId = "folder:1_folder_resource_id";
+  const std::string kResourceId = "nonexisting_file";
+  const std::string kParentResourceId = "1_folder_resource_id";
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   fake_service_.RemoveResourceFromDirectory(
       kParentResourceId,
       kResourceId,
       test_util::CreateCopyResultCallback(&error));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_NOT_FOUND, error);
 }
 
 TEST_F(FakeDriveServiceTest, RemoveResourceFromDirectory_OrphanFile) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
-  const std::string kResourceId = "file:1_orphanfile_resource_id";
+  const std::string kResourceId = "1_orphanfile_resource_id";
   const std::string kParentResourceId = fake_service_.GetRootResourceId();
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   fake_service_.RemoveResourceFromDirectory(
       kParentResourceId,
       kResourceId,
       test_util::CreateCopyResultCallback(&error));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_NOT_FOUND, error);
 }
 
 TEST_F(FakeDriveServiceTest, RemoveResourceFromDirectory_Offline) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
   fake_service_.set_offline(true);
 
-  const std::string kResourceId = "file:subdirectory_file_1_id";
-  const std::string kParentResourceId = "folder:1_folder_resource_id";
+  const std::string kResourceId = "subdirectory_file_1_id";
+  const std::string kParentResourceId = "1_folder_resource_id";
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   fake_service_.RemoveResourceFromDirectory(
       kParentResourceId,
       kResourceId,
       test_util::CreateCopyResultCallback(&error));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(GDATA_NO_CONNECTION, error);
 }
@@ skipping 72 matching lines @@
   EXPECT_EQ(old_largest_change_id + 1,
             fake_service_.about_resource().largest_change_id());
   EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource());
 }
 
 TEST_F(FakeDriveServiceTest, AddNewDirectory_ToNonRootDirectory) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
   int64 old_largest_change_id = GetLargestChangeByAboutResource();
 
-  const std::string kParentResourceId = "folder:1_folder_resource_id";
+  const std::string kParentResourceId = "1_folder_resource_id";
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   scoped_ptr<FileResource> entry;
   fake_service_.AddNewDirectory(
       kParentResourceId,
       "new directory",
       DriveServiceInterface::AddNewDirectoryOptions(),
       test_util::CreateCopyResultCallback(&error, &entry));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_CREATED, error);
   ASSERT_TRUE(entry);
   EXPECT_TRUE(entry->IsDirectory());
   EXPECT_EQ("resource_id_1", entry->file_id());
   EXPECT_EQ("new directory", entry->title());
   EXPECT_TRUE(HasParent(entry->file_id(), kParentResourceId));
   // Should be incremented as a new directory was created.
   EXPECT_EQ(old_largest_change_id + 1,
             fake_service_.about_resource().largest_change_id());
   EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource());
 }
 
 TEST_F(FakeDriveServiceTest, AddNewDirectory_ToNonexistingDirectory) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
-  const std::string kParentResourceId = "folder:nonexisting_resource_id";
+  const std::string kParentResourceId = "nonexisting_resource_id";
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   scoped_ptr<FileResource> entry;
   fake_service_.AddNewDirectory(
       kParentResourceId,
       "new directory",
       DriveServiceInterface::AddNewDirectoryOptions(),
       test_util::CreateCopyResultCallback(&error, &entry));
   base::RunLoop().RunUntilIdle();
 
@@ skipping 20 matching lines @@
 
 TEST_F(FakeDriveServiceTest, InitiateUploadNewFile_Offline) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
   fake_service_.set_offline(true);
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   GURL upload_location;
   fake_service_.InitiateUploadNewFile(
       "test/foo",
       13,
-      "folder:1_folder_resource_id",
+      "1_folder_resource_id",
       "new file.foo",
       FakeDriveService::InitiateUploadNewFileOptions(),
       test_util::CreateCopyResultCallback(&error, &upload_location));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(GDATA_NO_CONNECTION, error);
   EXPECT_TRUE(upload_location.is_empty());
 }
 
 TEST_F(FakeDriveServiceTest, InitiateUploadNewFile_NotFound) {
@@ skipping 15 matching lines @@
 }
 
 TEST_F(FakeDriveServiceTest, InitiateUploadNewFile) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   GURL upload_location;
   fake_service_.InitiateUploadNewFile(
       "test/foo",
       13,
-      "folder:1_folder_resource_id",
+      "1_folder_resource_id",
       "new file.foo",
       FakeDriveService::InitiateUploadNewFileOptions(),
       test_util::CreateCopyResultCallback(&error, &upload_location));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_FALSE(upload_location.is_empty());
   EXPECT_NE(GURL("https://1_folder_resumable_create_media_link?mode=newfile"),
             upload_location);
 }
 
 TEST_F(FakeDriveServiceTest, InitiateUploadExistingFile_Offline) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
   fake_service_.set_offline(true);
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   GURL upload_location;
   fake_service_.InitiateUploadExistingFile(
       "test/foo",
       13,
-      "file:2_file_resource_id",
+      "2_file_resource_id",
       FakeDriveService::InitiateUploadExistingFileOptions(),
       test_util::CreateCopyResultCallback(&error, &upload_location));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(GDATA_NO_CONNECTION, error);
   EXPECT_TRUE(upload_location.is_empty());
 }
 
 TEST_F(FakeDriveServiceTest, InitiateUploadExistingFile_NotFound) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
@@ skipping 16 matching lines @@
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
   FakeDriveService::InitiateUploadExistingFileOptions options;
   options.etag = "invalid_etag";
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   GURL upload_location;
   fake_service_.InitiateUploadExistingFile(
       "text/plain",
       13,
-      "file:2_file_resource_id",
+      "2_file_resource_id",
       options,
       test_util::CreateCopyResultCallback(&error, &upload_location));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_PRECONDITION, error);
   EXPECT_TRUE(upload_location.is_empty());
 }
 
 TEST_F(FakeDriveServiceTest, InitiateUpload_ExistingFile) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
-  scoped_ptr<FileResource> entry = FindEntry("file:2_file_resource_id");
+  scoped_ptr<FileResource> entry = FindEntry("2_file_resource_id");
   ASSERT_TRUE(entry);
 
   FakeDriveService::InitiateUploadExistingFileOptions options;
   options.etag = entry->etag();
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   GURL upload_location;
   fake_service_.InitiateUploadExistingFile(
       "text/plain",
       13,
-      "file:2_file_resource_id",
+      "2_file_resource_id",
       options,
       test_util::CreateCopyResultCallback(&error, &upload_location));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_TRUE(upload_location.is_valid());
 }
 
 TEST_F(FakeDriveServiceTest, ResumeUpload_Offline) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   GURL upload_location;
   fake_service_.InitiateUploadNewFile(
       "test/foo",
       15,
-      "folder:1_folder_resource_id",
+      "1_folder_resource_id",
       "new file.foo",
       FakeDriveService::InitiateUploadNewFileOptions(),
       test_util::CreateCopyResultCallback(&error, &upload_location));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_FALSE(upload_location.is_empty());
   EXPECT_NE(GURL("https://1_folder_resumable_create_media_link"),
             upload_location);
 
@@ skipping 14 matching lines @@
 }
 
 TEST_F(FakeDriveServiceTest, ResumeUpload_NotFound) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   GURL upload_location;
   fake_service_.InitiateUploadNewFile(
       "test/foo",
       15,
-      "folder:1_folder_resource_id",
+      "1_folder_resource_id",
       "new file.foo",
       FakeDriveService::InitiateUploadNewFileOptions(),
       test_util::CreateCopyResultCallback(&error, &upload_location));
   base::RunLoop().RunUntilIdle();
 
   ASSERT_EQ(HTTP_SUCCESS, error);
 
   UploadRangeResponse response;
   scoped_ptr<FileResource> entry;
   fake_service_.ResumeUpload(
@@ skipping 11 matching lines @@
 TEST_F(FakeDriveServiceTest, ResumeUpload_ExistingFile) {
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   base::FilePath local_file_path =
       temp_dir.path().Append(FILE_PATH_LITERAL("File 1.txt"));
   std::string contents("hogefugapiyo");
   ASSERT_TRUE(test_util::WriteStringToFile(local_file_path, contents));
 
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
-  scoped_ptr<FileResource> entry = FindEntry("file:2_file_resource_id");
+  scoped_ptr<FileResource> entry = FindEntry("2_file_resource_id");
   ASSERT_TRUE(entry);
 
   FakeDriveService::InitiateUploadExistingFileOptions options;
   options.etag = entry->etag();
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   GURL upload_location;
   fake_service_.InitiateUploadExistingFile(
       "text/plain",
       contents.size(),
-      "file:2_file_resource_id",
+      "2_file_resource_id",
       options,
       test_util::CreateCopyResultCallback(&error, &upload_location));
   base::RunLoop().RunUntilIdle();
 
   ASSERT_EQ(HTTP_SUCCESS, error);
 
   UploadRangeResponse response;
   entry.reset();
   std::vector<test_util::ProgressInfo> upload_progress_values;
   fake_service_.ResumeUpload(
@@ skipping 43 matching lines @@
   std::string contents("hogefugapiyo");
   ASSERT_TRUE(test_util::WriteStringToFile(local_file_path, contents));
 
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   GURL upload_location;
   fake_service_.InitiateUploadNewFile(
       "test/foo",
       contents.size(),
-      "folder:1_folder_resource_id",
+      "1_folder_resource_id",
       "new file.foo",
       FakeDriveService::InitiateUploadNewFileOptions(),
       test_util::CreateCopyResultCallback(&error, &upload_location));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_FALSE(upload_location.is_empty());
   EXPECT_NE(GURL("https://1_folder_resumable_create_media_link"),
             upload_location);
 
@@ skipping 106 matching lines @@
 }
 
 TEST_F(FakeDriveServiceTest, AddNewFile_ToNonRootDirectory) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
   int64 old_largest_change_id = GetLargestChangeByAboutResource();
 
   const std::string kContentType = "text/plain";
   const std::string kContentData = "This is some test content.";
   const std::string kTitle = "new file";
-  const std::string kParentResourceId = "folder:1_folder_resource_id";
+  const std::string kParentResourceId = "1_folder_resource_id";
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   scoped_ptr<FileResource> entry;
   fake_service_.AddNewFile(
       kContentType,
       kContentData,
       kParentResourceId,
       kTitle,
       false,  // shared_with_me
       test_util::CreateCopyResultCallback(&error, &entry));
@@ skipping 12 matching lines @@
   EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource());
   EXPECT_EQ(base::MD5String(kContentData), entry->md5_checksum());
 }
 
 TEST_F(FakeDriveServiceTest, AddNewFile_ToNonexistingDirectory) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
   const std::string kContentType = "text/plain";
   const std::string kContentData = "This is some test content.";
   const std::string kTitle = "new file";
-  const std::string kParentResourceId = "folder:nonexisting_resource_id";
+  const std::string kParentResourceId = "nonexisting_resource_id";
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   scoped_ptr<FileResource> entry;
   fake_service_.AddNewFile(
       kContentType,
       kContentData,
       kParentResourceId,
       kTitle,
       false,  // shared_with_me
       test_util::CreateCopyResultCallback(&error, &entry));
@@ skipping 57 matching lines @@
   // Should be incremented as a new directory was created.
   EXPECT_EQ(old_largest_change_id + 1,
             fake_service_.about_resource().largest_change_id());
   EXPECT_EQ(old_largest_change_id + 1, GetLargestChangeByAboutResource());
   EXPECT_EQ(base::MD5String(kContentData), entry->md5_checksum());
 }
 
 TEST_F(FakeDriveServiceTest, SetLastModifiedTime_ExistingFile) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
-  const std::string kResourceId = "file:2_file_resource_id";
+  const std::string kResourceId = "2_file_resource_id";
   base::Time time;
   ASSERT_TRUE(base::Time::FromString("1 April 2013 12:34:56", &time));
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   scoped_ptr<FileResource> entry;
   fake_service_.SetLastModifiedTime(
       kResourceId,
       time,
       test_util::CreateCopyResultCallback(&error, &entry));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   ASSERT_TRUE(entry);
   EXPECT_EQ(time, entry->modified_date());
 }
 
 TEST_F(FakeDriveServiceTest, SetLastModifiedTime_NonexistingFile) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
-  const std::string kResourceId = "file:nonexisting_resource_id";
+  const std::string kResourceId = "nonexisting_resource_id";
   base::Time time;
   ASSERT_TRUE(base::Time::FromString("1 April 2013 12:34:56", &time));
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   scoped_ptr<FileResource> entry;
   fake_service_.SetLastModifiedTime(
       kResourceId,
       time,
       test_util::CreateCopyResultCallback(&error, &entry));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_NOT_FOUND, error);
   EXPECT_FALSE(entry);
 }
 
 TEST_F(FakeDriveServiceTest, SetLastModifiedTime_Offline) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
   fake_service_.set_offline(true);
 
-  const std::string kResourceId = "file:2_file_resource_id";
+  const std::string kResourceId = "2_file_resource_id";
   base::Time time;
   ASSERT_TRUE(base::Time::FromString("1 April 2013 12:34:56", &time));
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   scoped_ptr<FileResource> entry;
   fake_service_.SetLastModifiedTime(
       kResourceId,
       time,
       test_util::CreateCopyResultCallback(&error, &entry));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(GDATA_NO_CONNECTION, error);
   EXPECT_FALSE(entry);
 }
 
 }  // namespace
 
 }  // namespace drive