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
|
// Copyright 2017 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "components/subresource_filter/content/browser/verified_ruleset_dealer.h"
#include "base/bind.h"
#include "base/bind_helpers.h"
#include "base/files/file.h"
#include "base/location.h"
#include "base/logging.h"
#include "components/subresource_filter/core/common/indexed_ruleset.h"
#include "components/subresource_filter/core/common/memory_mapped_ruleset.h"
namespace subresource_filter {
// VerifiedRulesetDealer and its Handle. ---------------------------------------
VerifiedRulesetDealer::VerifiedRulesetDealer() = default;
VerifiedRulesetDealer::~VerifiedRulesetDealer() = default;
void VerifiedRulesetDealer::SetRulesetFile(base::File ruleset_file) {
RulesetDealer::SetRulesetFile(std::move(ruleset_file));
status_ = RulesetVerificationStatus::NOT_VERIFIED;
}
scoped_refptr<const MemoryMappedRuleset> VerifiedRulesetDealer::GetRuleset() {
DCHECK(CalledOnValidSequence());
// TODO(pkalinnikov): Record verification status to a histogram.
switch (status_) {
case RulesetVerificationStatus::NOT_VERIFIED: {
auto ruleset = RulesetDealer::GetRuleset();
if (ruleset &&
IndexedRulesetMatcher::Verify(ruleset->data(), ruleset->length())) {
status_ = RulesetVerificationStatus::INTACT;
return ruleset;
}
status_ = RulesetVerificationStatus::CORRUPT;
return nullptr;
}
case RulesetVerificationStatus::INTACT: {
auto ruleset = RulesetDealer::GetRuleset();
DCHECK(ruleset);
return ruleset;
}
case RulesetVerificationStatus::CORRUPT:
return nullptr;
default:
NOTREACHED();
return nullptr;
}
}
VerifiedRulesetDealer::Handle::Handle(
scoped_refptr<base::SequencedTaskRunner> task_runner)
: task_runner_(task_runner.get()),
dealer_(new VerifiedRulesetDealer,
base::OnTaskRunnerDeleter(std::move(task_runner))) {}
VerifiedRulesetDealer::Handle::~Handle() = default;
void VerifiedRulesetDealer::Handle::GetDealerAsync(
base::Callback<void(VerifiedRulesetDealer*)> callback) {
DCHECK(sequence_checker_.CalledOnValidSequence());
// NOTE: Properties of the sequenced |task_runner| guarantee that the
// |callback| will always be provided with a valid pointer, because the
// corresponding task will be posted *before* a task to delete the pointer
// upon destruction of |this| Handler.
task_runner_->PostTask(FROM_HERE,
base::Bind(std::move(callback), dealer_.get()));
}
void VerifiedRulesetDealer::Handle::SetRulesetFile(base::File file) {
DCHECK(sequence_checker_.CalledOnValidSequence());
task_runner_->PostTask(
FROM_HERE,
base::Bind(&VerifiedRulesetDealer::SetRulesetFile,
base::Unretained(dealer_.get()), base::Passed(&file)));
}
// VerifiedRuleset and its Handle. ---------------------------------------------
VerifiedRuleset::VerifiedRuleset() {
sequence_checker_.DetachFromSequence();
}
VerifiedRuleset::~VerifiedRuleset() {
DCHECK(sequence_checker_.CalledOnValidSequence());
}
void VerifiedRuleset::Initialize(VerifiedRulesetDealer* dealer) {
DCHECK(sequence_checker_.CalledOnValidSequence());
DCHECK(dealer);
ruleset_ = dealer->GetRuleset();
}
VerifiedRuleset::Handle::Handle(VerifiedRulesetDealer::Handle* dealer_handle)
: task_runner_(dealer_handle->task_runner()),
ruleset_(new VerifiedRuleset, base::OnTaskRunnerDeleter(task_runner_)) {
dealer_handle->GetDealerAsync(base::Bind(&VerifiedRuleset::Initialize,
base::Unretained(ruleset_.get())));
}
VerifiedRuleset::Handle::~Handle() {
DCHECK(sequence_checker_.CalledOnValidSequence());
}
void VerifiedRuleset::Handle::GetRulesetAsync(
base::Callback<void(VerifiedRuleset*)> callback) {
DCHECK(sequence_checker_.CalledOnValidSequence());
task_runner_->PostTask(FROM_HERE, base::Bind(callback, ruleset_.get()));
}
} // namespace subresource_filter
|
