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
|
// Copyright 2021 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "content/browser/cache_storage/cache_storage_control_wrapper.h"
#include "base/task/sequenced_task_runner.h"
#include "third_party/blink/public/common/storage_key/storage_key.h"
namespace content {
CacheStorageControlWrapper::CacheStorageControlWrapper(
scoped_refptr<base::SequencedTaskRunner> io_task_runner,
const base::FilePath& user_data_directory,
scoped_refptr<storage::SpecialStoragePolicy> special_storage_policy,
scoped_refptr<storage::QuotaManagerProxy> quota_manager_proxy,
mojo::PendingRemote<storage::mojom::BlobStorageContext>
blob_storage_context) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
DCHECK(quota_manager_proxy);
// QuotaManagerProxy::RegisterClient() must be called during construction
// until crbug.com/1182630 is fixed.
mojo::PendingRemote<storage::mojom::QuotaClient> cache_storage_client_remote;
mojo::PendingReceiver<storage::mojom::QuotaClient>
cache_storage_client_receiver =
cache_storage_client_remote.InitWithNewPipeAndPassReceiver();
quota_manager_proxy->RegisterClient(
std::move(cache_storage_client_remote),
storage::QuotaClientType::kServiceWorkerCache);
mojo::PendingRemote<storage::mojom::QuotaClient>
background_fetch_client_remote;
mojo::PendingReceiver<storage::mojom::QuotaClient>
background_fetch_client_receiver =
background_fetch_client_remote.InitWithNewPipeAndPassReceiver();
quota_manager_proxy->RegisterClient(
std::move(background_fetch_client_remote),
storage::QuotaClientType::kBackgroundFetch);
cache_storage_context_ = base::SequenceBound<CacheStorageContextImpl>(
CacheStorageContextImpl::CreateSchedulerTaskRunner(),
std::move(quota_manager_proxy));
cache_storage_context_.AsyncCall(&CacheStorageContextImpl::Init)
.WithArgs(cache_storage_control_.BindNewPipeAndPassReceiver(),
user_data_directory, std::move(cache_storage_client_receiver),
std::move(background_fetch_client_receiver),
std::move(blob_storage_context));
if (special_storage_policy) {
// `storage_policy_observer_` is owned by `this` and so it is safe
// to use base::Unretained here.
storage_policy_observer_.emplace(
base::BindRepeating(&CacheStorageControlWrapper::ApplyPolicyUpdates,
base::Unretained(this)),
std::move(io_task_runner), std::move(special_storage_policy));
}
}
CacheStorageControlWrapper::~CacheStorageControlWrapper() {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
}
void CacheStorageControlWrapper::AddReceiver(
const network::CrossOriginEmbedderPolicy& cross_origin_embedder_policy,
mojo::PendingRemote<network::mojom::CrossOriginEmbedderPolicyReporter>
coep_reporter_remote,
const network::DocumentIsolationPolicy& document_isolation_policy,
mojo::PendingRemote<network::mojom::DocumentIsolationPolicyReporter>
dip_reporter_remote,
const storage::BucketLocator& bucket,
storage::mojom::CacheStorageOwner owner,
mojo::PendingReceiver<blink::mojom::CacheStorage> receiver) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
if (storage_policy_observer_)
storage_policy_observer_->StartTrackingOrigin(bucket.storage_key.origin());
cache_storage_control_->AddReceiver(
cross_origin_embedder_policy, std::move(coep_reporter_remote),
document_isolation_policy, std::move(dip_reporter_remote), bucket, owner,
std::move(receiver));
}
void CacheStorageControlWrapper::AddObserver(
mojo::PendingRemote<storage::mojom::CacheStorageObserver> observer) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
cache_storage_control_->AddObserver(std::move(observer));
}
void CacheStorageControlWrapper::ApplyPolicyUpdates(
std::vector<storage::mojom::StoragePolicyUpdatePtr> policy_updates) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
cache_storage_control_->ApplyPolicyUpdates(std::move(policy_updates));
}
} // namespace content
|
