Convert Media Galleries to use base::File

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 "base/file_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "chrome/browser/drive/drive_uploader.h"
@@ skipping 126 matching lines @@
       SyncStatusCode status = SYNC_STATUS_UNKNOWN;
       local_sync_service_->MaybeInitializeFileSystemContext(
           origin, file_system->file_system_context(),
           CreateResultReceiver(&status));
       base::RunLoop().RunUntilIdle();
       EXPECT_EQ(SYNC_STATUS_OK, status);
 
       file_system->backend()->sync_context()->
           set_mock_notify_changes_duration_in_sec(0);
 
-      EXPECT_EQ(base::PLATFORM_FILE_OK, file_system->OpenFileSystem());
+      EXPECT_EQ(base::File::FILE_OK, file_system->OpenFileSystem());
       file_systems_[app_id] = file_system;
     }
 
     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
     remote_sync_service_->RegisterOrigin(origin, CreateResultReceiver(&status));
     base::RunLoop().RunUntilIdle();
     return status;
   }
 
   void AddLocalFolder(const std::string& app_id,
                       const base::FilePath::StringType& path) {
     ASSERT_TRUE(ContainsKey(file_systems_, app_id));
-    EXPECT_EQ(base::PLATFORM_FILE_OK,
+    EXPECT_EQ(base::File::FILE_OK,
               file_systems_[app_id]->CreateDirectory(
                   CreateURL(app_id, path)));
   }
 
   void AddOrUpdateLocalFile(const std::string& app_id,
                             const base::FilePath::StringType& path,
                             const std::string& content) {
     fileapi::FileSystemURL url(CreateURL(app_id, path));
     ASSERT_TRUE(ContainsKey(file_systems_, app_id));
-    EXPECT_EQ(base::PLATFORM_FILE_OK, file_systems_[app_id]->CreateFile(url));
+    EXPECT_EQ(base::File::FILE_OK, file_systems_[app_id]->CreateFile(url));
     int64 bytes_written = file_systems_[app_id]->WriteString(url, content);
     EXPECT_EQ(static_cast<int64>(content.size()), bytes_written);
     base::RunLoop().RunUntilIdle();
   }
 
   void UpdateLocalFile(const std::string& app_id,
                        const base::FilePath::StringType& path,
                        const std::string& content) {
     ASSERT_TRUE(ContainsKey(file_systems_, app_id));
     int64 bytes_written = file_systems_[app_id]->WriteString(
         CreateURL(app_id, path), content);
     EXPECT_EQ(static_cast<int64>(content.size()), bytes_written);
     base::RunLoop().RunUntilIdle();
   }
 
   void RemoveLocal(const std::string& app_id,
                    const base::FilePath::StringType& path) {
     ASSERT_TRUE(ContainsKey(file_systems_, app_id));
-    EXPECT_EQ(base::PLATFORM_FILE_OK,
+    EXPECT_EQ(base::File::FILE_OK,
               file_systems_[app_id]->Remove(
                   CreateURL(app_id, path),
                   true /* recursive */));
     base::RunLoop().RunUntilIdle();
   }
 
   SyncStatusCode ProcessLocalChange() {
     SyncStatusCode status = SYNC_STATUS_UNKNOWN;
     fileapi::FileSystemURL url;
     local_sync_service_->ProcessLocalChange(
@@ skipping 98 matching lines @@
              remote_entries.begin();
          itr != remote_entries.end();
          ++itr) {
       const google_apis::ResourceEntry& remote_entry = **itr;
       EXPECT_FALSE(ContainsKey(remote_entry_by_title, remote_entry.title()));
       remote_entry_by_title[remote_entry.title()] = *itr;
     }
 
     fileapi::FileSystemURL url(CreateURL(app_id, path));
     CannedSyncableFileSystem::FileEntryList local_entries;
-    EXPECT_EQ(base::PLATFORM_FILE_OK,
+    EXPECT_EQ(base::File::FILE_OK,
               file_system->ReadDirectory(url, &local_entries));
     for (CannedSyncableFileSystem::FileEntryList::iterator itr =
              local_entries.begin();
          itr != local_entries.end();
          ++itr) {
       const fileapi::DirectoryEntry& local_entry = *itr;
       fileapi::FileSystemURL entry_url(
           CreateURL(app_id, path.Append(local_entry.name)));
       std::string title = entry_url.path().AsUTF8Unsafe();
       ASSERT_TRUE(ContainsKey(remote_entry_by_title, title));
@@ skipping 17 matching lines @@
   }
 
   void VerifyConsistencyForFile(const std::string& app_id,
                                 const base::FilePath& path,
                                 const std::string& file_id,
                                 CannedSyncableFileSystem* file_system) {
     fileapi::FileSystemURL url(CreateURL(app_id, path));
     std::string file_content;
     EXPECT_EQ(google_apis::HTTP_SUCCESS,
               fake_drive_service_helper_->ReadFile(file_id, &file_content));
-    EXPECT_EQ(base::PLATFORM_FILE_OK,
+    EXPECT_EQ(base::File::FILE_OK,
               file_system->VerifyFile(url, file_content));
   }
 
   drive::FakeDriveService* fake_drive_service() {
     return static_cast<drive::FakeDriveService*>(
         remote_sync_service_->GetDriveService());
   }
 
   drive::DriveUploaderInterface* drive_uploader() {
     return remote_sync_service_->GetDriveUploader();
@@ skipping 166 matching lines @@
   EXPECT_EQ(google_apis::HTTP_SUCCESS,
             fake_drive_service_helper()->RenameResource(
                 file_id, base::FilePath(path).AsUTF8Unsafe()));
 
   EXPECT_EQ(SYNC_STATUS_OK, ProcessChangesUntilDone());
   VerifyConsistency();
 }
 
 }  // namespace drive_backend
 }  // namespace sync_file_system