base/files/file_proxy.h

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef BASE_FILES_FILE_PROXY_H_
   6 #define BASE_FILES_FILE_PROXY_H_
   7
   8 #include "base/base_export.h"
   9 #include "base/callback_forward.h"
  10 #include "base/files/file.h"
  11 #include "base/files/file_path.h"
  12 #include "base/memory/ref_counted.h"
  13 #include "base/memory/weak_ptr.h"
  14
  15 namespace tracked_objects {
  16 class Location;
  17 };
  18
  19 namespace base {
  20
  21 class TaskRunner;
  22 class Time;
  23
  24 // This class provides asynchronous access to a File. All methods follow the
  25 // same rules of the equivalent File method, as they are implemented by bouncing
  26 // the operation to File using a TaskRunner.
  27 //
  28 // This class performs automatic proxying to close the underlying file at
  29 // destruction.
  30 //
  31 // The TaskRunner is in charge of any sequencing of the operations, but a single
  32 // operation can be proxied at a time, regardless of the use of a callback.
  33 // In other words, having a sequence like
  34 //
  35 //   proxy.Write(...);
  36 //   proxy.Write(...);
  37 //
  38 // means the second Write will always fail.
  39 class BASE_EXPORT FileProxy : public SupportsWeakPtr<FileProxy> {
  40  public:
  41   // This callback is used by methods that report only an error code. It is
  42   // valid to pass a null callback to some functions that takes a
  43   // StatusCallback, in which case the operation will complete silently.
  44   typedef Callback<void(File::Error)> StatusCallback;
  45
  46   typedef Callback<void(File::Error,
  47                         const FilePath&)> CreateTemporaryCallback;
  48   typedef Callback<void(File::Error,
  49                         const File::Info&)> GetFileInfoCallback;
  50   typedef Callback<void(File::Error,
  51                         const char* data,
  52                         int bytes_read)> ReadCallback;
  53   typedef Callback<void(File::Error,
  54                         int bytes_written)> WriteCallback;
  55
  56   FileProxy();
  57   explicit FileProxy(TaskRunner* task_runner);
  58   ~FileProxy();
  59
  60   // Creates or opens a file with the given flags. It is invalid to pass a null
  61   // callback. If File::FLAG_CREATE is set in |file_flags| it always tries to
  62   // create a new file at the given |file_path| and fails if the file already
  63   // exists.
  64   //
  65   // This returns false if task posting to |task_runner| has failed.
  66   bool CreateOrOpen(const FilePath& file_path,
  67                     uint32 file_flags,
  68                     const StatusCallback& callback);
  69
  70   // Creates a temporary file for writing. The path and an open file are
  71   // returned. It is invalid to pass a null callback. The additional file flags
  72   // will be added on top of the default file flags which are:
  73   //   File::FLAG_CREATE_ALWAYS
  74   //   File::FLAG_WRITE
  75   //   File::FLAG_TEMPORARY.
  76   //
  77   // This returns false if task posting to |task_runner| has failed.
  78   bool CreateTemporary(uint32 additional_file_flags,
  79                        const CreateTemporaryCallback& callback);
  80
  81   // Returns true if the underlying |file_| is valid.
  82   bool IsValid() const;
  83
  84   // Returns true if a new file was created (or an old one truncated to zero
  85   // length to simulate a new file), and false otherwise.
  86   bool created() const { return file_.created(); }
  87
  88   // Claims ownership of |file|. It is an error to call this method when
  89   // IsValid() returns true.
  90   void SetFile(File file);
  91
  92   File TakeFile();
  93
  94   PlatformFile GetPlatformFile() const;
  95
  96   // Proxies File::Close. The callback can be null.
  97   // This returns false if task posting to |task_runner| has failed.
  98   bool Close(const StatusCallback& callback);
  99
 100   // Proxies File::GetInfo. The callback can't be null.
 101   // This returns false if task posting to |task_runner| has failed.
 102   bool GetInfo(const GetFileInfoCallback& callback);
 103
 104   // Proxies File::Read. The callback can't be null.
 105   // This returns false if |bytes_to_read| is less than zero, or
 106   // if task posting to |task_runner| has failed.
 107   bool Read(int64 offset, int bytes_to_read, const ReadCallback& callback);
 108
 109   // Proxies File::Write. The callback can be null.
 110   // This returns false if |bytes_to_write| is less than or equal to zero,
 111   // if |buffer| is NULL, or if task posting to |task_runner| has failed.
 112   bool Write(int64 offset,
 113              const char* buffer,
 114              int bytes_to_write,
 115              const WriteCallback& callback);
 116
 117   // Proxies File::SetTimes. The callback can be null.
 118   // This returns false if task posting to |task_runner| has failed.
 119   bool SetTimes(Time last_access_time,
 120                 Time last_modified_time,
 121                 const StatusCallback& callback);
 122
 123   // Proxies File::SetLength. The callback can be null.
 124   // This returns false if task posting to |task_runner| has failed.
 125   bool SetLength(int64 length, const StatusCallback& callback);
 126
 127   // Proxies File::Flush. The callback can be null.
 128   // This returns false if task posting to |task_runner| has failed.
 129   bool Flush(const StatusCallback& callback);
 130
 131  private:
 132   friend class FileHelper;
 133   TaskRunner* task_runner() { return task_runner_.get(); }
 134
 135   scoped_refptr<TaskRunner> task_runner_;
 136   File file_;
 137   DISALLOW_COPY_AND_ASSIGN(FileProxy);
 138 };
 139
 140 }  // namespace base
 141
 142 #endif  // BASE_FILES_FILE_PROXY_H_