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
|
// Copyright 2020 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "components/policy/content/safe_sites_navigation_throttle.h"
#include "base/functional/bind.h"
#include "components/policy/content/safe_search_service.h"
#include "components/url_matcher/url_util.h"
#include "content/public/browser/navigation_handle.h"
#include "url/gurl.h"
// Use of Unretained for is safe because it is called synchronously from this
// object.
SafeSitesNavigationThrottle::SafeSitesNavigationThrottle(
content::NavigationThrottleRegistry& registry,
content::BrowserContext* context,
std::optional<std::string_view> safe_sites_error_page_content)
: Client(registry),
safe_search_service_(SafeSearchFactory::GetForBrowserContext(context)),
safe_sites_error_page_content_(std::move(safe_sites_error_page_content)) {
SetDeferredResultCallback(base::BindRepeating(
&SafeSitesNavigationThrottle::OnDeferredResult, base::Unretained(this)));
}
SafeSitesNavigationThrottle::~SafeSitesNavigationThrottle() = default;
void SafeSitesNavigationThrottle::SetDeferredResultCallback(
const ProceedUntilResponseNavigationThrottle::DeferredResultCallback&
deferred_result_callback) {
deferred_result_callback_ = deferred_result_callback;
}
content::NavigationThrottle::ThrottleCheckResult
SafeSitesNavigationThrottle::WillStartRequest() {
const GURL& url = navigation_handle()->GetURL();
// Ignore blob scheme because we may use it to deliver navigation responses
// to the renderer process.
if (url.SchemeIs(url::kBlobScheme)) {
return PROCEED;
}
// Safe Sites filter applies to HTTP[S] requests.
if (!url.SchemeIsHTTPOrHTTPS()) {
return PROCEED;
}
GURL effective_url = url_matcher::util::GetEmbeddedURL(url);
if (!effective_url.is_valid()) {
effective_url = url;
}
const bool synchronous = safe_search_service_->CheckSafeSearchURL(
effective_url,
base::BindOnce(&SafeSitesNavigationThrottle::CheckSafeSearchCallback,
weak_ptr_factory_.GetWeakPtr()));
if (!synchronous) {
deferred_ = true;
return DEFER;
}
if (should_cancel_) {
return CreateCancelResult();
}
return PROCEED;
}
content::NavigationThrottle::ThrottleCheckResult
SafeSitesNavigationThrottle::WillRedirectRequest() {
return WillStartRequest();
}
const char* SafeSitesNavigationThrottle::GetNameForLogging() {
return "SafeSitesNavigationThrottle";
}
void SafeSitesNavigationThrottle::CheckSafeSearchCallback(bool is_safe) {
if (!deferred_) {
should_cancel_ = !is_safe;
return;
}
deferred_ = false;
deferred_result_callback_.Run(is_safe, CreateCancelResult());
}
void SafeSitesNavigationThrottle::OnDeferredResult(
bool proceed,
std::optional<ThrottleCheckResult> result) {
if (proceed) {
Resume();
} else {
CHECK(result.has_value());
CancelDeferredNavigation(*result);
}
}
content::NavigationThrottle::ThrottleCheckResult
SafeSitesNavigationThrottle::CreateCancelResult() const {
return ThrottleCheckResult(CANCEL, net::ERR_BLOCKED_BY_ADMINISTRATOR,
safe_sites_error_page_content_);
}
|
