Convert Media Galleries to use base::File

chrome/browser/storage_monitor/image_capture_device_manager_unittest.mm

 // 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.
 
 #import <Foundation/Foundation.h>
 #import <ImageCaptureCore/ImageCaptureCore.h>
 
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
@@ skipping 196 matching lines @@
 
 @end
 
 class TestCameraListener
     : public ImageCaptureDeviceListener,
       public base::SupportsWeakPtr<TestCameraListener> {
  public:
   TestCameraListener()
       : completed_(false),
         removed_(false),
-        last_error_(base::PLATFORM_FILE_ERROR_INVALID_URL) {}
+        last_error_(base::File::FILE_ERROR_INVALID_URL) {}
   virtual ~TestCameraListener() {}
 
   virtual void ItemAdded(const std::string& name,
-                         const base::PlatformFileInfo& info) OVERRIDE {
+                         const base::File::Info& info) OVERRIDE {
     items_.push_back(name);
   }
 
   virtual void NoMoreItems() OVERRIDE {
     completed_ = true;
   }
 
   virtual void DownloadedFile(const std::string& name,
-                              base::PlatformFileError error) OVERRIDE {
+                              base::File::Error error) OVERRIDE {
     EXPECT_TRUE(content::BrowserThread::CurrentlyOn(
         content::BrowserThread::UI));
     downloads_.push_back(name);
     last_error_ = error;
   }
 
   virtual void DeviceRemoved() OVERRIDE {
     removed_ = true;
   }
 
   std::vector<std::string> items() const { return items_; }
   std::vector<std::string> downloads() const { return downloads_; }
   bool completed() const { return completed_; }
   bool removed() const { return removed_; }
-  base::PlatformFileError last_error() const { return last_error_; }
+  base::File::Error last_error() const { return last_error_; }
 
  private:
   std::vector<std::string> items_;
   std::vector<std::string> downloads_;
   bool completed_;
   bool removed_;
-  base::PlatformFileError last_error_;
+  base::File::Error last_error_;
 };
 
 class ImageCaptureDeviceManagerTest : public testing::Test {
  public:
   virtual void SetUp() OVERRIDE {
     monitor_ = TestStorageMonitor::CreateAndInstall();
   }
 
   virtual void TearDown() OVERRIDE {
     TestStorageMonitor::RemoveSingleton();
@@ skipping 107 matching lines @@
 
   EXPECT_EQ(0U, listener_.downloads().size());
 
   // Test that a nonexistent file we ask to be downloaded will
   // return us a not-found error.
   base::FilePath temp_file = temp_dir.path().Append("tempfile");
   [camera downloadFile:std::string("nonexistent") localPath:temp_file];
   base::RunLoop().RunUntilIdle();
   ASSERT_EQ(1U, listener_.downloads().size());
   EXPECT_EQ("nonexistent", listener_.downloads()[0]);
-  EXPECT_EQ(base::PLATFORM_FILE_ERROR_NOT_FOUND, listener_.last_error());
+  EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, listener_.last_error());
 
   // Test that an existing file we ask to be downloaded will end up in
   // the location we specify. The mock system will copy testing file
   // contents to a separate filename, mimicking the ImageCaptureCore
   // library behavior. Our code then renames the file onto the requested
   // destination.
   [camera downloadFile:kTestFileName localPath:temp_file];
   base::RunLoop().RunUntilIdle();
 
   ASSERT_EQ(2U, listener_.downloads().size());
   EXPECT_EQ(kTestFileName, listener_.downloads()[1]);
-  ASSERT_EQ(base::PLATFORM_FILE_OK, listener_.last_error());
+  ASSERT_EQ(base::File::FILE_OK, listener_.last_error());
   char file_contents[5];
   ASSERT_EQ(4, base::ReadFile(temp_file, file_contents,
                               strlen(kTestFileContents)));
   EXPECT_EQ(kTestFileContents,
             std::string(file_contents, strlen(kTestFileContents)));
 
   [camera didRemoveDevice:device];
 }
 
 TEST_F(ImageCaptureDeviceManagerTest, TestSubdirectories) {
@@ skipping 22 matching lines @@
   base::RunLoop().RunUntilIdle();
 
   char file_contents[5];
   ASSERT_EQ(4, base::ReadFile(temp_file, file_contents,
                               strlen(kTestFileContents)));
   EXPECT_EQ(kTestFileContents,
             std::string(file_contents, strlen(kTestFileContents)));
 
   [camera didRemoveDevice:device];
 }