1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
|
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef CacheFileChunk__h__
#define CacheFileChunk__h__
#include "CacheFileIOManager.h"
#include "CacheStorageService.h"
#include "CacheHashUtils.h"
#include "CacheFileUtils.h"
#include "mozilla/Mutex.h"
#include "mozilla/UniquePtr.h"
namespace mozilla {
namespace net {
constexpr int32_t kChunkSize = 256 * 1024;
constexpr size_t kEmptyChunkHash = 0x1826;
class CacheFileChunk;
class CacheFile;
class CacheFileChunkBuffer {
public:
NS_INLINE_DECL_THREADSAFE_REFCOUNTING(CacheFileChunkBuffer)
explicit CacheFileChunkBuffer(CacheFileChunk* aChunk);
nsresult EnsureBufSize(uint32_t aBufSize);
void CopyFrom(CacheFileChunkBuffer* aOther);
nsresult FillInvalidRanges(CacheFileChunkBuffer* aOther,
CacheFileUtils::ValidityMap* aMap);
size_t SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const;
char* Buf() const { return mBuf; }
void SetDataSize(uint32_t aDataSize);
uint32_t DataSize() const { return mDataSize; }
uint32_t ReadHandlesCount() const { return mReadHandlesCount; }
bool WriteHandleExists() const { return mWriteHandleExists; }
private:
friend class CacheFileChunkHandle;
friend class CacheFileChunkReadHandle;
friend class CacheFileChunkWriteHandle;
~CacheFileChunkBuffer();
void AssertOwnsLock() const;
void RemoveReadHandle();
void RemoveWriteHandle();
// We keep a weak reference to the chunk to not create a reference cycle. The
// buffer is referenced only by chunk and handles. Handles are always
// destroyed before the chunk so it is guaranteed that mChunk is a valid
// pointer for the whole buffer's lifetime.
CacheFileChunk* mChunk;
char* mBuf;
uint32_t mBufSize;
uint32_t mDataSize;
uint32_t mReadHandlesCount;
bool mWriteHandleExists;
};
class CacheFileChunkHandle {
public:
uint32_t DataSize();
uint32_t Offset();
protected:
RefPtr<CacheFileChunkBuffer> mBuf;
};
class CacheFileChunkReadHandle : public CacheFileChunkHandle {
public:
explicit CacheFileChunkReadHandle(CacheFileChunkBuffer* aBuf);
~CacheFileChunkReadHandle();
const char* Buf();
};
class CacheFileChunkWriteHandle : public CacheFileChunkHandle {
public:
explicit CacheFileChunkWriteHandle(CacheFileChunkBuffer* aBuf);
~CacheFileChunkWriteHandle();
char* Buf();
void UpdateDataSize(uint32_t aOffset, uint32_t aLen);
};
#define CACHEFILECHUNKLISTENER_IID \
{ /* baf16149-2ab5-499c-a9c2-5904eb95c288 */ \
0xbaf16149, 0x2ab5, 0x499c, { \
0xa9, 0xc2, 0x59, 0x04, 0xeb, 0x95, 0xc2, 0x88 \
} \
}
class CacheFileChunkListener : public nsISupports {
public:
NS_DECLARE_STATIC_IID_ACCESSOR(CACHEFILECHUNKLISTENER_IID)
NS_IMETHOD OnChunkRead(nsresult aResult, CacheFileChunk* aChunk) = 0;
NS_IMETHOD OnChunkWritten(nsresult aResult, CacheFileChunk* aChunk) = 0;
NS_IMETHOD OnChunkAvailable(nsresult aResult, uint32_t aChunkIdx,
CacheFileChunk* aChunk) = 0;
NS_IMETHOD OnChunkUpdated(CacheFileChunk* aChunk) = 0;
};
NS_DEFINE_STATIC_IID_ACCESSOR(CacheFileChunkListener,
CACHEFILECHUNKLISTENER_IID)
class ChunkListenerItem {
public:
MOZ_COUNTED_DEFAULT_CTOR(ChunkListenerItem)
MOZ_COUNTED_DTOR(ChunkListenerItem)
nsCOMPtr<nsIEventTarget> mTarget;
nsCOMPtr<CacheFileChunkListener> mCallback;
};
class ChunkListeners {
public:
MOZ_COUNTED_DEFAULT_CTOR(ChunkListeners)
MOZ_COUNTED_DTOR(ChunkListeners)
nsTArray<ChunkListenerItem*> mItems;
};
class CacheFileChunk final : public CacheFileIOListener,
public CacheMemoryConsumer {
public:
NS_DECL_THREADSAFE_ISUPPORTS
bool DispatchRelease();
CacheFileChunk(CacheFile* aFile, uint32_t aIndex, bool aInitByWriter);
void InitNew();
nsresult Read(CacheFileHandle* aHandle, uint32_t aLen,
CacheHash::Hash16_t aHash, CacheFileChunkListener* aCallback);
nsresult Write(CacheFileHandle* aHandle, CacheFileChunkListener* aCallback);
void WaitForUpdate(CacheFileChunkListener* aCallback);
void CancelWait(CacheFileChunkListener* aCallback);
nsresult NotifyUpdateListeners();
uint32_t Index() const;
CacheHash::Hash16_t Hash() const;
uint32_t DataSize() const;
NS_IMETHOD OnFileOpened(CacheFileHandle* aHandle, nsresult aResult) override;
NS_IMETHOD OnDataWritten(CacheFileHandle* aHandle, const char* aBuf,
nsresult aResult) override;
NS_IMETHOD OnDataRead(CacheFileHandle* aHandle, char* aBuf,
nsresult aResult) override;
NS_IMETHOD OnFileDoomed(CacheFileHandle* aHandle, nsresult aResult) override;
NS_IMETHOD OnEOFSet(CacheFileHandle* aHandle, nsresult aResult) override;
NS_IMETHOD OnFileRenamed(CacheFileHandle* aHandle, nsresult aResult) override;
virtual bool IsKilled() override;
bool IsReady() const;
bool IsDirty() const;
nsresult GetStatus();
void SetError(nsresult aStatus);
CacheFileChunkReadHandle GetReadHandle();
CacheFileChunkWriteHandle GetWriteHandle(uint32_t aEnsuredBufSize);
// Memory reporting
size_t SizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) const;
size_t SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const;
private:
friend class CacheFileChunkBuffer;
friend class CacheFileChunkWriteHandle;
friend class CacheFileInputStream;
friend class CacheFileOutputStream;
friend class CacheFile;
virtual ~CacheFileChunk();
void AssertOwnsLock() const;
void UpdateDataSize(uint32_t aOffset, uint32_t aLen);
void Truncate(uint32_t aOffset);
bool CanAllocate(uint32_t aSize) const;
void BuffersAllocationChanged(uint32_t aFreed, uint32_t aAllocated);
mozilla::Atomic<uint32_t, ReleaseAcquire>& ChunksMemoryUsage() const;
enum EState { INITIAL = 0, READING = 1, WRITING = 2, READY = 3 };
uint32_t mIndex;
EState mState;
nsresult mStatus;
Atomic<bool> mActiveChunk; // Is true iff the chunk is in CacheFile::mChunks.
// Adding/removing chunk to/from mChunks as well
// as changing this member happens under the
// CacheFile's lock.
bool mIsDirty : 1;
bool mDiscardedChunk : 1;
uint32_t mBuffersSize;
bool const mLimitAllocation : 1; // Whether this chunk respects limit for
// disk chunks memory usage.
bool const mIsPriority : 1;
// Buffer containing the chunk data. Multiple read handles can access the same
// buffer. When write handle is created and some read handle exists a new copy
// of the buffer is created. This prevents invalidating the buffer when
// CacheFileInputStream::ReadSegments calls the handler outside the lock.
RefPtr<CacheFileChunkBuffer> mBuf;
// We need to keep pointers of the old buffers for memory reporting.
nsTArray<RefPtr<CacheFileChunkBuffer>> mOldBufs;
// Read handle that is used during writing the chunk to the disk.
UniquePtr<CacheFileChunkReadHandle> mWritingStateHandle;
// Buffer that is used to read the chunk from the disk. It is allowed to write
// a new data to chunk while we wait for the data from the disk. In this case
// this buffer is merged with mBuf in OnDataRead().
RefPtr<CacheFileChunkBuffer> mReadingStateBuf;
CacheHash::Hash16_t mExpectedHash;
RefPtr<CacheFile> mFile; // is null if chunk is cached to
// prevent reference cycles
nsCOMPtr<CacheFileChunkListener> mListener;
nsTArray<ChunkListenerItem*> mUpdateListeners;
CacheFileUtils::ValidityMap mValidityMap;
};
} // namespace net
} // namespace mozilla
#endif
|
