Remove google_apis::ResourceEntry and related code

chrome/browser/sync_file_system/drive_backend/drive_backend_sync_unittest.cc

 // Copyright 2014 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 <algorithm>
 #include <stack>
 
 #include "base/files/file_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
@@ skipping 393 matching lines @@
     std::string sync_root_folder_id;
     google_apis::GDataErrorCode error =
         fake_drive_service_helper_->GetSyncRootFolderID(&sync_root_folder_id);
     if (sync_root_folder_id.empty()) {
       EXPECT_EQ(google_apis::HTTP_NOT_FOUND, error);
       EXPECT_TRUE(file_systems_.empty());
       return;
     }
     EXPECT_EQ(google_apis::HTTP_SUCCESS, error);
 
-    ScopedVector<google_apis::ResourceEntry> remote_entries;
+    ScopedVector<google_apis::FileResource> remote_entries;
     EXPECT_EQ(google_apis::HTTP_SUCCESS,
               fake_drive_service_helper_->ListFilesInFolder(
                   sync_root_folder_id, &remote_entries));
-    std::map<std::string, const google_apis::ResourceEntry*> app_root_by_title;
-    for (ScopedVector<google_apis::ResourceEntry>::iterator itr =
+    std::map<std::string, const google_apis::FileResource*> app_root_by_title;
+    for (ScopedVector<google_apis::FileResource>::iterator itr =
              remote_entries.begin();
          itr != remote_entries.end();
          ++itr) {
-      const google_apis::ResourceEntry& remote_entry = **itr;
+      const google_apis::FileResource& remote_entry = **itr;
       EXPECT_FALSE(ContainsKey(app_root_by_title, remote_entry.title()));
       app_root_by_title[remote_entry.title()] = *itr;
     }
 
     for (std::map<std::string, CannedSyncableFileSystem*>::const_iterator itr =
              file_systems_.begin();
          itr != file_systems_.end(); ++itr) {
       const std::string& app_id = itr->first;
       SCOPED_TRACE(testing::Message() << "Verifying app: " << app_id);
       CannedSyncableFileSystem* file_system = itr->second;
       ASSERT_TRUE(ContainsKey(app_root_by_title, app_id));
       VerifyConsistencyForFolder(
           app_id, base::FilePath(),
-          app_root_by_title[app_id]->resource_id(),
+          app_root_by_title[app_id]->file_id(),
           file_system);
     }
   }
 
   void VerifyConsistencyForFolder(const std::string& app_id,
                                   const base::FilePath& path,
                                   const std::string& folder_id,
                                   CannedSyncableFileSystem* file_system) {
     SCOPED_TRACE(testing::Message() << "Verifying folder: " << path.value());
 
-    ScopedVector<google_apis::ResourceEntry> remote_entries;
+    ScopedVector<google_apis::FileResource> remote_entries;
     EXPECT_EQ(google_apis::HTTP_SUCCESS,
               fake_drive_service_helper_->ListFilesInFolder(
                   folder_id, &remote_entries));
-    std::map<std::string, const google_apis::ResourceEntry*>
+    std::map<std::string, const google_apis::FileResource*>
         remote_entry_by_title;
     for (size_t i = 0; i < remote_entries.size(); ++i) {
-      google_apis::ResourceEntry* remote_entry = remote_entries[i];
+      google_apis::FileResource* remote_entry = remote_entries[i];
       EXPECT_FALSE(ContainsKey(remote_entry_by_title, remote_entry->title()))
           << "title: " << remote_entry->title();
       remote_entry_by_title[remote_entry->title()] = remote_entry;
     }
 
     storage::FileSystemURL url(CreateURL(app_id, path));
     FileEntryList local_entries;
     EXPECT_EQ(base::File::FILE_OK,
               file_system->ReadDirectory(url, &local_entries));
     for (FileEntryList::iterator itr = local_entries.begin();
          itr != local_entries.end();
          ++itr) {
       const storage::DirectoryEntry& local_entry = *itr;
       storage::FileSystemURL entry_url(
           CreateURL(app_id, path.Append(local_entry.name)));
       std::string title =
           storage::VirtualPath::BaseName(entry_url.path()).AsUTF8Unsafe();
       SCOPED_TRACE(testing::Message() << "Verifying entry: " << title);
 
       ASSERT_TRUE(ContainsKey(remote_entry_by_title, title));
-      const google_apis::ResourceEntry& remote_entry =
+      const google_apis::FileResource& remote_entry =
           *remote_entry_by_title[title];
       if (local_entry.is_directory) {
-        ASSERT_TRUE(remote_entry.is_folder());
+        ASSERT_TRUE(remote_entry.IsDirectory());
         VerifyConsistencyForFolder(app_id, entry_url.path(),
-                                   remote_entry.resource_id(),
+                                   remote_entry.file_id(),
                                    file_system);
       } else {
-        ASSERT_TRUE(remote_entry.is_file());
+        ASSERT_FALSE(remote_entry.IsDirectory());
         VerifyConsistencyForFile(app_id, entry_url.path(),
-                                 remote_entry.resource_id(),
+                                 remote_entry.file_id(),
                                  file_system);
       }
       remote_entry_by_title.erase(title);
     }
 
     EXPECT_TRUE(remote_entry_by_title.empty());
   }
 
   void VerifyConsistencyForFile(const std::string& app_id,
                                 const base::FilePath& path,
@@ skipping 1223 matching lines @@
 
   EXPECT_EQ(1u, CountApp());
   EXPECT_EQ(1u, CountLocalFile(app_id));
 
   EXPECT_EQ(2u, CountMetadata());
   EXPECT_EQ(2u, CountTracker());
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system