net/disk_cache/simple/simple_entry_operation.h

   1 // Copyright 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_OPERATION_H_
   6 #define NET_DISK_CACHE_SIMPLE_SIMPLE_ENTRY_OPERATION_H_
   7
   8 #include "base/memory/ref_counted.h"
   9 #include "net/base/completion_callback.h"
  10 #include "net/log/net_log.h"
  11
  12 namespace net {
  13 class IOBuffer;
  14 }
  15
  16 namespace disk_cache {
  17
  18 class Entry;
  19 class SimpleEntryImpl;
  20
  21 // SimpleEntryOperation stores the information regarding operations in
  22 // SimpleEntryImpl, between the moment they are issued by users of the backend,
  23 // and the moment when they are executed.
  24 class SimpleEntryOperation {
  25  public:
  26   typedef net::CompletionCallback CompletionCallback;
  27
  28   enum EntryOperationType {
  29     TYPE_OPEN = 0,
  30     TYPE_CREATE = 1,
  31     TYPE_CLOSE = 2,
  32     TYPE_READ = 3,
  33     TYPE_WRITE = 4,
  34     TYPE_READ_SPARSE = 5,
  35     TYPE_WRITE_SPARSE = 6,
  36     TYPE_GET_AVAILABLE_RANGE = 7,
  37     TYPE_DOOM = 8,
  38   };
  39
  40   SimpleEntryOperation(const SimpleEntryOperation& other);
  41   ~SimpleEntryOperation();
  42
  43   static SimpleEntryOperation OpenOperation(SimpleEntryImpl* entry,
  44                                             bool have_index,
  45                                             const CompletionCallback& callback,
  46                                             Entry** out_entry);
  47   static SimpleEntryOperation CreateOperation(
  48       SimpleEntryImpl* entry,
  49       bool have_index,
  50       const CompletionCallback& callback,
  51       Entry** out_entry);
  52   static SimpleEntryOperation CloseOperation(SimpleEntryImpl* entry);
  53   static SimpleEntryOperation ReadOperation(SimpleEntryImpl* entry,
  54                                             int index,
  55                                             int offset,
  56                                             int length,
  57                                             net::IOBuffer* buf,
  58                                             const CompletionCallback& callback,
  59                                             bool alone_in_queue);
  60   static SimpleEntryOperation WriteOperation(
  61       SimpleEntryImpl* entry,
  62       int index,
  63       int offset,
  64       int length,
  65       net::IOBuffer* buf,
  66       bool truncate,
  67       bool optimistic,
  68       const CompletionCallback& callback);
  69   static SimpleEntryOperation ReadSparseOperation(
  70       SimpleEntryImpl* entry,
  71       int64 sparse_offset,
  72       int length,
  73       net::IOBuffer* buf,
  74       const CompletionCallback& callback);
  75   static SimpleEntryOperation WriteSparseOperation(
  76       SimpleEntryImpl* entry,
  77       int64 sparse_offset,
  78       int length,
  79       net::IOBuffer* buf,
  80       const CompletionCallback& callback);
  81   static SimpleEntryOperation GetAvailableRangeOperation(
  82       SimpleEntryImpl* entry,
  83       int64 sparse_offset,
  84       int length,
  85       int64* out_start,
  86       const CompletionCallback& callback);
  87   static SimpleEntryOperation DoomOperation(
  88       SimpleEntryImpl* entry,
  89       const CompletionCallback& callback);
  90
  91   bool ConflictsWith(const SimpleEntryOperation& other_op) const;
  92   // Releases all references. After calling this operation, SimpleEntryOperation
  93   // will only hold POD members.
  94   void ReleaseReferences();
  95
  96   EntryOperationType type() const {
  97     return static_cast<EntryOperationType>(type_);
  98   }
  99   const CompletionCallback& callback() const { return callback_; }
 100   Entry** out_entry() { return out_entry_; }
 101   bool have_index() const { return have_index_; }
 102   int index() const { return index_; }
 103   int offset() const { return offset_; }
 104   int64 sparse_offset() const { return sparse_offset_; }
 105   int length() const { return length_; }
 106   int64* out_start() { return out_start_; }
 107   net::IOBuffer* buf() { return buf_.get(); }
 108   bool truncate() const { return truncate_; }
 109   bool optimistic() const { return optimistic_; }
 110   bool alone_in_queue() const { return alone_in_queue_; }
 111
 112  private:
 113   SimpleEntryOperation(SimpleEntryImpl* entry,
 114                        net::IOBuffer* buf,
 115                        const CompletionCallback& callback,
 116                        Entry** out_entry,
 117                        int offset,
 118                        int64 sparse_offset,
 119                        int length,
 120                        int64* out_start,
 121                        EntryOperationType type,
 122                        bool have_index,
 123                        int index,
 124                        bool truncate,
 125                        bool optimistic,
 126                        bool alone_in_queue);
 127
 128   // This ensures entry will not be deleted until the operation has ran.
 129   scoped_refptr<SimpleEntryImpl> entry_;
 130   scoped_refptr<net::IOBuffer> buf_;
 131   CompletionCallback callback_;
 132
 133   // Used in open and create operations.
 134   Entry** out_entry_;
 135
 136   // Used in write and read operations.
 137   const int offset_;
 138   const int64 sparse_offset_;
 139   const int length_;
 140
 141   // Used in get available range operations.
 142   int64* const out_start_;
 143
 144   const EntryOperationType type_;
 145   // Used in open and create operations.
 146   const bool have_index_;
 147   // Used in write and read operations.
 148   const unsigned int index_;
 149   // Used only in write operations.
 150   const bool truncate_;
 151   const bool optimistic_;
 152   // Used only in SimpleCache.ReadIsParallelizable histogram.
 153   const bool alone_in_queue_;
 154 };
 155
 156 }  // namespace disk_cache
 157
 158 #endif  // NET_DISK_CACHE_SIMPLE_SIMPLE_ENTRY_OPERATION_H_