Remove some PlatformFile uses from zlib

third_party/zlib/google/zip_reader.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 "third_party/zlib/google/zip_reader.h"
 
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_util.h"
@@ skipping 257 matching lines @@
     return;
   }
 
   base::FilePath output_dir_path = output_file_path.DirName();
   if (!base::CreateDirectory(output_dir_path)) {
     DVLOG(1) << "Unzip failed: unable to create containing directory.";
     base::MessageLoopProxy::current()->PostTask(FROM_HERE, failure_callback);
     return;
   }
 
-  const int flags = (base::PLATFORM_FILE_CREATE_ALWAYS |
-                     base::PLATFORM_FILE_WRITE);
-  bool created = false;
-  base::PlatformFileError platform_file_error;
-  base::PlatformFile output_file = CreatePlatformFile(output_file_path,
-                                                      flags,
-                                                      &created,
-                                                      &platform_file_error);
+  const int flags = base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE;
+  base::File output_file(output_file_path, flags);
 
-  if (platform_file_error != base::PLATFORM_FILE_OK) {
+  if (!output_file.IsValid()) {
     DVLOG(1) << "Unzip failed: unable to create platform file at "
              << output_file_path.value();
     base::MessageLoopProxy::current()->PostTask(FROM_HERE, failure_callback);
     return;
   }
 
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&ZipReader::ExtractChunk,
                  weak_ptr_factory_.GetWeakPtr(),
-                 output_file,
+                 Passed(output_file.Pass()),
                  success_callback,
                  failure_callback,
                  progress_callback,
                  0 /* initial offset */));
 }
 
 bool ZipReader::ExtractCurrentEntryIntoDirectory(
     const base::FilePath& output_directory_path) {
   DCHECK(current_entry_info_.get());
 
@@ skipping 58 matching lines @@
   return true;
 }
 
 void ZipReader::Reset() {
   zip_file_ = NULL;
   num_entries_ = 0;
   reached_end_ = false;
   current_entry_info_.reset();
 }
 
-void ZipReader::ExtractChunk(base::PlatformFile output_file,
+void ZipReader::ExtractChunk(base::File output_file,
                              const SuccessCallback& success_callback,
                              const FailureCallback& failure_callback,
                              const ProgressCallback& progress_callback,
                              const int64 offset) {
   char buffer[internal::kZipBufSize];
 
   const int num_bytes_read = unzReadCurrentFile(zip_file_,
                                                 buffer,
                                                 internal::kZipBufSize);
 
   if (num_bytes_read == 0) {
     unzCloseCurrentFile(zip_file_);
-    base::ClosePlatformFile(output_file);
     success_callback.Run();
   } else if (num_bytes_read < 0) {
     DVLOG(1) << "Unzip failed: error while reading zipfile "
              << "(" << num_bytes_read << ")";
-    base::ClosePlatformFile(output_file);
     failure_callback.Run();
   } else {
-    if (num_bytes_read != base::WritePlatformFile(output_file,
-                                                  offset,
-                                                  buffer,
-                                                  num_bytes_read)) {
+    if (num_bytes_read != output_file.Write(offset, buffer, num_bytes_read)) {
       DVLOG(1) << "Unzip failed: unable to write all bytes to target.";
-      base::ClosePlatformFile(output_file);
       failure_callback.Run();
       return;
     }
 
     int64 current_progress = offset + num_bytes_read;
 
     progress_callback.Run(current_progress);
 
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&ZipReader::ExtractChunk,
                    weak_ptr_factory_.GetWeakPtr(),
-                   output_file,
+                   Passed(output_file.Pass()),
                    success_callback,
                    failure_callback,
                    progress_callback,
                    current_progress));
 
   }
 }
 
 
 }  // namespace zip