Convert most of base and net to use base::File

net/disk_cache/simple/simple_version_upgrade.cc

 // Copyright 2013 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 "net/disk_cache/simple/simple_version_upgrade.h"
 
 #include <cstring>
 
 #include "base/file_util.h"
+#include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/memory_mapped_file.h"
 #include "base/logging.h"
 #include "base/pickle.h"
-#include "base/platform_file.h"
 #include "net/disk_cache/simple/simple_backend_version.h"
 #include "net/disk_cache/simple/simple_entry_format_history.h"
 #include "third_party/zlib/zlib.h"
 
 namespace {
 
 // It is not possible to upgrade cache structures on disk that are of version
 // below this, the entire cache should be dropped for them.
 const uint32 kMinVersionAbleToUpgrade = 5;
 
 const char kFakeIndexFileName[] = "index";
 const char kIndexFileName[] = "the-real-index";
 
 void LogMessageFailedUpgradeFromVersion(int version) {
   LOG(ERROR) << "Failed to upgrade Simple Cache from version: " << version;
 }
 
 bool WriteFakeIndexFile(const base::FilePath& file_name) {
-  base::PlatformFileError error;
-  base::PlatformFile file = base::CreatePlatformFile(
-      file_name,
-      base::PLATFORM_FILE_CREATE | base::PLATFORM_FILE_WRITE,
-      NULL,
-      &error);
+  base::File file(file_name,  base::File::FLAG_CREATE | base::File::FLAG_WRITE);
+  if (!file.IsValid())
+    return false;
+
   disk_cache::FakeIndexData file_contents;
   file_contents.initial_magic_number =
       disk_cache::simplecache_v5::kSimpleInitialMagicNumber;
   file_contents.version = disk_cache::kSimpleVersion;
-  int bytes_written = base::WritePlatformFile(
-      file, 0, reinterpret_cast<char*>(&file_contents), sizeof(file_contents));
-  if (!base::ClosePlatformFile(file) ||
-      bytes_written != sizeof(file_contents)) {
+  int bytes_written = file.Write(0, reinterpret_cast<char*>(&file_contents),
+                                 sizeof(file_contents));
+  if (bytes_written != sizeof(file_contents)) {
     LOG(ERROR) << "Failed to write fake index file: "
                << file_name.LossyDisplayName();
     return false;
   }
   return true;
 }
 
 }  // namespace
 
 namespace disk_cache {
@@ skipping 72 matching lines @@
   // There is a convention among disk cache backends: looking at the magic in
   // the file "index" it should be sufficient to determine if the cache belongs
   // to the currently running backend. The Simple Backend stores its index in
   // the file "the-real-index" (see simple_index_file.cc) and the file "index"
   // only signifies presence of the implementation's magic and version. There
   // are two reasons for that:
   // 1. Absence of the index is itself not a fatal error in the Simple Backend
   // 2. The Simple Backend has pickled file format for the index making it hacky
   //    to have the magic in the right place.
   const base::FilePath fake_index = path.AppendASCII(kFakeIndexFileName);
-  base::PlatformFileError error;
-  base::PlatformFile fake_index_file = base::CreatePlatformFile(
-      fake_index,
-      base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_READ,
-      NULL,
-      &error);
-  if (error == base::PLATFORM_FILE_ERROR_NOT_FOUND) {
-    return WriteFakeIndexFile(fake_index);
-  } else if (error != base::PLATFORM_FILE_OK) {
+  base::File fake_index_file(fake_index,
+                             base::File::FLAG_OPEN | base::File::FLAG_READ);
+
+  if (!fake_index_file.IsValid()) {
+    if (fake_index_file.error() == base::File::FILE_ERROR_NOT_FOUND) {
+      return WriteFakeIndexFile(fake_index);
+    }
     return false;
   }
+
   FakeIndexData file_header;
-  int bytes_read = base::ReadPlatformFile(fake_index_file,
-                                          0,
-                                          reinterpret_cast<char*>(&file_header),
-                                          sizeof(file_header));
-  if (!base::ClosePlatformFile(fake_index_file) ||
-      bytes_read != sizeof(file_header) ||
+  int bytes_read = fake_index_file.Read(0,
+                                        reinterpret_cast<char*>(&file_header),
+                                        sizeof(file_header));
+  if (bytes_read != sizeof(file_header) ||
       file_header.initial_magic_number !=
           disk_cache::simplecache_v5::kSimpleInitialMagicNumber) {
     LOG(ERROR) << "File structure does not match the disk cache backend.";
     return false;
   }
+  fake_index_file.Close();
 
   uint32 version_from = file_header.version;
   if (version_from < kMinVersionAbleToUpgrade ||
       version_from > kSimpleVersion) {
     LOG(ERROR) << "Inconsistent cache version.";
     return false;
   }
   bool upgrade_needed = (version_from != kSimpleVersion);
   if (version_from == kMinVersionAbleToUpgrade) {
     // Upgrade only the index for V4 -> V5 move.
@@ skipping 23 matching lines @@
     }
   }
   // Verify during the test stage that the upgraders are implemented for all
   // versions. The release build would cause backend initialization failure
   // which would then later lead to removing all files known to the backend.
   DCHECK_EQ(kSimpleVersion, version_from);
   return false;
 }
 
 }  // namespace disk_cache