Convert Media Galleries to use base::File

chrome/browser/browsing_data/browsing_data_file_system_helper_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 "testing/gtest/include/gtest/gtest.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 78 matching lines @@
   // Unblocks the current MessageLoop. Should be called in response to some sort
   // of async activity in a callback method.
   void Notify() {
     base::MessageLoop::current()->Quit();
   }
 
   // Callback that should be executed in response to
   // fileapi::FileSystemContext::OpenFileSystem.
   void OpenFileSystemCallback(const GURL& root,
                               const std::string& name,
-                              base::PlatformFileError error) {
+                              base::File::Error error) {
     open_file_system_result_ = error;
     Notify();
   }
 
   bool OpenFileSystem(const GURL& origin,
                       fileapi::FileSystemType type,
                       fileapi::OpenFileSystemMode open_mode) {
     BrowserContext::GetDefaultStoragePartition(profile_.get())->
         GetFileSystemContext()->OpenFileSystem(
             origin, type, open_mode,
             base::Bind(
                 &BrowsingDataFileSystemHelperTest::OpenFileSystemCallback,
                 base::Unretained(this)));
     BlockUntilNotified();
-    return open_file_system_result_ == base::PLATFORM_FILE_OK;
+    return open_file_system_result_ == base::File::FILE_OK;
   }
 
   // Calls fileapi::FileSystemContext::OpenFileSystem with
   // OPEN_FILE_SYSTEM_FAIL_IF_NONEXISTENT flag
   // to verify the existence of a file system for a specified type and origin,
   // blocks until a response is available, then returns the result
   // synchronously to it's caller.
   bool FileSystemContainsOriginAndType(const GURL& origin,
                                        fileapi::FileSystemType type) {
     return OpenFileSystem(origin, type,
@@ skipping 44 matching lines @@
     EXPECT_TRUE(FileSystemContainsOriginAndType(kOrigin3, kPersistent));
     EXPECT_TRUE(FileSystemContainsOriginAndType(kOrigin3, kTemporary));
   }
 
   // Calls OpenFileSystem with OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT
   // to create a filesystem of a given type for a specified origin.
   void CreateDirectoryForOriginAndType(const GURL& origin,
                                        fileapi::FileSystemType type) {
     OpenFileSystem(origin, type,
                    fileapi::OPEN_FILE_SYSTEM_CREATE_IF_NONEXISTENT);
-    EXPECT_EQ(base::PLATFORM_FILE_OK, open_file_system_result_);
+    EXPECT_EQ(base::File::FILE_OK, open_file_system_result_);
   }
 
   // Returns a list of the FileSystemInfo objects gathered in the most recent
   // call to StartFetching().
   FileSystemInfoList* GetFileSystems() {
     return file_system_info_list_.get();
   }
 
  protected:
   content::TestBrowserThreadBundle thread_bundle_;
   scoped_ptr<TestingProfile> profile_;
 
   // Temporary storage to pass information back from callbacks.
-  base::PlatformFileError open_file_system_result_;
+  base::File::Error open_file_system_result_;
   ScopedFileSystemInfoList file_system_info_list_;
 
   scoped_refptr<BrowsingDataFileSystemHelper> helper_;
   scoped_refptr<CannedBrowsingDataFileSystemHelper> canned_helper_;
 
   DISALLOW_COPY_AND_ASSIGN(BrowsingDataFileSystemHelperTest);
 };
 
 // Verifies that the BrowsingDataFileSystemHelper correctly finds the test file
 // system data, and that each file system returned contains the expected data.
@@ skipping 95 matching lines @@
 // extension and devtools schemes.
 TEST_F(BrowsingDataFileSystemHelperTest, IgnoreExtensionsAndDevTools) {
   ASSERT_TRUE(canned_helper_->empty());
   canned_helper_->AddFileSystem(kOriginExt, kTemporary, 0);
   ASSERT_TRUE(canned_helper_->empty());
   canned_helper_->AddFileSystem(kOriginDevTools, kTemporary, 0);
   ASSERT_TRUE(canned_helper_->empty());
 }
 
 }  // namespace