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
|
// Copyright 2013 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef STORAGE_BROWSER_FILE_SYSTEM_QUOTA_QUOTA_RESERVATION_MANAGER_H_
#define STORAGE_BROWSER_FILE_SYSTEM_QUOTA_QUOTA_RESERVATION_MANAGER_H_
#include <stdint.h>
#include <map>
#include <memory>
#include <utility>
#include "base/component_export.h"
#include "base/files/file.h"
#include "base/functional/callback_forward.h"
#include "base/memory/raw_ptr.h"
#include "base/memory/scoped_refptr.h"
#include "base/memory/weak_ptr.h"
#include "storage/common/file_system/file_system_types.h"
namespace url {
class Origin;
}
namespace storage {
class QuotaReservation;
class QuotaReservationBuffer;
class COMPONENT_EXPORT(STORAGE_BROWSER) QuotaReservationManager {
public:
// Callback for ReserveQuota. When this callback returns false, ReserveQuota
// operation should be reverted.
using ReserveQuotaCallback =
base::OnceCallback<bool(base::File::Error error, int64_t delta)>;
// An abstraction of backing quota system.
class COMPONENT_EXPORT(STORAGE_BROWSER) QuotaBackend {
public:
QuotaBackend() = default;
QuotaBackend(const QuotaBackend&) = delete;
QuotaBackend& operator=(const QuotaBackend&) = delete;
virtual ~QuotaBackend() = default;
// Reserves or reclaims |delta| of quota for |origin| and |type| pair.
// Reserved quota should be counted as usage, but it should be on-memory
// and be cleared by a browser restart.
// Invokes |callback| upon completion with an error code.
// |callback| should return false if it can't accept the reservation, in
// that case, the backend should roll back the reservation.
virtual void ReserveQuota(const url::Origin& origin,
FileSystemType type,
int64_t delta,
ReserveQuotaCallback callback) = 0;
// Reclaims |size| of quota for |origin| and |type|.
virtual void ReleaseReservedQuota(const url::Origin& origin,
FileSystemType type,
int64_t size) = 0;
// Updates disk usage of |origin| and |type|.
// Invokes |callback| upon completion with an error code.
virtual void CommitQuotaUsage(const url::Origin& origin,
FileSystemType type,
int64_t delta) = 0;
virtual void IncrementDirtyCount(const url::Origin& origin,
FileSystemType type) = 0;
virtual void DecrementDirtyCount(const url::Origin& origin,
FileSystemType type) = 0;
};
explicit QuotaReservationManager(std::unique_ptr<QuotaBackend> backend);
QuotaReservationManager(const QuotaReservationManager&) = delete;
QuotaReservationManager& operator=(const QuotaReservationManager&) = delete;
~QuotaReservationManager();
// The entry point of the quota reservation. Creates new reservation object
// for |origin| and |type|.
scoped_refptr<QuotaReservation> CreateReservation(const url::Origin& origin,
FileSystemType type);
private:
using ReservationBufferByOriginAndType =
std::map<std::pair<url::Origin, FileSystemType>,
raw_ptr<QuotaReservationBuffer, CtnExperimental>>;
friend class QuotaReservation;
friend class QuotaReservationBuffer;
friend class QuotaReservationManagerTest;
void ReserveQuota(const url::Origin& origin,
FileSystemType type,
int64_t delta,
ReserveQuotaCallback callback);
void ReleaseReservedQuota(const url::Origin& origin,
FileSystemType type,
int64_t size);
void CommitQuotaUsage(const url::Origin& origin,
FileSystemType type,
int64_t delta);
void IncrementDirtyCount(const url::Origin& origin, FileSystemType type);
void DecrementDirtyCount(const url::Origin& origin, FileSystemType type);
scoped_refptr<QuotaReservationBuffer> GetReservationBuffer(
const url::Origin& origin,
FileSystemType type);
void ReleaseReservationBuffer(QuotaReservationBuffer* reservation_pool);
std::unique_ptr<QuotaBackend> backend_;
// Not owned. The destructor of ReservationBuffer should erase itself from
// |reservation_buffers_| by calling ReleaseReservationBuffer.
ReservationBufferByOriginAndType reservation_buffers_;
SEQUENCE_CHECKER(sequence_checker_);
base::WeakPtrFactory<QuotaReservationManager> weak_ptr_factory_{this};
};
} // namespace storage
#endif // STORAGE_BROWSER_FILE_SYSTEM_QUOTA_QUOTA_RESERVATION_MANAGER_H_
|
