net/disk_cache/simple/simple_entry_impl.h

   1 // Copyright (c) 2013 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 NET_DISK_CACHE_SIMPLE_SIMPLE_ENTRY_IMPL_H_
   6 #define NET_DISK_CACHE_SIMPLE_SIMPLE_ENTRY_IMPL_H_
   7
   8 #include <queue>
   9 #include <string>
  10
  11 #include "base/files/file_path.h"
  12 #include "base/memory/ref_counted.h"
  13 #include "base/memory/scoped_ptr.h"
  14 #include "base/memory/weak_ptr.h"
  15 #include "base/threading/thread_checker.h"
  16 #include "net/base/net_log.h"
  17 #include "net/disk_cache/disk_cache.h"
  18 #include "net/disk_cache/simple/simple_entry_format.h"
  19 #include "net/disk_cache/simple/simple_entry_operation.h"
  20
  21 namespace base {
  22 class TaskRunner;
  23 }
  24
  25 namespace net {
  26 class IOBuffer;
  27 }
  28
  29 namespace disk_cache {
  30
  31 class SimpleBackendImpl;
  32 class SimpleSynchronousEntry;
  33 struct SimpleEntryStat;
  34 struct SimpleEntryCreationResults;
  35
  36 // SimpleEntryImpl is the IO thread interface to an entry in the very simple
  37 // disk cache. It proxies for the SimpleSynchronousEntry, which performs IO
  38 // on the worker thread.
  39 class SimpleEntryImpl : public Entry, public base::RefCounted<SimpleEntryImpl>,
  40     public base::SupportsWeakPtr<SimpleEntryImpl> {
  41   friend class base::RefCounted<SimpleEntryImpl>;
  42  public:
  43   enum OperationsMode {
  44     NON_OPTIMISTIC_OPERATIONS,
  45     OPTIMISTIC_OPERATIONS,
  46   };
  47
  48   SimpleEntryImpl(const base::FilePath& path,
  49                   uint64 entry_hash,
  50                   OperationsMode operations_mode,
  51                   SimpleBackendImpl* backend,
  52                   net::NetLog* net_log);
  53
  54   // Adds another reader/writer to this entry, if possible, returning |this| to
  55   // |entry|.
  56   int OpenEntry(Entry** entry, const CompletionCallback& callback);
  57
  58   // Creates this entry, if possible. Returns |this| to |entry|.
  59   int CreateEntry(Entry** entry, const CompletionCallback& callback);
  60
  61   // Identical to Backend::Doom() except that it accepts a CompletionCallback.
  62   int DoomEntry(const CompletionCallback& callback);
  63
  64   const std::string& key() const { return key_; }
  65   uint64 entry_hash() const { return entry_hash_; }
  66   void SetKey(const std::string& key);
  67
  68   // From Entry:
  69   virtual void Doom() OVERRIDE;
  70   virtual void Close() OVERRIDE;
  71   virtual std::string GetKey() const OVERRIDE;
  72   virtual base::Time GetLastUsed() const OVERRIDE;
  73   virtual base::Time GetLastModified() const OVERRIDE;
  74   virtual int32 GetDataSize(int index) const OVERRIDE;
  75   virtual int ReadData(int stream_index,
  76                        int offset,
  77                        net::IOBuffer* buf,
  78                        int buf_len,
  79                        const CompletionCallback& callback) OVERRIDE;
  80   virtual int WriteData(int stream_index,
  81                         int offset,
  82                         net::IOBuffer* buf,
  83                         int buf_len,
  84                         const CompletionCallback& callback,
  85                         bool truncate) OVERRIDE;
  86   virtual int ReadSparseData(int64 offset,
  87                              net::IOBuffer* buf,
  88                              int buf_len,
  89                              const CompletionCallback& callback) OVERRIDE;
  90   virtual int WriteSparseData(int64 offset,
  91                               net::IOBuffer* buf,
  92                               int buf_len,
  93                               const CompletionCallback& callback) OVERRIDE;
  94   virtual int GetAvailableRange(int64 offset,
  95                                 int len,
  96                                 int64* start,
  97                                 const CompletionCallback& callback) OVERRIDE;
  98   virtual bool CouldBeSparse() const OVERRIDE;
  99   virtual void CancelSparseIO() OVERRIDE;
 100   virtual int ReadyForSparseIO(const CompletionCallback& callback) OVERRIDE;
 101
 102  private:
 103   class ScopedOperationRunner;
 104   friend class ScopedOperationRunner;
 105
 106   enum State {
 107     // The state immediately after construction, but before |synchronous_entry_|
 108     // has been assigned. This is the state at construction, and is the only
 109     // legal state to destruct an entry in.
 110     STATE_UNINITIALIZED,
 111
 112     // This entry is available for regular IO.
 113     STATE_READY,
 114
 115     // IO is currently in flight, operations must wait for completion before
 116     // launching.
 117     STATE_IO_PENDING,
 118
 119     // A failure occurred in the current or previous operation. All operations
 120     // after that must fail, until we receive a Close().
 121     STATE_FAILURE,
 122   };
 123
 124   // Used in histograms, please only add entries at the end.
 125   enum CheckCrcResult {
 126     CRC_CHECK_NEVER_READ_TO_END = 0,
 127     CRC_CHECK_NOT_DONE = 1,
 128     CRC_CHECK_DONE = 2,
 129     CRC_CHECK_NEVER_READ_AT_ALL = 3,
 130     CRC_CHECK_MAX = 4,
 131   };
 132
 133   virtual ~SimpleEntryImpl();
 134
 135   // Sets entry to STATE_UNINITIALIZED.
 136   void MakeUninitialized();
 137
 138   // Return this entry to a user of the API in |out_entry|. Increments the user
 139   // count.
 140   void ReturnEntryToCaller(Entry** out_entry);
 141
 142   // Ensures that |this| is no longer referenced by our |backend_|, this
 143   // guarantees that this entry cannot have OpenEntry/CreateEntry called again.
 144   void RemoveSelfFromBackend();
 145
 146   // An error occured, and the SimpleSynchronousEntry should have Doomed
 147   // us at this point. We need to remove |this| from the Backend and the
 148   // index.
 149   void MarkAsDoomed();
 150
 151   // Runs the next operation in the queue, if any and if there is no other
 152   // operation running at the moment.
 153   // WARNING: May delete |this|, as an operation in the queue can contain
 154   // the last reference.
 155   void RunNextOperationIfNeeded();
 156
 157   void OpenEntryInternal(bool have_index,
 158                          const CompletionCallback& callback,
 159                          Entry** out_entry);
 160
 161   void CreateEntryInternal(bool have_index,
 162                            const CompletionCallback& callback,
 163                            Entry** out_entry);
 164
 165   void CloseInternal();
 166
 167   void ReadDataInternal(int index,
 168                         int offset,
 169                         net::IOBuffer* buf,
 170                         int buf_len,
 171                         const CompletionCallback& callback);
 172
 173   void WriteDataInternal(int index,
 174                          int offset,
 175                          net::IOBuffer* buf,
 176                          int buf_len,
 177                          const CompletionCallback& callback,
 178                          bool truncate);
 179
 180   // Called after a SimpleSynchronousEntry has completed CreateEntry() or
 181   // OpenEntry(). If |in_sync_entry| is non-NULL, creation is successful and we
 182   // can return |this| SimpleEntryImpl to |*out_entry|. Runs
 183   // |completion_callback|.
 184   void CreationOperationComplete(
 185       const CompletionCallback& completion_callback,
 186       const base::TimeTicks& start_time,
 187       scoped_ptr<SimpleEntryCreationResults> in_results,
 188       Entry** out_entry,
 189       net::NetLog::EventType end_event_type);
 190
 191   // Called after we've closed and written the EOF record to our entry. Until
 192   // this point it hasn't been safe to OpenEntry() the same entry, but from this
 193   // point it is.
 194   void CloseOperationComplete();
 195
 196   // Internal utility method used by other completion methods. Calls
 197   // |completion_callback| after updating state and dooming on errors.
 198   void EntryOperationComplete(int stream_index,
 199                               const CompletionCallback& completion_callback,
 200                               const SimpleEntryStat& entry_stat,
 201                               scoped_ptr<int> result);
 202
 203   // Called after an asynchronous read. Updates |crc32s_| if possible.
 204   void ReadOperationComplete(int stream_index,
 205                              int offset,
 206                              const CompletionCallback& completion_callback,
 207                              scoped_ptr<uint32> read_crc32,
 208                              scoped_ptr<base::Time> last_used,
 209                              scoped_ptr<int> result);
 210
 211   // Called after an asynchronous write completes.
 212   void WriteOperationComplete(int stream_index,
 213                               const CompletionCallback& completion_callback,
 214                               scoped_ptr<SimpleEntryStat> entry_stat,
 215                               scoped_ptr<int> result);
 216
 217   // Called after validating the checksums on an entry. Passes through the
 218   // original result if successful, propogates the error if the checksum does
 219   // not validate.
 220   void ChecksumOperationComplete(
 221       int stream_index,
 222       int orig_result,
 223       const CompletionCallback& completion_callback,
 224       scoped_ptr<int> result);
 225
 226   // Called after completion of asynchronous IO and receiving file metadata for
 227   // the entry in |entry_stat|. Updates the metadata in the entry and in the
 228   // index to make them available on next IO operations.
 229   void UpdateDataFromEntryStat(const SimpleEntryStat& entry_stat);
 230
 231   int64 GetDiskUsage() const;
 232
 233   // Used to report histograms.
 234   void RecordReadIsParallelizable(const SimpleEntryOperation& operation) const;
 235   void RecordWriteDependencyType(const SimpleEntryOperation& operation) const;
 236
 237   // All nonstatic SimpleEntryImpl methods should always be called on the IO
 238   // thread, in all cases. |io_thread_checker_| documents and enforces this.
 239   base::ThreadChecker io_thread_checker_;
 240
 241   base::WeakPtr<SimpleBackendImpl> backend_;
 242   const scoped_refptr<base::TaskRunner> worker_pool_;
 243   const base::FilePath path_;
 244   const uint64 entry_hash_;
 245   const bool use_optimistic_operations_;
 246   std::string key_;
 247
 248   // |last_used_|, |last_modified_| and |data_size_| are copied from the
 249   // synchronous entry at the completion of each item of asynchronous IO.
 250   // TODO(clamy): Unify last_used_ with data in the index.
 251   base::Time last_used_;
 252   base::Time last_modified_;
 253   int32 data_size_[kSimpleEntryFileCount];
 254
 255   // Number of times this object has been returned from Backend::OpenEntry() and
 256   // Backend::CreateEntry() without subsequent Entry::Close() calls. Used to
 257   // notify the backend when this entry not used by any callers.
 258   int open_count_;
 259
 260   State state_;
 261
 262   // When possible, we compute a crc32, for the data in each entry as we read or
 263   // write. For each stream, |crc32s_[index]| is the crc32 of that stream from
 264   // [0 .. |crc32s_end_offset_|). If |crc32s_end_offset_[index] == 0| then the
 265   // value of |crc32s_[index]| is undefined.
 266   int32 crc32s_end_offset_[kSimpleEntryFileCount];
 267   uint32 crc32s_[kSimpleEntryFileCount];
 268
 269   // If |have_written_[index]| is true, we have written to the stream |index|.
 270   bool have_written_[kSimpleEntryFileCount];
 271
 272   // Reflects how much CRC checking has been done with the entry. This state is
 273   // reported on closing each entry stream.
 274   CheckCrcResult crc_check_state_[kSimpleEntryFileCount];
 275
 276   // The |synchronous_entry_| is the worker thread object that performs IO on
 277   // entries. It's owned by this SimpleEntryImpl whenever |operation_running_|
 278   // is false (i.e. when an operation is not pending on the worker pool).
 279   SimpleSynchronousEntry* synchronous_entry_;
 280
 281   std::queue<SimpleEntryOperation> pending_operations_;
 282
 283   net::BoundNetLog net_log_;
 284
 285   scoped_ptr<SimpleEntryOperation> executing_operation_;
 286 };
 287
 288 }  // namespace disk_cache
 289
 290 #endif  // NET_DISK_CACHE_SIMPLE_SIMPLE_ENTRY_IMPL_H_