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
|
// 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.
#include "storage/browser/file_system/quota/quota_reservation.h"
#include <stdint.h>
#include <memory>
#include "base/functional/bind.h"
#include "base/functional/callback.h"
#include "storage/browser/file_system/quota/open_file_handle.h"
#include "storage/browser/file_system/quota/quota_reservation_buffer.h"
namespace storage {
void QuotaReservation::RefreshReservation(int64_t size,
StatusCallback callback) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
DCHECK(!running_refresh_request_);
DCHECK(!client_crashed_);
if (!reservation_manager())
return;
running_refresh_request_ = true;
reservation_manager()->ReserveQuota(
origin(), type(), size - remaining_quota_,
base::BindOnce(&QuotaReservation::AdaptDidUpdateReservedQuota,
weak_ptr_factory_.GetWeakPtr(), remaining_quota_,
std::move(callback)));
if (running_refresh_request_)
remaining_quota_ = 0;
}
std::unique_ptr<OpenFileHandle> QuotaReservation::GetOpenFileHandle(
const base::FilePath& platform_path) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
DCHECK(!client_crashed_);
return reservation_buffer_->GetOpenFileHandle(this, platform_path);
}
void QuotaReservation::OnClientCrash() {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
client_crashed_ = true;
if (remaining_quota_) {
reservation_buffer_->PutReservationToBuffer(remaining_quota_);
remaining_quota_ = 0;
}
}
void QuotaReservation::ConsumeReservation(int64_t size) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
DCHECK_LT(0, size);
DCHECK_LE(size, remaining_quota_);
if (client_crashed_)
return;
remaining_quota_ -= size;
reservation_buffer_->PutReservationToBuffer(size);
}
QuotaReservationManager* QuotaReservation::reservation_manager() {
return reservation_buffer_->reservation_manager();
}
const url::Origin& QuotaReservation::origin() const {
return reservation_buffer_->origin();
}
FileSystemType QuotaReservation::type() const {
return reservation_buffer_->type();
}
QuotaReservation::QuotaReservation(QuotaReservationBuffer* reservation_buffer)
: client_crashed_(false),
running_refresh_request_(false),
remaining_quota_(0),
reservation_buffer_(reservation_buffer) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
}
QuotaReservation::~QuotaReservation() {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
if (remaining_quota_ && reservation_manager()) {
reservation_manager()->ReleaseReservedQuota(origin(), type(),
remaining_quota_);
}
}
// static
bool QuotaReservation::AdaptDidUpdateReservedQuota(
const base::WeakPtr<QuotaReservation>& reservation,
int64_t previous_size,
StatusCallback callback,
base::File::Error error,
int64_t delta) {
if (!reservation)
return false;
return reservation->DidUpdateReservedQuota(previous_size, std::move(callback),
error, delta);
}
bool QuotaReservation::DidUpdateReservedQuota(int64_t previous_size,
StatusCallback callback,
base::File::Error error,
int64_t delta) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
DCHECK(running_refresh_request_);
running_refresh_request_ = false;
if (client_crashed_) {
std::move(callback).Run(base::File::FILE_ERROR_ABORT);
return false;
}
if (error == base::File::FILE_OK)
remaining_quota_ = previous_size + delta;
std::move(callback).Run(error);
return true;
}
} // namespace storage
|
