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
|
// Copyright 2014 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_TEST_MOCK_QUOTA_MANAGER_PROXY_H_
#define STORAGE_BROWSER_TEST_MOCK_QUOTA_MANAGER_PROXY_H_
#include <stdint.h>
#include <vector>
#include "base/containers/flat_set.h"
#include "base/memory/raw_ptr.h"
#include "base/memory/scoped_refptr.h"
#include "base/synchronization/lock.h"
#include "base/task/sequenced_task_runner.h"
#include "base/time/time.h"
#include "components/services/storage/public/mojom/quota_client.mojom.h"
#include "mojo/public/cpp/bindings/pending_remote.h"
#include "mojo/public/cpp/bindings/remote.h"
#include "storage/browser/quota/quota_client_type.h"
#include "storage/browser/quota/quota_manager_proxy.h"
#include "storage/browser/test/mock_quota_manager.h"
#include "url/origin.h"
namespace storage {
class MockQuotaManager;
enum class QuotaClientType;
class MockQuotaManagerProxy : public QuotaManagerProxy {
public:
// It is ok to give nullptr to `quota_manager`.
MockQuotaManagerProxy(
MockQuotaManager* quota_manager,
scoped_refptr<base::SequencedTaskRunner> quota_manager_task_runner);
MockQuotaManagerProxy(const MockQuotaManagerProxy&) = delete;
MockQuotaManagerProxy& operator=(const MockQuotaManagerProxy&) = delete;
void UpdateOrCreateBucket(
const BucketInitParams& bucket_params,
scoped_refptr<base::SequencedTaskRunner> callback_task_runner,
base::OnceCallback<void(QuotaErrorOr<BucketInfo>)> callback) override;
QuotaErrorOr<BucketInfo> GetOrCreateBucketSync(
const BucketInitParams& params) override;
void GetBucketByNameUnsafe(
const blink::StorageKey& storage_key,
const std::string& bucket_name,
scoped_refptr<base::SequencedTaskRunner> callback_task_runner,
base::OnceCallback<void(QuotaErrorOr<BucketInfo>)>) override;
void GetBucketById(
const BucketId& bucket_id,
scoped_refptr<base::SequencedTaskRunner> callback_task_runner,
base::OnceCallback<void(QuotaErrorOr<BucketInfo>)> callback) override;
void GetBucketsForStorageKey(
const blink::StorageKey& storage_key,
bool delete_expired,
scoped_refptr<base::SequencedTaskRunner> callback_task_runner,
base::OnceCallback<void(QuotaErrorOr<std::set<BucketInfo>>)> callback)
override;
// We don't mock them.
void SetUsageCacheEnabled(QuotaClientType client_id,
const blink::StorageKey& storage_key,
bool enabled) override {}
void GetUsageAndQuota(
const blink::StorageKey& storage_key,
scoped_refptr<base::SequencedTaskRunner> callback_task_runner,
UsageAndQuotaCallback callback) override;
void GetUsageAndQuota(
const BucketLocator& bucket_locator,
scoped_refptr<base::SequencedTaskRunner> callback_task_runner,
UsageAndQuotaCallback callback);
// Updates the internal access count which can be accessed via
// `notify_bucket_accessed_count()`. Also, records the `bucket_id` in
// `last_notified_bucket_id_`.
void NotifyBucketAccessed(const BucketLocator& bucket,
base::Time access_time) override;
// Records the `bucket_id` and `delta` as `last_notified_bucket_id_` and
// `last_notified_bucket_delta_` respectively. If a non-null
// `MockQuotaManager` is given to the constructor, this also updates the
// manager's internal usage information.
void NotifyBucketModified(
QuotaClientType client_id,
const BucketLocator& bucket,
std::optional<int64_t> delta,
base::Time modification_time,
scoped_refptr<base::SequencedTaskRunner> callback_task_runner,
base::OnceClosure callback) override;
void CreateBucketForTesting(
const blink::StorageKey& storage_key,
const std::string& bucket_name,
scoped_refptr<base::SequencedTaskRunner> callback_task_runner,
base::OnceCallback<void(QuotaErrorOr<BucketInfo>)> callback) override;
blink::StorageKey last_notified_storage_key() const {
return last_notified_storage_key_;
}
int notify_bucket_accessed_count() const { return bucket_accessed_count_; }
int notify_bucket_modified_count() const { return bucket_modified_count_; }
BucketId last_notified_bucket_id() const { return last_notified_bucket_id_; }
std::optional<int64_t> last_notified_bucket_delta() const {
return last_notified_bucket_delta_;
}
protected:
~MockQuotaManagerProxy() override;
private:
const raw_ptr<MockQuotaManager, AcrossTasksDanglingUntriaged>
mock_quota_manager_;
// The real QuotaManagerProxy is safe to call into from any thread, therefore
// this mock quota manager must also be safe to call into from any thread.
base::Lock lock_;
blink::StorageKey last_notified_storage_key_;
int bucket_accessed_count_ = 0;
int bucket_modified_count_ = 0;
BucketId last_notified_bucket_id_ = BucketId::FromUnsafeValue(-1);
std::optional<int64_t> last_notified_bucket_delta_;
};
} // namespace storage
#endif // STORAGE_BROWSER_TEST_MOCK_QUOTA_MANAGER_PROXY_H_
|
