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
|
// 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_search_service.h"
#include <utility>
#include "base/functional/bind.h"
#include "components/keyed_service/content/browser_context_dependency_manager.h"
#include "components/safe_search_api/safe_search/safe_search_url_checker_client.h"
#include "components/safe_search_api/url_checker.h"
#include "components/url_matcher/url_util.h"
#include "content/public/browser/browser_context.h"
#include "content/public/browser/storage_partition.h"
#include "net/base/net_errors.h"
namespace {
// Calls the SafeSearchService callback with the result of the Safe Search
// API check.
void OnCheckURLDone(SafeSearchService::CheckSafeSearchCallback callback,
const GURL& /* url */,
safe_search_api::Classification classification,
safe_search_api::ClassificationDetails details) {
std::move(callback).Run(classification ==
safe_search_api::Classification::SAFE);
}
} // namespace
SafeSearchService::SafeSearchService(content::BrowserContext* browser_context)
: browser_context_(browser_context) {}
SafeSearchService::~SafeSearchService() = default;
bool SafeSearchService::CheckSafeSearchURL(const GURL& url,
CheckSafeSearchCallback callback) {
if (!safe_search_url_checker_) {
net::NetworkTrafficAnnotationTag traffic_annotation =
net::DefineNetworkTrafficAnnotation("safe_search_service", R"(
semantics {
sender: "Cloud Policy"
description:
"Checks whether a given URL (or set of URLs) is considered safe "
"by Google SafeSearch."
trigger:
"If the policy for safe sites is enabled, this is sent for every "
"top-level navigation if the result isn't already cached."
data: "URL to be checked."
destination: GOOGLE_OWNED_SERVICE
}
policy {
cookies_allowed: NO
setting:
"This feature is off by default and cannot be controlled in "
"settings."
chrome_policy {
SafeSitesFilterBehavior {
SafeSitesFilterBehavior: 0
}
}
})");
safe_search_url_checker_ = std::make_unique<safe_search_api::URLChecker>(
std::make_unique<safe_search_api::SafeSearchURLCheckerClient>(
browser_context_->GetDefaultStoragePartition()
->GetURLLoaderFactoryForBrowserProcess(),
traffic_annotation));
}
return safe_search_url_checker_->CheckURL(
url_matcher::util::Normalize(url),
base::BindOnce(&OnCheckURLDone, std::move(callback)));
}
void SafeSearchService::SetSafeSearchURLCheckerForTest(
std::unique_ptr<safe_search_api::URLChecker> safe_search_url_checker) {
safe_search_url_checker_ = std::move(safe_search_url_checker);
}
// static
SafeSearchFactory* SafeSearchFactory::GetInstance() {
return base::Singleton<SafeSearchFactory>::get();
}
// static
SafeSearchService* SafeSearchFactory::GetForBrowserContext(
content::BrowserContext* context) {
return static_cast<SafeSearchService*>(
GetInstance()->GetServiceForBrowserContext(context, true));
}
SafeSearchFactory::SafeSearchFactory()
: BrowserContextKeyedServiceFactory(
"SafeSearch",
BrowserContextDependencyManager::GetInstance()) {}
SafeSearchFactory::~SafeSearchFactory() = default;
std::unique_ptr<KeyedService>
SafeSearchFactory::BuildServiceInstanceForBrowserContext(
content::BrowserContext* context) const {
return std::make_unique<SafeSearchService>(context);
}
content::BrowserContext* SafeSearchFactory::GetBrowserContextToUse(
content::BrowserContext* context) const {
return context;
}
|
