drive: Replace GetResourceListCallback in DriveServiceInterface with FileListCallback

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"
 #include "base/files/scoped_temp_dir.h"
 #include "base/md5.h"
 #include "base/run_loop.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/drive/test_util.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "google_apis/drive/drive_api_parser.h"
 #include "google_apis/drive/gdata_wapi_parser.h"
 #include "google_apis/drive/gdata_wapi_requests.h"
 #include "google_apis/drive/test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using google_apis::AboutResource;
 using google_apis::AppList;
 using google_apis::ChangeList;
 using google_apis::ChangeResource;
+using google_apis::FileList;
 using google_apis::GDATA_NO_CONNECTION;
 using google_apis::GDATA_OTHER_ERROR;
 using google_apis::GDataErrorCode;
 using google_apis::GetContentCallback;
 using google_apis::HTTP_CREATED;
 using google_apis::HTTP_NOT_FOUND;
 using google_apis::HTTP_NO_CONTENT;
 using google_apis::HTTP_PRECONDITION;
 using google_apis::HTTP_RESUME_INCOMPLETE;
 using google_apis::HTTP_SUCCESS;
 using google_apis::Link;
 using google_apis::ProgressCallback;
 using google_apis::ResourceEntry;
-using google_apis::ResourceList;
 using google_apis::UploadRangeResponse;
 
 namespace drive {
 
 namespace test_util {
 
 using google_apis::test_util::AppendProgressCallbackResult;
 using google_apis::test_util::CreateCopyResultCallback;
 using google_apis::test_util::ProgressInfo;
 using google_apis::test_util::TestGetContentCallback;
@@ skipping 58 matching lines @@
     fake_service_.GetAboutResource(
         test_util::CreateCopyResultCallback(&error, &about_resource));
     base::RunLoop().RunUntilIdle();
     return about_resource->largest_change_id();
   }
 
   content::TestBrowserThreadBundle thread_bundle_;
   FakeDriveService fake_service_;
 };
 
-TEST_F(FakeDriveServiceTest, GetAllResourceList) {
+TEST_F(FakeDriveServiceTest, GetAllFileList) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
-  scoped_ptr<ResourceList> resource_list;
-  fake_service_.GetAllResourceList(
-      test_util::CreateCopyResultCallback(&error, &resource_list));
+  scoped_ptr<FileList> file_list;
+  fake_service_.GetAllFileList(
+      test_util::CreateCopyResultCallback(&error, &file_list));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_SUCCESS, error);
-  ASSERT_TRUE(resource_list);
+  ASSERT_TRUE(file_list);
   // Do some sanity check.
-  EXPECT_EQ(15U, resource_list->entries().size());
-  EXPECT_EQ(1, fake_service_.resource_list_load_count());
+  EXPECT_EQ(15U, file_list->items().size());
+  EXPECT_EQ(1, fake_service_.file_list_load_count());
 }
 
-TEST_F(FakeDriveServiceTest, GetAllResourceList_Offline) {
+TEST_F(FakeDriveServiceTest, GetAllFileList_Offline) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
   fake_service_.set_offline(true);
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
-  scoped_ptr<ResourceList> resource_list;
-  fake_service_.GetAllResourceList(
-      test_util::CreateCopyResultCallback(&error, &resource_list));
+  scoped_ptr<FileList> file_list;
+  fake_service_.GetAllFileList(
+      test_util::CreateCopyResultCallback(&error, &file_list));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(GDATA_NO_CONNECTION, error);
-  EXPECT_FALSE(resource_list);
+  EXPECT_FALSE(file_list);
 }
 
-TEST_F(FakeDriveServiceTest, GetResourceListInDirectory_InRootDirectory) {
+TEST_F(FakeDriveServiceTest, GetFileListInDirectory_InRootDirectory) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
-  scoped_ptr<ResourceList> resource_list;
-  fake_service_.GetResourceListInDirectory(
+  scoped_ptr<FileList> file_list;
+  fake_service_.GetFileListInDirectory(
       fake_service_.GetRootResourceId(),
-      test_util::CreateCopyResultCallback(&error, &resource_list));
+      test_util::CreateCopyResultCallback(&error, &file_list));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_SUCCESS, error);
-  ASSERT_TRUE(resource_list);
+  ASSERT_TRUE(file_list);
   // Do some sanity check. There are 8 entries in the root directory.
-  EXPECT_EQ(8U, resource_list->entries().size());
+  EXPECT_EQ(8U, file_list->items().size());
   EXPECT_EQ(1, fake_service_.directory_load_count());
 }
 
-TEST_F(FakeDriveServiceTest, GetResourceListInDirectory_InNonRootDirectory) {
+TEST_F(FakeDriveServiceTest, GetFileListInDirectory_InNonRootDirectory) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
-  scoped_ptr<ResourceList> resource_list;
-  fake_service_.GetResourceListInDirectory(
+  scoped_ptr<FileList> file_list;
+  fake_service_.GetFileListInDirectory(
       "folder:1_folder_resource_id",
-      test_util::CreateCopyResultCallback(&error, &resource_list));
+      test_util::CreateCopyResultCallback(&error, &file_list));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_SUCCESS, error);
-  ASSERT_TRUE(resource_list);
+  ASSERT_TRUE(file_list);
   // Do some sanity check. There is three entries in 1_folder_resource_id
   // directory.
-  EXPECT_EQ(3U, resource_list->entries().size());
+  EXPECT_EQ(3U, file_list->items().size());
   EXPECT_EQ(1, fake_service_.directory_load_count());
 }
 
-TEST_F(FakeDriveServiceTest, GetResourceListInDirectory_Offline) {
+TEST_F(FakeDriveServiceTest, GetFileListInDirectory_Offline) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
   fake_service_.set_offline(true);
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
-  scoped_ptr<ResourceList> resource_list;
-  fake_service_.GetResourceListInDirectory(
+  scoped_ptr<FileList> file_list;
+  fake_service_.GetFileListInDirectory(
       fake_service_.GetRootResourceId(),
-      test_util::CreateCopyResultCallback(&error, &resource_list));
+      test_util::CreateCopyResultCallback(&error, &file_list));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(GDATA_NO_CONNECTION, error);
-  EXPECT_FALSE(resource_list);
+  EXPECT_FALSE(file_list);
 }
 
 TEST_F(FakeDriveServiceTest, Search) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
-  scoped_ptr<ResourceList> resource_list;
+  scoped_ptr<FileList> file_list;
   fake_service_.Search(
       "File",  // search_query
-      test_util::CreateCopyResultCallback(&error, &resource_list));
+      test_util::CreateCopyResultCallback(&error, &file_list));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_SUCCESS, error);
-  ASSERT_TRUE(resource_list);
+  ASSERT_TRUE(file_list);
   // Do some sanity check. There are 4 entries that contain "File" in their
   // titles.
-  EXPECT_EQ(4U, resource_list->entries().size());
+  EXPECT_EQ(4U, file_list->items().size());
 }
 
 TEST_F(FakeDriveServiceTest, Search_WithAttribute) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
-  scoped_ptr<ResourceList> resource_list;
+  scoped_ptr<FileList> file_list;
   fake_service_.Search(
       "title:1.txt",  // search_query
-      test_util::CreateCopyResultCallback(&error, &resource_list));
+      test_util::CreateCopyResultCallback(&error, &file_list));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_SUCCESS, error);
-  ASSERT_TRUE(resource_list);
+  ASSERT_TRUE(file_list);
   // Do some sanity check. There are 4 entries that contain "1.txt" in their
   // titles.
-  EXPECT_EQ(4U, resource_list->entries().size());
+  EXPECT_EQ(4U, file_list->items().size());
 }
 
 TEST_F(FakeDriveServiceTest, Search_MultipleQueries) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
-  scoped_ptr<ResourceList> resource_list;
+  scoped_ptr<FileList> file_list;
   fake_service_.Search(
       "Directory 1",  // search_query
-      test_util::CreateCopyResultCallback(&error, &resource_list));
+      test_util::CreateCopyResultCallback(&error, &file_list));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_SUCCESS, error);
-  ASSERT_TRUE(resource_list);
+  ASSERT_TRUE(file_list);
   // There are 2 entries that contain both "Directory" and "1" in their titles.
-  EXPECT_EQ(2U, resource_list->entries().size());
+  EXPECT_EQ(2U, file_list->items().size());
 
   fake_service_.Search(
       "\"Directory 1\"",  // search_query
-      test_util::CreateCopyResultCallback(&error, &resource_list));
+      test_util::CreateCopyResultCallback(&error, &file_list));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_SUCCESS, error);
-  ASSERT_TRUE(resource_list);
+  ASSERT_TRUE(file_list);
   // There is 1 entry that contain "Directory 1" in its title.
-  EXPECT_EQ(1U, resource_list->entries().size());
+  EXPECT_EQ(1U, file_list->items().size());
 }
 
 TEST_F(FakeDriveServiceTest, Search_Offline) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
   fake_service_.set_offline(true);
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
-  scoped_ptr<ResourceList> resource_list;
+  scoped_ptr<FileList> file_list;
   fake_service_.Search(
       "Directory 1",  // search_query
-      test_util::CreateCopyResultCallback(&error, &resource_list));
+      test_util::CreateCopyResultCallback(&error, &file_list));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(GDATA_NO_CONNECTION, error);
-  EXPECT_FALSE(resource_list);
+  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",
                                std::string(),  // etag
                                test_util::CreateCopyResultCallback(&error));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(HTTP_NO_CONTENT, error);
 
   error = GDATA_OTHER_ERROR;
-  scoped_ptr<ResourceList> resource_list;
+  scoped_ptr<FileList> file_list;
   fake_service_.Search(
       "File",  // search_query
-      test_util::CreateCopyResultCallback(&error, &resource_list));
+      test_util::CreateCopyResultCallback(&error, &file_list));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_SUCCESS, error);
-  ASSERT_TRUE(resource_list);
+  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, resource_list->entries().size());
+  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",
                               test_util::CreateCopyResultCallback(&error));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(HTTP_SUCCESS, error);
 
   error = GDATA_OTHER_ERROR;
-  scoped_ptr<ResourceList> resource_list;
+  scoped_ptr<FileList> file_list;
   fake_service_.Search(
       "File",  // search_query
-      test_util::CreateCopyResultCallback(&error, &resource_list));
+      test_util::CreateCopyResultCallback(&error, &file_list));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_SUCCESS, error);
-  ASSERT_TRUE(resource_list);
+  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, resource_list->entries().size());
+  EXPECT_EQ(3U, file_list->items().size());
 }
 
 TEST_F(FakeDriveServiceTest, SearchByTitle) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
-  scoped_ptr<ResourceList> resource_list;
+  scoped_ptr<FileList> file_list;
   fake_service_.SearchByTitle(
       "1.txt",  // title
       fake_service_.GetRootResourceId(),  // directory_resource_id
-      test_util::CreateCopyResultCallback(&error, &resource_list));
+      test_util::CreateCopyResultCallback(&error, &file_list));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_SUCCESS, error);
-  ASSERT_TRUE(resource_list);
+  ASSERT_TRUE(file_list);
   // Do some sanity check. There are 2 entries that contain "1.txt" in their
   // titles directly under the root directory.
-  EXPECT_EQ(2U, resource_list->entries().size());
+  EXPECT_EQ(2U, file_list->items().size());
 }
 
 TEST_F(FakeDriveServiceTest, SearchByTitle_EmptyDirectoryResourceId) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
-  scoped_ptr<ResourceList> resource_list;
+  scoped_ptr<FileList> file_list;
   fake_service_.SearchByTitle(
       "1.txt",  // title
       "",  // directory resource id
-      test_util::CreateCopyResultCallback(&error, &resource_list));
+      test_util::CreateCopyResultCallback(&error, &file_list));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_SUCCESS, error);
-  ASSERT_TRUE(resource_list);
+  ASSERT_TRUE(file_list);
   // Do some sanity check. There are 4 entries that contain "1.txt" in their
   // titles.
-  EXPECT_EQ(4U, resource_list->entries().size());
+  EXPECT_EQ(4U, file_list->items().size());
 }
 
 TEST_F(FakeDriveServiceTest, SearchByTitle_Offline) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
   fake_service_.set_offline(true);
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
-  scoped_ptr<ResourceList> resource_list;
+  scoped_ptr<FileList> file_list;
   fake_service_.SearchByTitle(
       "Directory 1",  // title
       fake_service_.GetRootResourceId(),  // directory_resource_id
-      test_util::CreateCopyResultCallback(&error, &resource_list));
+      test_util::CreateCopyResultCallback(&error, &file_list));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(GDATA_NO_CONNECTION, error);
-  EXPECT_FALSE(resource_list);
+  EXPECT_FALSE(file_list);
 }
 
 TEST_F(FakeDriveServiceTest, GetChangeList_NoNewEntries) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   scoped_ptr<ChangeList> change_list;
   fake_service_.GetChangeList(
       fake_service_.about_resource().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());
   // This should be empty as the latest changestamp was passed to
-  // GetResourceList(), hence there should be no new entries.
+  // GetChangeList(), hence there should be no new entries.
   EXPECT_EQ(0U, change_list->items().size());
   // It's considered loaded even if the result is empty.
   EXPECT_EQ(1, fake_service_.change_list_load_count());
 }
 
 TEST_F(FakeDriveServiceTest, GetChangeList_WithNewEntry) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
   const int64 old_largest_change_id =
       fake_service_.about_resource().largest_change_id();
 
@@ skipping 97 matching lines @@
             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());
   ASSERT_TRUE(item.file());
   EXPECT_TRUE(item.file()->labels().is_trashed());
   EXPECT_EQ(1, fake_service_.change_list_load_count());
 }
 
-TEST_F(FakeDriveServiceTest, GetRemainingFileList_GetAllResourceList) {
+TEST_F(FakeDriveServiceTest, GetRemainingFileList_GetAllFileList) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
   fake_service_.set_default_max_results(6);
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
-  scoped_ptr<ResourceList> resource_list;
-  fake_service_.GetAllResourceList(
-      test_util::CreateCopyResultCallback(&error, &resource_list));
+  scoped_ptr<FileList> file_list;
+  fake_service_.GetAllFileList(
+      test_util::CreateCopyResultCallback(&error, &file_list));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(HTTP_SUCCESS, error);
-  ASSERT_TRUE(resource_list);
+  ASSERT_TRUE(file_list);
 
   // Do some sanity check.
   // The number of results is 14 entries. Thus, it should split into three
   // chunks: 6, 6, and then 2.
-  EXPECT_EQ(6U, resource_list->entries().size());
-  EXPECT_EQ(1, fake_service_.resource_list_load_count());
+  EXPECT_EQ(6U, file_list->items().size());
+  EXPECT_EQ(1, fake_service_.file_list_load_count());
 
   // Second page loading.
-  const google_apis::Link* next_link =
-      resource_list->GetLinkByType(Link::LINK_NEXT);
-  ASSERT_TRUE(next_link);
-  // Keep the next url before releasing the |resource_list|.
-  GURL next_url(next_link->href());
+  // Keep the next url before releasing the |file_list|.
+  GURL next_url(file_list->next_link());
 
   error = GDATA_OTHER_ERROR;
-  resource_list.reset();
+  file_list.reset();
   fake_service_.GetRemainingFileList(
       next_url,
-      test_util::CreateCopyResultCallback(&error, &resource_list));
+      test_util::CreateCopyResultCallback(&error, &file_list));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_SUCCESS, error);
-  ASSERT_TRUE(resource_list);
+  ASSERT_TRUE(file_list);
 
-  EXPECT_EQ(6U, resource_list->entries().size());
-  EXPECT_EQ(1, fake_service_.resource_list_load_count());
+  EXPECT_EQ(6U, file_list->items().size());
+  EXPECT_EQ(1, fake_service_.file_list_load_count());
 
   // Third page loading.
-  next_link = resource_list->GetLinkByType(Link::LINK_NEXT);
-  ASSERT_TRUE(next_link);
-  next_url = GURL(next_link->href());
+  next_url = file_list->next_link();
 
   error = GDATA_OTHER_ERROR;
-  resource_list.reset();
+  file_list.reset();
   fake_service_.GetRemainingFileList(
       next_url,
-      test_util::CreateCopyResultCallback(&error, &resource_list));
+      test_util::CreateCopyResultCallback(&error, &file_list));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_SUCCESS, error);
-  ASSERT_TRUE(resource_list);
+  ASSERT_TRUE(file_list);
 
-  EXPECT_EQ(3U, resource_list->entries().size());
-  EXPECT_EQ(1, fake_service_.resource_list_load_count());
+  EXPECT_EQ(3U, file_list->items().size());
+  EXPECT_EQ(1, fake_service_.file_list_load_count());
 }
 
-TEST_F(FakeDriveServiceTest,
-       GetRemainingFileList_GetResourceListInDirectory) {
+TEST_F(FakeDriveServiceTest, GetRemainingFileList_GetFileListInDirectory) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
   fake_service_.set_default_max_results(3);
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
-  scoped_ptr<ResourceList> resource_list;
-  fake_service_.GetResourceListInDirectory(
+  scoped_ptr<FileList> file_list;
+  fake_service_.GetFileListInDirectory(
       fake_service_.GetRootResourceId(),
-      test_util::CreateCopyResultCallback(&error, &resource_list));
+      test_util::CreateCopyResultCallback(&error, &file_list));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(HTTP_SUCCESS, error);
-  ASSERT_TRUE(resource_list);
+  ASSERT_TRUE(file_list);
 
   // Do some sanity check.
   // The number of results is 8 entries. Thus, it should split into three
   // chunks: 3, 3, and then 2.
-  EXPECT_EQ(3U, resource_list->entries().size());
+  EXPECT_EQ(3U, file_list->items().size());
   EXPECT_EQ(1, fake_service_.directory_load_count());
 
   // Second page loading.
-  const google_apis::Link* next_link =
-      resource_list->GetLinkByType(Link::LINK_NEXT);
-  ASSERT_TRUE(next_link);
-  // Keep the next url before releasing the |resource_list|.
-  GURL next_url(next_link->href());
+  // Keep the next url before releasing the |file_list|.
+  GURL next_url = file_list->next_link();
 
   error = GDATA_OTHER_ERROR;
-  resource_list.reset();
+  file_list.reset();
   fake_service_.GetRemainingFileList(
       next_url,
-      test_util::CreateCopyResultCallback(&error, &resource_list));
+      test_util::CreateCopyResultCallback(&error, &file_list));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_SUCCESS, error);
-  ASSERT_TRUE(resource_list);
+  ASSERT_TRUE(file_list);
 
-  EXPECT_EQ(3U, resource_list->entries().size());
+  EXPECT_EQ(3U, file_list->items().size());
   EXPECT_EQ(1, fake_service_.directory_load_count());
 
   // Third page loading.
-  next_link = resource_list->GetLinkByType(Link::LINK_NEXT);
-  ASSERT_TRUE(next_link);
-  next_url = GURL(next_link->href());
+  next_url = file_list->next_link();
 
   error = GDATA_OTHER_ERROR;
-  resource_list.reset();
+  file_list.reset();
   fake_service_.GetRemainingFileList(
       next_url,
-      test_util::CreateCopyResultCallback(&error, &resource_list));
+      test_util::CreateCopyResultCallback(&error, &file_list));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_SUCCESS, error);
-  ASSERT_TRUE(resource_list);
+  ASSERT_TRUE(file_list);
 
-  EXPECT_EQ(2U, resource_list->entries().size());
+  EXPECT_EQ(2U, file_list->items().size());
   EXPECT_EQ(1, fake_service_.directory_load_count());
 }
 
 TEST_F(FakeDriveServiceTest, GetRemainingFileList_Search) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
   fake_service_.set_default_max_results(2);
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
-  scoped_ptr<ResourceList> resource_list;
+  scoped_ptr<FileList> file_list;
   fake_service_.Search(
       "File",  // search_query
-      test_util::CreateCopyResultCallback(&error, &resource_list));
+      test_util::CreateCopyResultCallback(&error, &file_list));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(HTTP_SUCCESS, error);
-  ASSERT_TRUE(resource_list);
+  ASSERT_TRUE(file_list);
 
   // Do some sanity check.
   // The number of results is 4 entries. Thus, it should split into two
   // chunks: 2, and then 2
-  EXPECT_EQ(2U, resource_list->entries().size());
+  EXPECT_EQ(2U, file_list->items().size());
 
   // Second page loading.
-  const google_apis::Link* next_link =
-      resource_list->GetLinkByType(Link::LINK_NEXT);
-  ASSERT_TRUE(next_link);
-  // Keep the next url before releasing the |resource_list|.
-  GURL next_url(next_link->href());
+  // Keep the next url before releasing the |file_list|.
+  GURL next_url = file_list->next_link();
 
   error = GDATA_OTHER_ERROR;
-  resource_list.reset();
+  file_list.reset();
   fake_service_.GetRemainingFileList(
       next_url,
-      test_util::CreateCopyResultCallback(&error, &resource_list));
+      test_util::CreateCopyResultCallback(&error, &file_list));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_SUCCESS, error);
-  ASSERT_TRUE(resource_list);
+  ASSERT_TRUE(file_list);
 
-  EXPECT_EQ(2U, resource_list->entries().size());
+  EXPECT_EQ(2U, file_list->items().size());
 }
 
 TEST_F(FakeDriveServiceTest, GetRemainingChangeList_GetChangeList) {
   ASSERT_TRUE(test_util::SetUpTestEntries(&fake_service_));
   fake_service_.set_default_max_results(2);
   const int64 old_largest_change_id =
       fake_service_.about_resource().largest_change_id();
 
   // Add 5 new directory in the root directory.
   for (int i = 0; i < 5; ++i) {
@@ skipping 1574 matching lines @@
       test_util::CreateCopyResultCallback(&error, &resource_entry));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(GDATA_NO_CONNECTION, error);
   EXPECT_FALSE(resource_entry);
 }
 
 }  // namespace
 
 }  // namespace drive