1// Copyright (c) 2012 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_BLOCKFILE_SPARSE_CONTROL_H_
6#define NET_DISK_CACHE_BLOCKFILE_SPARSE_CONTROL_H_
7
8#include <string>
9#include <vector>
10
11#include "base/basictypes.h"
12#include "base/compiler_specific.h"
13#include "net/base/completion_callback.h"
14#include "net/disk_cache/blockfile/bitmap.h"
15#include "net/disk_cache/blockfile/disk_format.h"
16
17namespace net {
18class IOBuffer;
19class DrainableIOBuffer;
20}
21
22namespace disk_cache {
23
24class Entry;
25class EntryImpl;
26
27// This class provides support for the sparse capabilities of the disk cache.
28// Basically, sparse IO is directed from EntryImpl to this class, and we split
29// the operation into multiple small pieces, sending each one to the
30// appropriate entry. An instance of this class is asociated with each entry
31// used directly for sparse operations (the entry passed in to the constructor).
32class SparseControl {
33 public:
34  typedef net::CompletionCallback CompletionCallback;
35
36  // The operation to perform.
37  enum SparseOperation {
38    kNoOperation,
39    kReadOperation,
40    kWriteOperation,
41    kGetRangeOperation
42  };
43
44  explicit SparseControl(EntryImpl* entry);
45  ~SparseControl();
46
47  // Initializes the object for the current entry. If this entry already stores
48  // sparse data, or can be used to do it, it updates the relevant information
49  // on disk and returns net::OK. Otherwise it returns a net error code.
50  int Init();
51
52  // Performs a quick test to see if the entry is sparse or not, without
53  // generating disk IO (so the answer provided is only a best effort).
54  bool CouldBeSparse() const;
55
56  // Performs an actual sparse read or write operation for this entry. |op| is
57  // the operation to perform, |offset| is the desired sparse offset, |buf| and
58  // |buf_len| specify the actual data to use and |callback| is the callback
59  // to use for asynchronous operations. See the description of the Read /
60  // WriteSparseData for details about the arguments. The return value is the
61  // number of bytes read or written, or a net error code.
62  int StartIO(SparseOperation op, int64 offset, net::IOBuffer* buf,
63              int buf_len, const CompletionCallback& callback);
64
65  // Implements Entry::GetAvailableRange().
66  int GetAvailableRange(int64 offset, int len, int64* start);
67
68  // Cancels the current sparse operation (if any).
69  void CancelIO();
70
71  // Returns OK if the entry can be used for new IO or ERR_IO_PENDING if we are
72  // busy. If the entry is busy, we'll invoke the callback when we are ready
73  // again. See disk_cache::Entry::ReadyToUse() for more info.
74  int ReadyToUse(const CompletionCallback& completion_callback);
75
76  // Deletes the children entries of |entry|.
77  static void DeleteChildren(EntryImpl* entry);
78
79 private:
80  // Creates a new sparse entry or opens an aready created entry from disk.
81  // These methods just read / write the required info from disk for the current
82  // entry, and verify that everything is correct. The return value is a net
83  // error code.
84  int CreateSparseEntry();
85  int OpenSparseEntry(int data_len);
86
87  // Opens and closes a child entry. A child entry is a regular EntryImpl object
88  // with a key derived from the key of the resource to store and the range
89  // stored by that child.
90  bool OpenChild();
91  void CloseChild();
92  std::string GenerateChildKey();
93
94  // Deletes the current child and continues the current operation (open).
95  bool KillChildAndContinue(const std::string& key, bool fatal);
96
97  // Continues the current operation (open) without a current child.
98  bool ContinueWithoutChild(const std::string& key);
99
100  // Returns true if the required child is tracked by the parent entry, i.e. it
101  // was already created.
102  bool ChildPresent();
103
104  // Sets the bit for the current child to the provided |value|. In other words,
105  // starts or stops tracking this child.
106  void SetChildBit(bool value);
107
108  // Writes to disk the tracking information for this entry.
109  void WriteSparseData();
110
111  // Verify that the range to be accessed for the current child is appropriate.
112  // Returns false if an error is detected or there is no need to perform the
113  // current IO operation (for instance if the required range is not stored by
114  // the child).
115  bool VerifyRange();
116
117  // Updates the contents bitmap for the current range, based on the result of
118  // the current operation.
119  void UpdateRange(int result);
120
121  // Returns the number of bytes stored at |block_index|, if its allocation-bit
122  // is off (because it is not completely filled).
123  int PartialBlockLength(int block_index) const;
124
125  // Initializes the sparse info for the current child.
126  void InitChildData();
127
128  // Iterates through all the children needed to complete the current operation.
129  void DoChildrenIO();
130
131  // Performs a single operation with the current child. Returns true when we
132  // should move on to the next child and false when we should interrupt our
133  // work.
134  bool DoChildIO();
135
136  // Performs the required work for GetAvailableRange for one child.
137  int DoGetAvailableRange();
138
139  // Performs the required work after a single IO operations finishes.
140  void DoChildIOCompleted(int result);
141
142  // Invoked by the callback of asynchronous operations.
143  void OnChildIOCompleted(int result);
144
145  // Reports to the user that we are done.
146  void DoUserCallback();
147  void DoAbortCallbacks();
148
149  EntryImpl* entry_;  // The sparse entry.
150  EntryImpl* child_;  // The current child entry.
151  SparseOperation operation_;
152  bool pending_;  // True if any child IO operation returned pending.
153  bool finished_;
154  bool init_;
155  bool range_found_;  // True if GetAvailableRange found something.
156  bool abort_;  // True if we should abort the current operation ASAP.
157
158  SparseHeader sparse_header_;  // Data about the children of entry_.
159  Bitmap children_map_;  // The actual bitmap of children.
160  SparseData child_data_;  // Parent and allocation map of child_.
161  Bitmap child_map_;  // The allocation map as a bitmap.
162
163  CompletionCallback user_callback_;
164  std::vector<CompletionCallback> abort_callbacks_;
165  int64 offset_;  // Current sparse offset.
166  scoped_refptr<net::DrainableIOBuffer> user_buf_;
167  int buf_len_;  // Bytes to read or write.
168  int child_offset_;  // Offset to use for the current child.
169  int child_len_;  // Bytes to read or write for this child.
170  int result_;
171
172  DISALLOW_COPY_AND_ASSIGN(SparseControl);
173};
174
175}  // namespace disk_cache
176
177#endif  // NET_DISK_CACHE_BLOCKFILE_SPARSE_CONTROL_H_
178