Remove some PlatformFile uses from zlib

third_party/zlib/google/zip_reader_unittest.cc

 // Copyright (c) 2011 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 "third_party/zlib/google/zip_reader.h"
 
 #include <set>
 #include <string>
 
 #include "base/bind.h"
 #include "base/file_util.h"
+#include "base/files/file.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/md5.h"
 #include "base/path_service.h"
-#include "base/platform_file.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 #include "third_party/zlib/google/zip_internal.h"
 
 namespace {
 
 const static std::string kQuuxExpectedMD5 = "d1ae4ac8a17a0e09317113ab284b57a6";
 
-// Wrap PlatformFiles in a class so that we don't leak them in tests.
-class PlatformFileWrapper {
+class FileWrapper {
  public:
   typedef enum {
     READ_ONLY,
     READ_WRITE
   } AccessMode;
 
-  PlatformFileWrapper(const base::FilePath& file, AccessMode mode)
-      : file_(base::kInvalidPlatformFileValue) {
-    switch (mode) {
-      case READ_ONLY:
-        file_ = base::CreatePlatformFile(file,
-                                         base::PLATFORM_FILE_OPEN |
-                                         base::PLATFORM_FILE_READ,
-                                         NULL, NULL);
-        break;
-      case READ_WRITE:
-        file_ = base::CreatePlatformFile(file,
-                                         base::PLATFORM_FILE_CREATE_ALWAYS |
-                                         base::PLATFORM_FILE_READ |
-                                         base::PLATFORM_FILE_WRITE,
-                                         NULL, NULL);
-        break;
-      default:
-        NOTREACHED();
-    }
-    return;
+  FileWrapper(const base::FilePath& path, AccessMode mode) {
+    int flags = base::File::FLAG_READ;
+    if (mode == READ_ONLY)
+      flags |= base::File::FLAG_OPEN;
+    else
+      flags |= base::File::FLAG_WRITE | base::File::FLAG_CREATE_ALWAYS;
+
+    file_.Initialize(path, flags);
   }
 
-  ~PlatformFileWrapper() {
-    base::ClosePlatformFile(file_);
-  }
+  ~FileWrapper() {}
 
-  base::PlatformFile platform_file() { return file_; }
+  base::PlatformFile platform_file() { return file_.GetPlatformFile(); }
 
  private:
-  base::PlatformFile file_;
+  base::File file_;
 };
 
 // A mock that provides methods that can be used as callbacks in asynchronous
 // unzip functions.  Tracks the number of calls and number of bytes reported.
 // Assumes that progress callbacks will be executed in-order.
 class MockUnzipListener : public base::SupportsWeakPtr<MockUnzipListener> {
  public:
-  MockUnzipListener() 
+  MockUnzipListener()
       : success_calls_(0),
         failure_calls_(0),
         progress_calls_(0),
         current_progress_(0) {
   }
 
   // Success callback for async functions.
   void OnUnzipSuccess() {
     success_calls_++;
   }
@@ skipping 104 matching lines @@
   base::MessageLoop message_loop_;
 };
 
 TEST_F(ZipReaderTest, Open_ValidZipFile) {
   ZipReader reader;
   ASSERT_TRUE(reader.Open(test_zip_file_));
 }
 
 TEST_F(ZipReaderTest, Open_ValidZipPlatformFile) {
   ZipReader reader;
-  PlatformFileWrapper zip_fd_wrapper(test_zip_file_,
-                                     PlatformFileWrapper::READ_ONLY);
+  FileWrapper zip_fd_wrapper(test_zip_file_, FileWrapper::READ_ONLY);
   ASSERT_TRUE(reader.OpenFromPlatformFile(zip_fd_wrapper.platform_file()));
 }
 
 TEST_F(ZipReaderTest, Open_NonExistentFile) {
   ZipReader reader;
   ASSERT_FALSE(reader.Open(test_data_dir_.AppendASCII("nonexistent.zip")));
 }
 
 TEST_F(ZipReaderTest, Open_ExistentButNonZipFile) {
   ZipReader reader;
@@ skipping 16 matching lines @@
             static_cast<size_t>(reader.num_entries()));
   EXPECT_EQ(test_zip_contents_.size(), actual_contents.size());
   EXPECT_EQ(test_zip_contents_, actual_contents);
 }
 
 // Open the test zip file from a file descriptor, iterate through its contents,
 // and compare that they match the expected contents.
 TEST_F(ZipReaderTest, PlatformFileIteration) {
   std::set<base::FilePath> actual_contents;
   ZipReader reader;
-  PlatformFileWrapper zip_fd_wrapper(test_zip_file_,
-                                     PlatformFileWrapper::READ_ONLY);
+  FileWrapper zip_fd_wrapper(test_zip_file_, FileWrapper::READ_ONLY);
   ASSERT_TRUE(reader.OpenFromPlatformFile(zip_fd_wrapper.platform_file()));
   while (reader.HasMore()) {
     ASSERT_TRUE(reader.OpenCurrentEntryInZip());
     actual_contents.insert(reader.current_entry_info()->file_path());
     ASSERT_TRUE(reader.AdvanceToNextEntry());
   }
   EXPECT_FALSE(reader.AdvanceToNextEntry());  // Shouldn't go further.
   EXPECT_EQ(test_zip_contents_.size(),
             static_cast<size_t>(reader.num_entries()));
   EXPECT_EQ(test_zip_contents_.size(), actual_contents.size());
@@ skipping 31 matching lines @@
                                      &output));
   const std::string md5 = base::MD5String(output);
   EXPECT_EQ(kQuuxExpectedMD5, md5);
   // quux.txt should be larger than kZipBufSize so that we can exercise
   // the loop in ExtractCurrentEntry().
   EXPECT_LT(static_cast<size_t>(internal::kZipBufSize), output.size());
 }
 
 TEST_F(ZipReaderTest, PlatformFileExtractCurrentEntryToFilePath_RegularFile) {
   ZipReader reader;
-  PlatformFileWrapper zip_fd_wrapper(test_zip_file_,
-                                     PlatformFileWrapper::READ_ONLY);
+  FileWrapper zip_fd_wrapper(test_zip_file_, FileWrapper::READ_ONLY);
   ASSERT_TRUE(reader.OpenFromPlatformFile(zip_fd_wrapper.platform_file()));
   base::FilePath target_path(FILE_PATH_LITERAL("foo/bar/quux.txt"));
   ASSERT_TRUE(reader.LocateAndOpenEntry(target_path));
   ASSERT_TRUE(reader.ExtractCurrentEntryToFilePath(
       test_dir_.AppendASCII("quux.txt")));
   // Read the output file and compute the MD5.
   std::string output;
   ASSERT_TRUE(base::ReadFileToString(test_dir_.AppendASCII("quux.txt"),
                                      &output));
   const std::string md5 = base::MD5String(output);
   EXPECT_EQ(kQuuxExpectedMD5, md5);
   // quux.txt should be larger than kZipBufSize so that we can exercise
   // the loop in ExtractCurrentEntry().
   EXPECT_LT(static_cast<size_t>(internal::kZipBufSize), output.size());
 }
 
 #if defined(OS_POSIX)
 TEST_F(ZipReaderTest, PlatformFileExtractCurrentEntryToFd_RegularFile) {
   ZipReader reader;
-  PlatformFileWrapper zip_fd_wrapper(test_zip_file_,
-                                     PlatformFileWrapper::READ_ONLY);
+  FileWrapper zip_fd_wrapper(test_zip_file_, FileWrapper::READ_ONLY);
   ASSERT_TRUE(reader.OpenFromPlatformFile(zip_fd_wrapper.platform_file()));
   base::FilePath target_path(FILE_PATH_LITERAL("foo/bar/quux.txt"));
   base::FilePath out_path = test_dir_.AppendASCII("quux.txt");
-  PlatformFileWrapper out_fd_w(out_path, PlatformFileWrapper::READ_WRITE);
+  FileWrapper out_fd_w(out_path, FileWrapper::READ_WRITE);
   ASSERT_TRUE(reader.LocateAndOpenEntry(target_path));
   ASSERT_TRUE(reader.ExtractCurrentEntryToFd(out_fd_w.platform_file()));
   // Read the output file and compute the MD5.
   std::string output;
   ASSERT_TRUE(base::ReadFileToString(test_dir_.AppendASCII("quux.txt"),
                                      &output));
   const std::string md5 = base::MD5String(output);
   EXPECT_EQ(kQuuxExpectedMD5, md5);
   // quux.txt should be larger than kZipBufSize so that we can exercise
   // the loop in ExtractCurrentEntry().
@@ skipping 221 matching lines @@
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(1, listener.success_calls());
   EXPECT_EQ(0, listener.failure_calls());
   EXPECT_GE(0, listener.progress_calls());
 
   ASSERT_TRUE(base::DirectoryExists(target_file));
 }
 
 }  // namespace zip