Convert Media Galleries to use base::File

chrome/browser/sync_file_system/sync_file_system_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 <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/run_loop.h"
 #include "base/stl_util.h"
@@ skipping 51 matching lines @@
   DCHECK(status_out);
   DCHECK(value_out);
   DCHECK(run_loop);
   *status_out = status;
   *value_out = value;
   run_loop->Quit();
 }
 
 // This is called on IO thread.
 void VerifyFileError(base::RunLoop* run_loop,
-                     base::PlatformFileError error) {
+                     base::File::Error error) {
   DCHECK(run_loop);
-  EXPECT_EQ(base::PLATFORM_FILE_OK, error);
+  EXPECT_EQ(base::File::FILE_OK, error);
   run_loop->Quit();
 }
 
 }  // namespace
 
 class MockSyncEventObserver : public SyncEventObserver {
  public:
   MockSyncEventObserver() {}
   virtual ~MockSyncEventObserver() {}
 
@@ skipping 87 matching lines @@
         .Times(AnyNumber())
         .WillRepeatedly(Return(REMOTE_SERVICE_OK));
 
     sync_service_->InitializeForApp(
         file_system_->file_system_context(),
         GURL(kOrigin),
         AssignAndQuitCallback(&run_loop, &status));
     run_loop.Run();
 
     EXPECT_EQ(SYNC_STATUS_OK, status);
-    EXPECT_EQ(base::PLATFORM_FILE_OK, file_system_->OpenFileSystem());
+    EXPECT_EQ(base::File::FILE_OK, file_system_->OpenFileSystem());
   }
 
   // Calls InitializeForApp after setting up the mock remote service to
   // perform following when RegisterOrigin is called:
   //  1. Notify RemoteFileSyncService's observers of |state_to_notify|
   //  2. Run the given callback with |status_to_return|.
   //
   // ..and verifies if following conditions are met:
   //  1. The SyncEventObserver of the service is called with
   //     |expected_states| service state values.
@@ skipping 144 matching lines @@
   }
 
   // The local_change_processor's ApplyLocalChange should be called once
   // with ADD_OR_UPDATE change for TYPE_FILE.
   const FileChange change(FileChange::FILE_CHANGE_ADD_OR_UPDATE,
                           SYNC_FILE_TYPE_FILE);
   EXPECT_CALL(*mock_local_change_processor(),
               ApplyLocalChange(change, _, _, kFile, _))
       .WillOnce(MockStatusCallback(SYNC_STATUS_OK));
 
-  EXPECT_EQ(base::PLATFORM_FILE_OK, file_system_->CreateFile(kFile));
+  EXPECT_EQ(base::File::FILE_OK, file_system_->CreateFile(kFile));
 
   run_loop.Run();
 
   file_system_->RemoveSyncStatusObserver(&status_observer);
 }
 
 TEST_F(SyncFileSystemServiceTest, SimpleRemoteSyncFlow) {
   InitializeApp();
 
   EnableSync();
@@ skipping 107 matching lines @@
         base::Bind(&AssignValueAndQuit<SyncFileStatus>,
                    &run_loop, &status, &sync_file_status));
     run_loop.Run();
 
     EXPECT_EQ(SYNC_STATUS_OK, status);
     EXPECT_EQ(SYNC_FILE_STATUS_CONFLICTING, sync_file_status);
   }
 
   // 3. The file has pending local changes.
   {
-    EXPECT_EQ(base::PLATFORM_FILE_OK, file_system_->CreateFile(kFile));
+    EXPECT_EQ(base::File::FILE_OK, file_system_->CreateFile(kFile));
 
     base::RunLoop run_loop;
     EXPECT_CALL(*mock_remote_service(), IsConflicting(kFile))
         .WillOnce(Return(false));
 
     status = SYNC_STATUS_UNKNOWN;
     sync_file_status = SYNC_FILE_STATUS_UNKNOWN;
     sync_service_->GetFileSyncStatus(
         kFile,
         base::Bind(&AssignValueAndQuit<SyncFileStatus>,
                    &run_loop, &status, &sync_file_status));
     run_loop.Run();
 
     EXPECT_EQ(SYNC_STATUS_OK, status);
     EXPECT_EQ(SYNC_FILE_STATUS_HAS_PENDING_CHANGES, sync_file_status);
   }
 
   // 4. The file has a conflict and pending local changes. In this case
   // we return SYNC_FILE_STATUS_CONFLICTING.
   {
-    EXPECT_EQ(base::PLATFORM_FILE_OK, file_system_->TruncateFile(kFile, 1U));
+    EXPECT_EQ(base::File::FILE_OK, file_system_->TruncateFile(kFile, 1U));
 
     base::RunLoop run_loop;
     EXPECT_CALL(*mock_remote_service(), IsConflicting(kFile))
         .WillOnce(Return(true));
 
     status = SYNC_STATUS_UNKNOWN;
     sync_file_status = SYNC_FILE_STATUS_UNKNOWN;
     sync_service_->GetFileSyncStatus(
         kFile,
         base::Bind(&AssignValueAndQuit<SyncFileStatus>,
                    &run_loop, &status, &sync_file_status));
     run_loop.Run();
 
     EXPECT_EQ(SYNC_STATUS_OK, status);
     EXPECT_EQ(SYNC_FILE_STATUS_CONFLICTING, sync_file_status);
   }
 }
 
 }  // namespace sync_file_system