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

net/disk_cache/simple/simple_synchronous_entry.h

 // Copyright (c) 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.
 
 #ifndef NET_DISK_CACHE_SIMPLE_SIMPLE_SYNCHRONOUS_ENTRY_H_
 #define NET_DISK_CACHE_SIMPLE_SIMPLE_SYNCHRONOUS_ENTRY_H_
 
 #include <algorithm>
 #include <map>
 #include <string>
 #include <utility>
 #include <vector>
 
+#include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
-#include "base/platform_file.h"
 #include "base/time/time.h"
 #include "net/base/cache_type.h"
 #include "net/base/net_export.h"
 #include "net/disk_cache/simple/simple_entry_format.h"
 
 namespace net {
 class GrowableIOBuffer;
 class IOBuffer;
 }
 
@@ skipping 178 matching lines @@
       uint64 entry_hash);
 
   // Like Entry, the SimpleSynchronousEntry self releases when Close() is
   // called.
   ~SimpleSynchronousEntry();
 
   // Tries to open one of the cache entry files. Succeeds if the open succeeds
   // or if the file was not found and is allowed to be omitted if the
   // corresponding stream is empty.
   bool MaybeOpenFile(int file_index,
-                     base::PlatformFileError* out_error);
+                     base::File::Error* out_error);
   // Creates one of the cache entry files if necessary. If the file is allowed
   // to be omitted if the corresponding stream is empty, and if |file_required|
   // is FILE_NOT_REQUIRED, then the file is not created; otherwise, it is.
   bool MaybeCreateFile(int file_index,
                        FileRequired file_required,
-                       base::PlatformFileError* out_error);
+                       base::File::Error* out_error);
   bool OpenFiles(bool had_index,
                  SimpleEntryStat* out_entry_stat);
   bool CreateFiles(bool had_index,
                    SimpleEntryStat* out_entry_stat);
   void CloseFile(int index);
   void CloseFiles();
 
   // Returns a net error, i.e. net::OK on success. |had_index| is passed
   // from the main entry for metrics purposes, and is true if the index was
   // initialized when the open operation began.
@@ skipping 28 matching lines @@
                        int* out_data_size) const;
   void Doom() const;
 
   // Opens the sparse data file and scans it if it exists.
   bool OpenSparseFileIfExists(int32* out_sparse_data_size);
 
   // Creates and initializes the sparse data file.
   bool CreateSparseFile();
 
   // Closes the sparse data file.
-  bool CloseSparseFile();
+  void CloseSparseFile();
 
   // Writes the header to the (newly-created) sparse file.
   bool InitializeSparseFile();
 
   // Removes all but the header of the sparse file.
   bool TruncateSparseFile();
 
   // Scans the existing ranges in the sparse file. Populates |sparse_ranges_|
   // and sets |*out_sparse_data_size| to the total size of all the ranges (not
   // including headers).
@@ skipping 16 matching lines @@
                                      uint64 entry_hash,
                                      int file_index);
   static bool DeleteFilesForEntryHash(const base::FilePath& path,
                                       uint64 entry_hash);
 
   void RecordSyncCreateResult(CreateEntryResult result, bool had_index);
 
   base::FilePath GetFilenameFromFileIndex(int file_index);
 
   bool sparse_file_open() const {
-    return sparse_file_ != base::kInvalidPlatformFileValue;
+    return sparse_file_.IsValid();
   }
 
   const net::CacheType cache_type_;
   const base::FilePath path_;
   const uint64 entry_hash_;
   std::string key_;
 
   bool have_open_files_;
   bool initialized_;
 
-  base::PlatformFile files_[kSimpleEntryFileCount];
+  base::File files_[kSimpleEntryFileCount];
 
   // True if the corresponding stream is empty and therefore no on-disk file
   // was created to store it.
   bool empty_file_omitted_[kSimpleEntryFileCount];
 
   typedef std::map<int64, SparseRange> SparseRangeOffsetMap;
   typedef SparseRangeOffsetMap::iterator SparseRangeIterator;
   SparseRangeOffsetMap sparse_ranges_;
-  base::PlatformFile sparse_file_;
+  base::File sparse_file_;
   // Offset of the end of the sparse file (where the next sparse range will be
   // written).
   int64 sparse_tail_offset_;
 
   // True if the entry was created, or false if it was opened. Used to log
   // SimpleCache.*.EntryCreatedWithStream2Omitted only for created entries.
   bool files_created_;
 };
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_SIMPLE_SIMPLE_SYNCHRONOUS_ENTRY_H_