[email protected] | 9045b882 | 2012-01-13 20:35:35 | [diff] [blame] | 1 | // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
[email protected] | ac03952 | 2010-06-15 16:39:44 | [diff] [blame] | 2 | // Use of this source code is governed by a BSD-style license that can be |
| 3 | // found in the LICENSE file. |
| 4 | |
| 5 | #include "chrome/browser/net/chrome_network_delegate.h" |
| 6 | |
avi | 6846aef | 2015-12-26 01:09:38 | [diff] [blame] | 7 | #include <stddef.h> |
[email protected] | eac11e1 | 2013-03-19 22:04:32 | [diff] [blame] | 8 | #include <stdlib.h> |
| 9 | |
[email protected] | d1208ba3 | 2012-11-08 11:10:33 | [diff] [blame] | 10 | #include <vector> |
| 11 | |
[email protected] | d8e4f13 | 2012-09-06 04:28:05 | [diff] [blame] | 12 | #include "base/base_paths.h" |
mkwst | 0513c9d | 2015-04-01 05:53:15 | [diff] [blame] | 13 | #include "base/command_line.h" |
jochen | b93dba3c | 2014-11-11 05:28:41 | [diff] [blame] | 14 | #include "base/debug/alias.h" |
jochen | b5680e6 | 2014-10-13 08:43:41 | [diff] [blame] | 15 | #include "base/debug/dump_without_crashing.h" |
jochen | b93dba3c | 2014-11-11 05:28:41 | [diff] [blame] | 16 | #include "base/debug/stack_trace.h" |
[email protected] | 7a299a9 | 2012-10-24 23:54:50 | [diff] [blame] | 17 | #include "base/logging.h" |
avi | 6846aef | 2015-12-26 01:09:38 | [diff] [blame] | 18 | #include "base/macros.h" |
Ilya Sherman | 982457e6 | 2017-12-13 02:19:36 | [diff] [blame] | 19 | #include "base/metrics/histogram_functions.h" |
jochen | 0e3b3a6 | 2014-09-16 18:31:23 | [diff] [blame] | 20 | #include "base/metrics/user_metrics.h" |
[email protected] | d8e4f13 | 2012-09-06 04:28:05 | [diff] [blame] | 21 | #include "base/path_service.h" |
[email protected] | 3ea1b18 | 2013-02-08 22:38:41 | [diff] [blame] | 22 | #include "base/strings/string_number_conversions.h" |
ellyjones | d84033d | 2015-02-12 19:20:34 | [diff] [blame] | 23 | #include "base/strings/string_util.h" |
[email protected] | 069c4916 | 2013-09-11 20:46:35 | [diff] [blame] | 24 | #include "base/time/time.h" |
avi | 6846aef | 2015-12-26 01:09:38 | [diff] [blame] | 25 | #include "build/build_config.h" |
[email protected] | 6baff0b5 | 2012-03-06 01:30:18 | [diff] [blame] | 26 | #include "chrome/browser/browser_process.h" |
droger | b171697 | 2015-06-30 09:04:09 | [diff] [blame] | 27 | #include "chrome/browser/content_settings/cookie_settings_factory.h" |
[email protected] | 9c8ae8c | 2012-03-09 13:13:35 | [diff] [blame] | 28 | #include "chrome/browser/content_settings/tab_specific_content_settings.h" |
[email protected] | 8523ba5 | 2011-05-22 19:00:58 | [diff] [blame] | 29 | #include "chrome/browser/custom_handlers/protocol_handler_registry.h" |
[email protected] | 4a2b623 | 2014-06-19 08:44:14 | [diff] [blame] | 30 | #include "chrome/browser/net/chrome_extensions_network_delegate.h" |
[email protected] | 6baff0b5 | 2012-03-06 01:30:18 | [diff] [blame] | 31 | #include "chrome/browser/profiles/profile_manager.h" |
avi | 24d693f | 2016-08-06 18:03:52 | [diff] [blame] | 32 | #include "chrome/browser/task_manager/task_manager_interface.h" |
Scott Violet | 6200d33 | 2018-02-23 21:29:23 | [diff] [blame] | 33 | #include "chrome/common/buildflags.h" |
[email protected] | 0a8db0d | 2011-04-13 15:15:40 | [diff] [blame] | 34 | #include "chrome/common/pref_names.h" |
droger | b171697 | 2015-06-30 09:04:09 | [diff] [blame] | 35 | #include "components/content_settings/core/browser/cookie_settings.h" |
sclittle | ae932be | 2015-10-08 20:53:50 | [diff] [blame] | 36 | #include "components/data_usage/core/data_use_aggregator.h" |
[email protected] | 45de676a | 2014-03-18 23:52:02 | [diff] [blame] | 37 | #include "components/domain_reliability/monitor.h" |
brettw | b1fc1b8 | 2016-02-02 00:19:08 | [diff] [blame] | 38 | #include "components/prefs/pref_member.h" |
| 39 | #include "components/prefs/pref_service.h" |
Dominic Battre | 5e8a1cd | 2018-01-02 16:16:58 | [diff] [blame] | 40 | #include "components/variations/net/variations_http_headers.h" |
[email protected] | c38831a1 | 2011-10-28 12:44:49 | [diff] [blame] | 41 | #include "content/public/browser/browser_thread.h" |
[email protected] | 9dfed87 | 2013-12-30 23:08:56 | [diff] [blame] | 42 | #include "content/public/browser/render_frame_host.h" |
[email protected] | 9c1662b | 2012-03-06 15:44:33 | [diff] [blame] | 43 | #include "content/public/browser/render_view_host.h" |
[email protected] | 9c8ae8c | 2012-03-09 13:13:35 | [diff] [blame] | 44 | #include "content/public/browser/resource_request_info.h" |
mkwst | 0513c9d | 2015-04-01 05:53:15 | [diff] [blame] | 45 | #include "content/public/common/content_switches.h" |
ellyjones | d84033d | 2015-02-12 19:20:34 | [diff] [blame] | 46 | #include "content/public/common/process_type.h" |
tyoshino | 430d2f4 | 2016-12-15 09:30:00 | [diff] [blame] | 47 | #include "content/public/common/resource_type.h" |
Scott Violet | c8240b0 | 2018-03-08 22:03:59 | [diff] [blame] | 48 | #include "extensions/buildflags/buildflags.h" |
[email protected] | 82b4230 | 2011-04-20 16:28:16 | [diff] [blame] | 49 | #include "net/base/host_port_pair.h" |
sclittle | 3c16159e | 2014-12-15 19:53:17 | [diff] [blame] | 50 | #include "net/base/load_flags.h" |
[email protected] | 8202d0c | 2011-02-23 08:31:14 | [diff] [blame] | 51 | #include "net/base/net_errors.h" |
[email protected] | 5b9bc35 | 2012-07-18 13:13:34 | [diff] [blame] | 52 | #include "net/cookies/canonical_cookie.h" |
| 53 | #include "net/cookies/cookie_options.h" |
[email protected] | ac03952 | 2010-06-15 16:39:44 | [diff] [blame] | 54 | #include "net/http/http_request_headers.h" |
[email protected] | 4894438 | 2011-04-23 13:28:16 | [diff] [blame] | 55 | #include "net/http/http_response_headers.h" |
ellyjones | d84033d | 2015-02-12 19:20:34 | [diff] [blame] | 56 | #include "net/http/http_status_code.h" |
eroman | 87c53d6 | 2015-04-02 06:51:07 | [diff] [blame] | 57 | #include "net/log/net_log.h" |
mikecirone | 8b85c43 | 2016-09-08 19:11:00 | [diff] [blame] | 58 | #include "net/log/net_log_event_type.h" |
mikecirone | f22f981 | 2016-10-04 03:40:19 | [diff] [blame] | 59 | #include "net/log/net_log_with_source.h" |
[email protected] | d05ef99c | 2011-02-01 21:38:16 | [diff] [blame] | 60 | #include "net/url_request/url_request.h" |
| 61 | |
zpeng | db4a58e | 2017-01-10 17:40:32 | [diff] [blame] | 62 | #if defined(OS_ANDROID) |
Xing Liu | b9456c1 | 2018-05-11 01:46:17 | [diff] [blame] | 63 | #include "base/android/path_utils.h" |
[email protected] | 4a2b623 | 2014-06-19 08:44:14 | [diff] [blame] | 64 | #include "chrome/browser/io_thread.h" |
[email protected] | 4a2b623 | 2014-06-19 08:44:14 | [diff] [blame] | 65 | #endif |
| 66 | |
[email protected] | 4c219e2 | 2012-05-05 19:41:04 | [diff] [blame] | 67 | #if defined(OS_CHROMEOS) |
[email protected] | 49c4cf85 | 2013-09-27 19:28:24 | [diff] [blame] | 68 | #include "base/sys_info.h" |
[email protected] | 28853848 | 2012-09-06 21:09:35 | [diff] [blame] | 69 | #include "chrome/common/chrome_switches.h" |
[email protected] | 4c219e2 | 2012-05-05 19:41:04 | [diff] [blame] | 70 | #endif |
| 71 | |
brettw | 00899e6 | 2016-11-12 02:10:17 | [diff] [blame] | 72 | #if BUILDFLAG(ENABLE_EXTENSIONS) |
[email protected] | 84b7a55 | 2014-07-19 04:52:06 | [diff] [blame] | 73 | #include "extensions/common/constants.h" |
| 74 | #endif |
| 75 | |
[email protected] | 631bb74 | 2011-11-02 11:29:39 | [diff] [blame] | 76 | using content::BrowserThread; |
[email protected] | eaabba2 | 2012-03-07 15:02:11 | [diff] [blame] | 77 | using content::RenderViewHost; |
[email protected] | ea11472 | 2012-03-12 01:11:25 | [diff] [blame] | 78 | using content::ResourceRequestInfo; |
[email protected] | 631bb74 | 2011-11-02 11:29:39 | [diff] [blame] | 79 | |
[email protected] | d05ef99c | 2011-02-01 21:38:16 | [diff] [blame] | 80 | namespace { |
| 81 | |
satorux | d18e61a | 2017-06-08 06:38:46 | [diff] [blame] | 82 | bool g_access_to_all_files_enabled = false; |
| 83 | |
[email protected] | d1208ba3 | 2012-11-08 11:10:33 | [diff] [blame] | 84 | // Gets called when the extensions finish work on the URL. If the extensions |
| 85 | // did not do a redirect (so |new_url| is empty) then we enforce the |
| 86 | // SafeSearch parameters. Otherwise we will get called again after the |
| 87 | // redirect and we enforce SafeSearch then. |
| 88 | void ForceGoogleSafeSearchCallbackWrapper( |
| 89 | const net::CompletionCallback& callback, |
| 90 | net::URLRequest* request, |
| 91 | GURL* new_url, |
| 92 | int rv) { |
| 93 | if (rv == net::OK && new_url->is_empty()) |
[email protected] | 184799df | 2014-07-22 16:03:24 | [diff] [blame] | 94 | safe_search_util::ForceGoogleSafeSearch(request, new_url); |
[email protected] | d1208ba3 | 2012-11-08 11:10:33 | [diff] [blame] | 95 | callback.Run(rv); |
| 96 | } |
| 97 | |
jochen | 65227537 | 2015-01-16 11:35:27 | [diff] [blame] | 98 | void ReportInvalidReferrerSendOnUI() { |
jochen | 0e3b3a6 | 2014-09-16 18:31:23 | [diff] [blame] | 99 | base::RecordAction( |
| 100 | base::UserMetricsAction("Net.URLRequest_StartJob_InvalidReferrer")); |
jochen | 65227537 | 2015-01-16 11:35:27 | [diff] [blame] | 101 | } |
| 102 | |
| 103 | void ReportInvalidReferrerSend(const GURL& target_url, |
| 104 | const GURL& referrer_url) { |
jochen | 4c874d2 | 2015-04-13 14:01:04 | [diff] [blame] | 105 | LOG(ERROR) << "Cancelling request to " << target_url |
| 106 | << " with invalid referrer " << referrer_url; |
jochen | 65227537 | 2015-01-16 11:35:27 | [diff] [blame] | 107 | // Record information to help debug http://crbug.com/422871 |
| 108 | if (!target_url.SchemeIsHTTPOrHTTPS()) |
| 109 | return; |
| 110 | BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, |
tzik | 53a7b902 | 2017-04-24 11:14:48 | [diff] [blame] | 111 | base::BindOnce(&ReportInvalidReferrerSendOnUI)); |
jochen | b5680e6 | 2014-10-13 08:43:41 | [diff] [blame] | 112 | base::debug::DumpWithoutCrashing(); |
jochen | 4c874d2 | 2015-04-13 14:01:04 | [diff] [blame] | 113 | NOTREACHED(); |
jochen | 0e3b3a6 | 2014-09-16 18:31:23 | [diff] [blame] | 114 | } |
| 115 | |
sclittle | 3c16159e | 2014-12-15 19:53:17 | [diff] [blame] | 116 | // Record network errors that HTTP requests complete with, including OK and |
| 117 | // ABORTED. |
maksim.sisov | 1b83bb7 | 2016-10-07 06:07:23 | [diff] [blame] | 118 | void RecordNetworkErrorHistograms(const net::URLRequest* request, |
| 119 | int net_error) { |
sclittle | 3c16159e | 2014-12-15 19:53:17 | [diff] [blame] | 120 | if (request->url().SchemeIs("http")) { |
Ilya Sherman | 982457e6 | 2017-12-13 02:19:36 | [diff] [blame] | 121 | base::UmaHistogramSparse("Net.HttpRequestCompletionErrorCodes", |
| 122 | std::abs(net_error)); |
sclittle | 3c16159e | 2014-12-15 19:53:17 | [diff] [blame] | 123 | |
rdsmith | 4de1fcf | 2016-08-30 05:35:21 | [diff] [blame] | 124 | if (request->load_flags() & net::LOAD_MAIN_FRAME_DEPRECATED) { |
Ilya Sherman | 982457e6 | 2017-12-13 02:19:36 | [diff] [blame] | 125 | base::UmaHistogramSparse("Net.HttpRequestCompletionErrorCodes.MainFrame", |
| 126 | std::abs(net_error)); |
sclittle | 3c16159e | 2014-12-15 19:53:17 | [diff] [blame] | 127 | } |
| 128 | } |
| 129 | } |
| 130 | |
Ken Rockot | 314714c | 2017-11-05 23:36:24 | [diff] [blame] | 131 | bool IsAccessAllowedInternal(const base::FilePath& path, |
| 132 | const base::FilePath& profile_path) { |
| 133 | #if !defined(OS_CHROMEOS) && !defined(OS_ANDROID) |
| 134 | return true; |
| 135 | #else |
| 136 | |
| 137 | std::vector<base::FilePath> whitelist; |
| 138 | #if defined(OS_CHROMEOS) |
| 139 | // Use a whitelist to only allow access to files residing in the list of |
| 140 | // directories below. |
| 141 | static const base::FilePath::CharType* const kLocalAccessWhiteList[] = { |
| 142 | "/home/chronos/user/Downloads", |
| 143 | "/home/chronos/user/log", |
| 144 | "/home/chronos/user/WebRTC Logs", |
| 145 | "/media", |
| 146 | "/opt/oem", |
| 147 | "/usr/share/chromeos-assets", |
| 148 | "/var/log", |
| 149 | }; |
| 150 | |
| 151 | base::FilePath temp_dir; |
Avi Drissman | ea15ea0 | 2018-05-07 18:55:12 | [diff] [blame] | 152 | if (base::PathService::Get(base::DIR_TEMP, &temp_dir)) |
Ken Rockot | 314714c | 2017-11-05 23:36:24 | [diff] [blame] | 153 | whitelist.push_back(temp_dir); |
| 154 | |
| 155 | // The actual location of "/home/chronos/user/Xyz" is the Xyz directory under |
| 156 | // the profile path ("/home/chronos/user' is a hard link to current primary |
| 157 | // logged in profile.) For the support of multi-profile sessions, we are |
| 158 | // switching to use explicit "$PROFILE_PATH/Xyz" path and here whitelist such |
| 159 | // access. |
| 160 | if (!profile_path.empty()) { |
| 161 | const base::FilePath downloads = profile_path.AppendASCII("Downloads"); |
| 162 | whitelist.push_back(downloads); |
| 163 | const base::FilePath webrtc_logs = profile_path.AppendASCII("WebRTC Logs"); |
| 164 | whitelist.push_back(webrtc_logs); |
| 165 | } |
| 166 | #elif defined(OS_ANDROID) |
| 167 | // Access to files in external storage is allowed. |
| 168 | base::FilePath external_storage_path; |
Avi Drissman | 9098f900 | 2018-05-04 00:11:52 | [diff] [blame] | 169 | base::PathService::Get(base::DIR_ANDROID_EXTERNAL_STORAGE, |
| 170 | &external_storage_path); |
Ken Rockot | 314714c | 2017-11-05 23:36:24 | [diff] [blame] | 171 | if (external_storage_path.IsParent(path)) |
| 172 | return true; |
| 173 | |
Xing Liu | b9456c1 | 2018-05-11 01:46:17 | [diff] [blame] | 174 | auto all_download_dirs = base::android::GetAllPrivateDownloadsDirectories(); |
| 175 | for (const auto& dir : all_download_dirs) |
| 176 | whitelist.push_back(dir); |
| 177 | |
Ken Rockot | 314714c | 2017-11-05 23:36:24 | [diff] [blame] | 178 | // Whitelist of other allowed directories. |
| 179 | static const base::FilePath::CharType* const kLocalAccessWhiteList[] = { |
| 180 | "/sdcard", "/mnt/sdcard", |
| 181 | }; |
| 182 | #endif |
| 183 | |
| 184 | for (const auto* whitelisted_path : kLocalAccessWhiteList) |
| 185 | whitelist.push_back(base::FilePath(whitelisted_path)); |
| 186 | |
| 187 | for (const auto& whitelisted_path : whitelist) { |
| 188 | // base::FilePath::operator== should probably handle trailing separators. |
| 189 | if (whitelisted_path == path.StripTrailingSeparators() || |
| 190 | whitelisted_path.IsParent(path)) { |
| 191 | return true; |
| 192 | } |
| 193 | } |
| 194 | |
| 195 | DVLOG(1) << "File access denied - " << path.value().c_str(); |
| 196 | return false; |
| 197 | #endif // !defined(OS_CHROMEOS) && !defined(OS_ANDROID) |
| 198 | } |
| 199 | |
[email protected] | d05ef99c | 2011-02-01 21:38:16 | [diff] [blame] | 200 | } // namespace |
[email protected] | ac03952 | 2010-06-15 16:39:44 | [diff] [blame] | 201 | |
[email protected] | 0651b81 | 2011-02-24 00:22:50 | [diff] [blame] | 202 | ChromeNetworkDelegate::ChromeNetworkDelegate( |
[email protected] | 5a38dfd | 2012-07-23 23:22:10 | [diff] [blame] | 203 | extensions::EventRouterForwarder* event_router, |
rajendrant | 14a5a85 | 2016-11-17 17:58:48 | [diff] [blame] | 204 | BooleanPrefMember* enable_referrers) |
ljusten | 98684cb7 | 2016-10-11 13:26:18 | [diff] [blame] | 205 | : profile_(nullptr), |
[email protected] | 6a5f77c3 | 2011-09-04 19:19:59 | [diff] [blame] | 206 | enable_referrers_(enable_referrers), |
ljusten | 98684cb7 | 2016-10-11 13:26:18 | [diff] [blame] | 207 | force_google_safe_search_(nullptr), |
| 208 | force_youtube_restrict_(nullptr), |
igorcov | 193d8ad3 | 2016-05-27 11:03:21 | [diff] [blame] | 209 | allowed_domains_for_apps_(nullptr), |
mkwst | 0513c9d | 2015-04-01 05:53:15 | [diff] [blame] | 210 | experimental_web_platform_features_enabled_( |
gayane | 0b46091c | 2016-04-07 21:01:05 | [diff] [blame] | 211 | base::CommandLine::ForCurrentProcess()->HasSwitch( |
| 212 | switches::kEnableExperimentalWebPlatformFeatures)), |
sclittle | ae932be | 2015-10-08 20:53:50 | [diff] [blame] | 213 | data_use_aggregator_(nullptr), |
| 214 | is_data_usage_off_the_record_(true) { |
[email protected] | 0a8db0d | 2011-04-13 15:15:40 | [diff] [blame] | 215 | DCHECK(enable_referrers); |
[email protected] | 4a2b623 | 2014-06-19 08:44:14 | [diff] [blame] | 216 | extensions_delegate_.reset( |
| 217 | ChromeExtensionsNetworkDelegate::Create(event_router)); |
[email protected] | 0651b81 | 2011-02-24 00:22:50 | [diff] [blame] | 218 | } |
| 219 | |
[email protected] | ac03952 | 2010-06-15 16:39:44 | [diff] [blame] | 220 | ChromeNetworkDelegate::~ChromeNetworkDelegate() {} |
| 221 | |
[email protected] | a09159a | 2012-11-29 12:51:48 | [diff] [blame] | 222 | void ChromeNetworkDelegate::set_extension_info_map( |
[email protected] | 38427a1 | 2013-11-09 17:34:20 | [diff] [blame] | 223 | extensions::InfoMap* extension_info_map) { |
[email protected] | 4a2b623 | 2014-06-19 08:44:14 | [diff] [blame] | 224 | extensions_delegate_->set_extension_info_map(extension_info_map); |
| 225 | } |
| 226 | |
| 227 | void ChromeNetworkDelegate::set_profile(void* profile) { |
| 228 | profile_ = profile; |
| 229 | extensions_delegate_->set_profile(profile); |
[email protected] | a09159a | 2012-11-29 12:51:48 | [diff] [blame] | 230 | } |
| 231 | |
| 232 | void ChromeNetworkDelegate::set_cookie_settings( |
droger | b171697 | 2015-06-30 09:04:09 | [diff] [blame] | 233 | content_settings::CookieSettings* cookie_settings) { |
[email protected] | a09159a | 2012-11-29 12:51:48 | [diff] [blame] | 234 | cookie_settings_ = cookie_settings; |
| 235 | } |
| 236 | |
sclittle | ae932be | 2015-10-08 20:53:50 | [diff] [blame] | 237 | void ChromeNetworkDelegate::set_data_use_aggregator( |
| 238 | data_usage::DataUseAggregator* data_use_aggregator, |
| 239 | bool is_data_usage_off_the_record) { |
| 240 | data_use_aggregator_ = data_use_aggregator; |
| 241 | is_data_usage_off_the_record_ = is_data_usage_off_the_record; |
| 242 | } |
| 243 | |
[email protected] | c4a7df8 | 2012-08-09 22:48:46 | [diff] [blame] | 244 | // static |
[email protected] | 9d8cfb68 | 2012-09-13 16:48:04 | [diff] [blame] | 245 | void ChromeNetworkDelegate::InitializePrefsOnUIThread( |
[email protected] | 0a8db0d | 2011-04-13 15:15:40 | [diff] [blame] | 246 | BooleanPrefMember* enable_referrers, |
[email protected] | d1208ba3 | 2012-11-08 11:10:33 | [diff] [blame] | 247 | BooleanPrefMember* force_google_safe_search, |
ljusten | 98684cb7 | 2016-10-11 13:26:18 | [diff] [blame] | 248 | IntegerPrefMember* force_youtube_restrict, |
igorcov | 193d8ad3 | 2016-05-27 11:03:21 | [diff] [blame] | 249 | StringPrefMember* allowed_domains_for_apps, |
[email protected] | 0a8db0d | 2011-04-13 15:15:40 | [diff] [blame] | 250 | PrefService* pref_service) { |
anujk.sharma | 2e02ce16 | 2015-04-29 23:10:02 | [diff] [blame] | 251 | DCHECK_CURRENTLY_ON(BrowserThread::UI); |
[email protected] | 96a5c34 | 2012-12-04 18:14:02 | [diff] [blame] | 252 | enable_referrers->Init(prefs::kEnableReferrers, pref_service); |
[email protected] | 6a1c98e0 | 2012-10-24 21:49:43 | [diff] [blame] | 253 | enable_referrers->MoveToThread( |
thestig | 529ad8a | 2016-07-08 20:30:12 | [diff] [blame] | 254 | BrowserThread::GetTaskRunnerForThread(BrowserThread::IO)); |
[email protected] | d1208ba3 | 2012-11-08 11:10:33 | [diff] [blame] | 255 | if (force_google_safe_search) { |
treib | 4e26f665 | 2014-12-01 14:34:18 | [diff] [blame] | 256 | force_google_safe_search->Init(prefs::kForceGoogleSafeSearch, pref_service); |
[email protected] | d1208ba3 | 2012-11-08 11:10:33 | [diff] [blame] | 257 | force_google_safe_search->MoveToThread( |
thestig | 529ad8a | 2016-07-08 20:30:12 | [diff] [blame] | 258 | BrowserThread::GetTaskRunnerForThread(BrowserThread::IO)); |
[email protected] | d1208ba3 | 2012-11-08 11:10:33 | [diff] [blame] | 259 | } |
ljusten | 98684cb7 | 2016-10-11 13:26:18 | [diff] [blame] | 260 | if (force_youtube_restrict) { |
| 261 | force_youtube_restrict->Init(prefs::kForceYouTubeRestrict, pref_service); |
| 262 | force_youtube_restrict->MoveToThread( |
thestig | 529ad8a | 2016-07-08 20:30:12 | [diff] [blame] | 263 | BrowserThread::GetTaskRunnerForThread(BrowserThread::IO)); |
treib | 4e26f665 | 2014-12-01 14:34:18 | [diff] [blame] | 264 | } |
igorcov | 193d8ad3 | 2016-05-27 11:03:21 | [diff] [blame] | 265 | if (allowed_domains_for_apps) { |
| 266 | allowed_domains_for_apps->Init(prefs::kAllowedDomainsForApps, pref_service); |
| 267 | allowed_domains_for_apps->MoveToThread( |
thestig | 529ad8a | 2016-07-08 20:30:12 | [diff] [blame] | 268 | BrowserThread::GetTaskRunnerForThread(BrowserThread::IO)); |
igorcov | 193d8ad3 | 2016-05-27 11:03:21 | [diff] [blame] | 269 | } |
[email protected] | 0a8db0d | 2011-04-13 15:15:40 | [diff] [blame] | 270 | } |
| 271 | |
[email protected] | 4875ba1 | 2011-03-30 22:31:51 | [diff] [blame] | 272 | int ChromeNetworkDelegate::OnBeforeURLRequest( |
[email protected] | 4c76d7c | 2011-04-15 19:14:12 | [diff] [blame] | 273 | net::URLRequest* request, |
[email protected] | 084262c | 2011-12-01 21:12:47 | [diff] [blame] | 274 | const net::CompletionCallback& callback, |
[email protected] | 4c76d7c | 2011-04-15 19:14:12 | [diff] [blame] | 275 | GURL* new_url) { |
[email protected] | 6a5f77c3 | 2011-09-04 19:19:59 | [diff] [blame] | 276 | |
[email protected] | 4a2b623 | 2014-06-19 08:44:14 | [diff] [blame] | 277 | extensions_delegate_->ForwardStartRequestStatus(request); |
[email protected] | 6baff0b5 | 2012-03-06 01:30:18 | [diff] [blame] | 278 | |
[email protected] | 0a8db0d | 2011-04-13 15:15:40 | [diff] [blame] | 279 | if (!enable_referrers_->GetValue()) |
[email protected] | 99ecf6e | 2013-04-10 22:46:13 | [diff] [blame] | 280 | request->SetReferrer(std::string()); |
[email protected] | d1208ba3 | 2012-11-08 11:10:33 | [diff] [blame] | 281 | |
treib | 4e26f665 | 2014-12-01 14:34:18 | [diff] [blame] | 282 | bool force_safe_search = |
treib | 4e26f665 | 2014-12-01 14:34:18 | [diff] [blame] | 283 | (force_google_safe_search_ && force_google_safe_search_->GetValue()); |
[email protected] | d1208ba3 | 2012-11-08 11:10:33 | [diff] [blame] | 284 | |
| 285 | net::CompletionCallback wrapped_callback = callback; |
| 286 | if (force_safe_search) { |
| 287 | wrapped_callback = base::Bind(&ForceGoogleSafeSearchCallbackWrapper, |
| 288 | callback, |
| 289 | base::Unretained(request), |
| 290 | base::Unretained(new_url)); |
| 291 | } |
| 292 | |
[email protected] | 4a2b623 | 2014-06-19 08:44:14 | [diff] [blame] | 293 | int rv = extensions_delegate_->OnBeforeURLRequest( |
| 294 | request, wrapped_callback, new_url); |
[email protected] | d1208ba3 | 2012-11-08 11:10:33 | [diff] [blame] | 295 | |
| 296 | if (force_safe_search && rv == net::OK && new_url->is_empty()) |
[email protected] | 184799df | 2014-07-22 16:03:24 | [diff] [blame] | 297 | safe_search_util::ForceGoogleSafeSearch(request, new_url); |
[email protected] | d1208ba3 | 2012-11-08 11:10:33 | [diff] [blame] | 298 | |
igorcov | 193d8ad3 | 2016-05-27 11:03:21 | [diff] [blame] | 299 | if (allowed_domains_for_apps_ && |
| 300 | !allowed_domains_for_apps_->GetValue().empty() && |
| 301 | request->url().DomainIs("google.com")) { |
| 302 | request->SetExtraRequestHeaderByName("X-GoogApps-Allowed-Domains", |
| 303 | allowed_domains_for_apps_->GetValue(), |
| 304 | true); |
| 305 | } |
| 306 | |
[email protected] | d1208ba3 | 2012-11-08 11:10:33 | [diff] [blame] | 307 | return rv; |
[email protected] | d05ef99c | 2011-02-01 21:38:16 | [diff] [blame] | 308 | } |
| 309 | |
ryansturm | 2343cb6 | 2016-06-15 01:09:00 | [diff] [blame] | 310 | int ChromeNetworkDelegate::OnBeforeStartTransaction( |
[email protected] | 636eccd | 2011-06-28 12:28:01 | [diff] [blame] | 311 | net::URLRequest* request, |
[email protected] | 084262c | 2011-12-01 21:12:47 | [diff] [blame] | 312 | const net::CompletionCallback& callback, |
[email protected] | 4c76d7c | 2011-04-15 19:14:12 | [diff] [blame] | 313 | net::HttpRequestHeaders* headers) { |
ljusten | 98684cb7 | 2016-10-11 13:26:18 | [diff] [blame] | 314 | if (force_youtube_restrict_) { |
| 315 | int value = force_youtube_restrict_->GetValue(); |
| 316 | static_assert(safe_search_util::YOUTUBE_RESTRICT_OFF == 0, |
| 317 | "OFF must be first"); |
| 318 | if (value > safe_search_util::YOUTUBE_RESTRICT_OFF && |
| 319 | value < safe_search_util::YOUTUBE_RESTRICT_COUNT) { |
| 320 | safe_search_util::ForceYouTubeRestrict(request, headers, |
| 321 | static_cast<safe_search_util::YouTubeRestrictMode>(value)); |
| 322 | } |
| 323 | } |
[email protected] | 184799df | 2014-07-22 16:03:24 | [diff] [blame] | 324 | |
ryansturm | 2343cb6 | 2016-06-15 01:09:00 | [diff] [blame] | 325 | return extensions_delegate_->OnBeforeStartTransaction(request, callback, |
| 326 | headers); |
[email protected] | ac03952 | 2010-06-15 16:39:44 | [diff] [blame] | 327 | } |
[email protected] | 8202d0c | 2011-02-23 08:31:14 | [diff] [blame] | 328 | |
ryansturm | 2343cb6 | 2016-06-15 01:09:00 | [diff] [blame] | 329 | void ChromeNetworkDelegate::OnStartTransaction( |
[email protected] | 5796dc94 | 2011-07-14 19:26:10 | [diff] [blame] | 330 | net::URLRequest* request, |
[email protected] | 783573b | 2011-05-13 11:05:15 | [diff] [blame] | 331 | const net::HttpRequestHeaders& headers) { |
ryansturm | 2343cb6 | 2016-06-15 01:09:00 | [diff] [blame] | 332 | extensions_delegate_->OnStartTransaction(request, headers); |
[email protected] | 82b4230 | 2011-04-20 16:28:16 | [diff] [blame] | 333 | } |
| 334 | |
[email protected] | ea8141e | 2011-10-05 13:12:51 | [diff] [blame] | 335 | int ChromeNetworkDelegate::OnHeadersReceived( |
| 336 | net::URLRequest* request, |
[email protected] | 084262c | 2011-12-01 21:12:47 | [diff] [blame] | 337 | const net::CompletionCallback& callback, |
[email protected] | 507af8f | 2012-10-20 00:42:32 | [diff] [blame] | 338 | const net::HttpResponseHeaders* original_response_headers, |
[email protected] | 5f71413 | 2014-03-26 10:41:16 | [diff] [blame] | 339 | scoped_refptr<net::HttpResponseHeaders>* override_response_headers, |
| 340 | GURL* allowed_unsafe_redirect_url) { |
[email protected] | 4a2b623 | 2014-06-19 08:44:14 | [diff] [blame] | 341 | return extensions_delegate_->OnHeadersReceived( |
[email protected] | 5f71413 | 2014-03-26 10:41:16 | [diff] [blame] | 342 | request, |
| 343 | callback, |
| 344 | original_response_headers, |
| 345 | override_response_headers, |
| 346 | allowed_unsafe_redirect_url); |
[email protected] | ea8141e | 2011-10-05 13:12:51 | [diff] [blame] | 347 | } |
| 348 | |
[email protected] | 31b2e5f | 2011-04-20 16:58:32 | [diff] [blame] | 349 | void ChromeNetworkDelegate::OnBeforeRedirect(net::URLRequest* request, |
| 350 | const GURL& new_location) { |
[email protected] | 45de676a | 2014-03-18 23:52:02 | [diff] [blame] | 351 | if (domain_reliability_monitor_) |
| 352 | domain_reliability_monitor_->OnBeforeRedirect(request); |
[email protected] | 4a2b623 | 2014-06-19 08:44:14 | [diff] [blame] | 353 | extensions_delegate_->OnBeforeRedirect(request, new_location); |
Dominic Battre | 5e8a1cd | 2018-01-02 16:16:58 | [diff] [blame] | 354 | variations::StripVariationHeaderIfNeeded(new_location, request); |
[email protected] | 31b2e5f | 2011-04-20 16:58:32 | [diff] [blame] | 355 | } |
| 356 | |
maksim.sisov | 1b83bb7 | 2016-10-07 06:07:23 | [diff] [blame] | 357 | void ChromeNetworkDelegate::OnResponseStarted(net::URLRequest* request, |
| 358 | int net_error) { |
| 359 | extensions_delegate_->OnResponseStarted(request, net_error); |
[email protected] | 8202d0c | 2011-02-23 08:31:14 | [diff] [blame] | 360 | } |
| 361 | |
sclittle | a133de0 | 2015-11-10 23:54:21 | [diff] [blame] | 362 | void ChromeNetworkDelegate::OnNetworkBytesReceived(net::URLRequest* request, |
| 363 | int64_t bytes_received) { |
brettw | ee486bb | 2016-12-08 17:56:34 | [diff] [blame] | 364 | #if !defined(OS_ANDROID) |
sclittle | ce72c48 | 2015-08-24 20:20:59 | [diff] [blame] | 365 | // Note: Currently, OnNetworkBytesReceived is only implemented for HTTP jobs, |
| 366 | // not FTP or other types, so those kinds of bytes will not be reported here. |
avi | 24d693f | 2016-08-06 18:03:52 | [diff] [blame] | 367 | task_manager::TaskManagerInterface::OnRawBytesRead(*request, bytes_received); |
brettw | ee486bb | 2016-12-08 17:56:34 | [diff] [blame] | 368 | #endif // !defined(OS_ANDROID) |
sclittle | ae932be | 2015-10-08 20:53:50 | [diff] [blame] | 369 | |
sclittle | a133de0 | 2015-11-10 23:54:21 | [diff] [blame] | 370 | ReportDataUsageStats(request, 0 /* tx_bytes */, bytes_received); |
sclittle | ae932be | 2015-10-08 20:53:50 | [diff] [blame] | 371 | } |
| 372 | |
sclittle | a133de0 | 2015-11-10 23:54:21 | [diff] [blame] | 373 | void ChromeNetworkDelegate::OnNetworkBytesSent(net::URLRequest* request, |
sclittle | ae932be | 2015-10-08 20:53:50 | [diff] [blame] | 374 | int64_t bytes_sent) { |
cburn | e9d2f361 | 2017-06-20 22:15:03 | [diff] [blame] | 375 | #if !defined(OS_ANDROID) |
| 376 | // Note: Currently, OnNetworkBytesSent is only implemented for HTTP jobs, |
| 377 | // not FTP or other types, so those kinds of bytes will not be reported here. |
| 378 | task_manager::TaskManagerInterface::OnRawBytesSent(*request, bytes_sent); |
| 379 | #endif // !defined(OS_ANDROID) |
| 380 | |
sclittle | a133de0 | 2015-11-10 23:54:21 | [diff] [blame] | 381 | ReportDataUsageStats(request, bytes_sent, 0 /* rx_bytes */); |
[email protected] | 8523ba5 | 2011-05-22 19:00:58 | [diff] [blame] | 382 | } |
| 383 | |
[email protected] | 9045b882 | 2012-01-13 20:35:35 | [diff] [blame] | 384 | void ChromeNetworkDelegate::OnCompleted(net::URLRequest* request, |
maksim.sisov | 1b83bb7 | 2016-10-07 06:07:23 | [diff] [blame] | 385 | bool started, |
| 386 | int net_error) { |
| 387 | DCHECK_NE(net::ERR_IO_PENDING, net_error); |
sclittle | 3c16159e | 2014-12-15 19:53:17 | [diff] [blame] | 388 | |
maksim.sisov | 1b83bb7 | 2016-10-07 06:07:23 | [diff] [blame] | 389 | // TODO(amohammadkhan): Verify that there is no double recording in data use |
| 390 | // of redirected requests. |
maksim.sisov | 1b83bb7 | 2016-10-07 06:07:23 | [diff] [blame] | 391 | RecordNetworkErrorHistograms(request, net_error); |
| 392 | |
maksim.sisov | 1b83bb7 | 2016-10-07 06:07:23 | [diff] [blame] | 393 | extensions_delegate_->OnCompleted(request, started, net_error); |
[email protected] | 45de676a | 2014-03-18 23:52:02 | [diff] [blame] | 394 | if (domain_reliability_monitor_) |
| 395 | domain_reliability_monitor_->OnCompleted(request, started); |
maksim.sisov | 1b83bb7 | 2016-10-07 06:07:23 | [diff] [blame] | 396 | extensions_delegate_->ForwardProxyErrors(request, net_error); |
[email protected] | 4a2b623 | 2014-06-19 08:44:14 | [diff] [blame] | 397 | extensions_delegate_->ForwardDoneRequestStatus(request); |
[email protected] | 8202d0c | 2011-02-23 08:31:14 | [diff] [blame] | 398 | } |
[email protected] | 4b50cb5 | 2011-03-10 00:29:37 | [diff] [blame] | 399 | |
[email protected] | 4875ba1 | 2011-03-30 22:31:51 | [diff] [blame] | 400 | void ChromeNetworkDelegate::OnURLRequestDestroyed(net::URLRequest* request) { |
[email protected] | 4a2b623 | 2014-06-19 08:44:14 | [diff] [blame] | 401 | extensions_delegate_->OnURLRequestDestroyed(request); |
[email protected] | 4875ba1 | 2011-03-30 22:31:51 | [diff] [blame] | 402 | } |
| 403 | |
[email protected] | 82a3767 | 2011-05-03 12:02:41 | [diff] [blame] | 404 | void ChromeNetworkDelegate::OnPACScriptError(int line_number, |
[email protected] | 439f1e3 | 2013-12-09 20:09:09 | [diff] [blame] | 405 | const base::string16& error) { |
[email protected] | 4a2b623 | 2014-06-19 08:44:14 | [diff] [blame] | 406 | extensions_delegate_->OnPACScriptError(line_number, error); |
[email protected] | 82a3767 | 2011-05-03 12:02:41 | [diff] [blame] | 407 | } |
[email protected] | 7efc582d | 2011-08-03 20:46:35 | [diff] [blame] | 408 | |
[email protected] | c2911d7 | 2011-10-03 22:16:36 | [diff] [blame] | 409 | net::NetworkDelegate::AuthRequiredResponse |
| 410 | ChromeNetworkDelegate::OnAuthRequired( |
[email protected] | 7efc582d | 2011-08-03 20:46:35 | [diff] [blame] | 411 | net::URLRequest* request, |
[email protected] | c2911d7 | 2011-10-03 22:16:36 | [diff] [blame] | 412 | const net::AuthChallengeInfo& auth_info, |
| 413 | const AuthCallback& callback, |
| 414 | net::AuthCredentials* credentials) { |
[email protected] | 4a2b623 | 2014-06-19 08:44:14 | [diff] [blame] | 415 | return extensions_delegate_->OnAuthRequired( |
| 416 | request, auth_info, callback, credentials); |
[email protected] | 7efc582d | 2011-08-03 20:46:35 | [diff] [blame] | 417 | } |
[email protected] | 9c8ae8c | 2012-03-09 13:13:35 | [diff] [blame] | 418 | |
[email protected] | 4c219e2 | 2012-05-05 19:41:04 | [diff] [blame] | 419 | bool ChromeNetworkDelegate::OnCanGetCookies( |
| 420 | const net::URLRequest& request, |
[email protected] | 9c8ae8c | 2012-03-09 13:13:35 | [diff] [blame] | 421 | const net::CookieList& cookie_list) { |
ljusten | 98684cb7 | 2016-10-11 13:26:18 | [diff] [blame] | 422 | // nullptr during tests, or when we're running in the system context. |
[email protected] | 5173de8b | 2013-06-02 21:16:02 | [diff] [blame] | 423 | if (!cookie_settings_.get()) |
[email protected] | 9c8ae8c | 2012-03-09 13:13:35 | [diff] [blame] | 424 | return true; |
| 425 | |
falken | 7169140 | 2017-01-27 03:38:00 | [diff] [blame] | 426 | bool allow = cookie_settings_->IsCookieAccessAllowed( |
Mike West | b85da8ed | 2017-08-10 14:16:46 | [diff] [blame] | 427 | request.url(), request.site_for_cookies()); |
[email protected] | 9c8ae8c | 2012-03-09 13:13:35 | [diff] [blame] | 428 | |
jam | 092d3be | 2016-09-27 15:56:36 | [diff] [blame] | 429 | const ResourceRequestInfo* info = ResourceRequestInfo::ForRequest(&request); |
| 430 | if (info) { |
[email protected] | 9c8ae8c | 2012-03-09 13:13:35 | [diff] [blame] | 431 | BrowserThread::PostTask( |
| 432 | BrowserThread::UI, FROM_HERE, |
tzik | 53a7b902 | 2017-04-24 11:14:48 | [diff] [blame] | 433 | base::BindOnce(&TabSpecificContentSettings::CookiesRead, |
| 434 | info->GetWebContentsGetterForRequest(), request.url(), |
Mike West | b85da8ed | 2017-08-10 14:16:46 | [diff] [blame] | 435 | request.site_for_cookies(), cookie_list, !allow)); |
[email protected] | 9c8ae8c | 2012-03-09 13:13:35 | [diff] [blame] | 436 | } |
| 437 | |
| 438 | return allow; |
| 439 | } |
| 440 | |
[email protected] | 4c219e2 | 2012-05-05 19:41:04 | [diff] [blame] | 441 | bool ChromeNetworkDelegate::OnCanSetCookie(const net::URLRequest& request, |
Victor Costan | 70f8551 | 2017-11-20 16:14:46 | [diff] [blame] | 442 | const net::CanonicalCookie& cookie, |
[email protected] | 4c219e2 | 2012-05-05 19:41:04 | [diff] [blame] | 443 | net::CookieOptions* options) { |
ljusten | 98684cb7 | 2016-10-11 13:26:18 | [diff] [blame] | 444 | // nullptr during tests, or when we're running in the system context. |
[email protected] | 5173de8b | 2013-06-02 21:16:02 | [diff] [blame] | 445 | if (!cookie_settings_.get()) |
[email protected] | 9c8ae8c | 2012-03-09 13:13:35 | [diff] [blame] | 446 | return true; |
| 447 | |
falken | 7169140 | 2017-01-27 03:38:00 | [diff] [blame] | 448 | bool allow = cookie_settings_->IsCookieAccessAllowed( |
Mike West | b85da8ed | 2017-08-10 14:16:46 | [diff] [blame] | 449 | request.url(), request.site_for_cookies()); |
[email protected] | 9c8ae8c | 2012-03-09 13:13:35 | [diff] [blame] | 450 | |
jam | 092d3be | 2016-09-27 15:56:36 | [diff] [blame] | 451 | const ResourceRequestInfo* info = ResourceRequestInfo::ForRequest(&request); |
| 452 | if (info) { |
[email protected] | 9c8ae8c | 2012-03-09 13:13:35 | [diff] [blame] | 453 | BrowserThread::PostTask( |
| 454 | BrowserThread::UI, FROM_HERE, |
tzik | 53a7b902 | 2017-04-24 11:14:48 | [diff] [blame] | 455 | base::BindOnce(&TabSpecificContentSettings::CookieChanged, |
| 456 | info->GetWebContentsGetterForRequest(), request.url(), |
Victor Costan | 70f8551 | 2017-11-20 16:14:46 | [diff] [blame] | 457 | request.site_for_cookies(), cookie, *options, !allow)); |
[email protected] | 9c8ae8c | 2012-03-09 13:13:35 | [diff] [blame] | 458 | } |
| 459 | |
| 460 | return allow; |
| 461 | } |
[email protected] | 4c219e2 | 2012-05-05 19:41:04 | [diff] [blame] | 462 | |
satorux | ddac044 | 2017-05-29 06:06:18 | [diff] [blame] | 463 | bool ChromeNetworkDelegate::OnCanAccessFile( |
| 464 | const net::URLRequest& request, |
| 465 | const base::FilePath& original_path, |
| 466 | const base::FilePath& absolute_path) const { |
satorux | d18e61a | 2017-06-08 06:38:46 | [diff] [blame] | 467 | if (g_access_to_all_files_enabled) |
[email protected] | d8e4f13 | 2012-09-06 04:28:05 | [diff] [blame] | 468 | return true; |
Ken Rockot | 314714c | 2017-11-05 23:36:24 | [diff] [blame] | 469 | return IsAccessAllowed(original_path, absolute_path, profile_path_); |
satorux | 7c536058 | 2017-01-27 07:24:29 | [diff] [blame] | 470 | } |
| 471 | |
| 472 | // static |
| 473 | bool ChromeNetworkDelegate::IsAccessAllowed( |
| 474 | const base::FilePath& path, |
| 475 | const base::FilePath& profile_path) { |
Ken Rockot | 314714c | 2017-11-05 23:36:24 | [diff] [blame] | 476 | return IsAccessAllowedInternal(path, profile_path); |
| 477 | } |
| 478 | |
| 479 | // static |
| 480 | bool ChromeNetworkDelegate::IsAccessAllowed( |
| 481 | const base::FilePath& path, |
| 482 | const base::FilePath& absolute_path, |
| 483 | const base::FilePath& profile_path) { |
| 484 | #if defined(OS_ANDROID) |
| 485 | // Android's whitelist relies on symbolic links (ex. /sdcard is whitelisted |
| 486 | // and commonly a symbolic link), thus do not check absolute paths. |
| 487 | return IsAccessAllowedInternal(path, profile_path); |
satorux | 7c536058 | 2017-01-27 07:24:29 | [diff] [blame] | 488 | #else |
Ken Rockot | 314714c | 2017-11-05 23:36:24 | [diff] [blame] | 489 | return (IsAccessAllowedInternal(path, profile_path) && |
| 490 | IsAccessAllowedInternal(absolute_path, profile_path)); |
[email protected] | d8e4f13 | 2012-09-06 04:28:05 | [diff] [blame] | 491 | #endif |
[email protected] | 4c219e2 | 2012-05-05 19:41:04 | [diff] [blame] | 492 | } |
[email protected] | a1d4ab07 | 2012-06-07 13:21:15 | [diff] [blame] | 493 | |
satorux | d18e61a | 2017-06-08 06:38:46 | [diff] [blame] | 494 | // static |
| 495 | void ChromeNetworkDelegate::EnableAccessToAllFilesForTesting(bool enabled) { |
| 496 | g_access_to_all_files_enabled = enabled; |
| 497 | } |
| 498 | |
[email protected] | e6d01765 | 2013-05-17 18:01:40 | [diff] [blame] | 499 | bool ChromeNetworkDelegate::OnCanEnablePrivacyMode( |
| 500 | const GURL& url, |
Mike West | b85da8ed | 2017-08-10 14:16:46 | [diff] [blame] | 501 | const GURL& site_for_cookies) const { |
ljusten | 98684cb7 | 2016-10-11 13:26:18 | [diff] [blame] | 502 | // nullptr during tests, or when we're running in the system context. |
[email protected] | 5173de8b | 2013-06-02 21:16:02 | [diff] [blame] | 503 | if (!cookie_settings_.get()) |
[email protected] | e6d01765 | 2013-05-17 18:01:40 | [diff] [blame] | 504 | return false; |
| 505 | |
Mike West | b85da8ed | 2017-08-10 14:16:46 | [diff] [blame] | 506 | return !cookie_settings_->IsCookieAccessAllowed(url, site_for_cookies); |
[email protected] | e6d01765 | 2013-05-17 18:01:40 | [diff] [blame] | 507 | } |
| 508 | |
estark | 7625d81 | 2015-10-12 20:10:41 | [diff] [blame] | 509 | bool ChromeNetworkDelegate::OnAreExperimentalCookieFeaturesEnabled() const { |
mkwst | 0513c9d | 2015-04-01 05:53:15 | [diff] [blame] | 510 | return experimental_web_platform_features_enabled_; |
| 511 | } |
| 512 | |
jochen | 0e3b3a6 | 2014-09-16 18:31:23 | [diff] [blame] | 513 | bool ChromeNetworkDelegate::OnCancelURLRequestWithPolicyViolatingReferrerHeader( |
| 514 | const net::URLRequest& request, |
| 515 | const GURL& target_url, |
| 516 | const GURL& referrer_url) const { |
jochen | 65227537 | 2015-01-16 11:35:27 | [diff] [blame] | 517 | ReportInvalidReferrerSend(target_url, referrer_url); |
jochen | 0e3b3a6 | 2014-09-16 18:31:23 | [diff] [blame] | 518 | return true; |
| 519 | } |
sclittle | a133de0 | 2015-11-10 23:54:21 | [diff] [blame] | 520 | |
juliatuttle | fcf4720 | 2017-05-23 15:53:02 | [diff] [blame] | 521 | bool ChromeNetworkDelegate::OnCanQueueReportingReport( |
| 522 | const url::Origin& origin) const { |
| 523 | if (!cookie_settings_) |
Douglas Creager | 81cad47 | 2018-05-17 14:34:09 | [diff] [blame^] | 524 | return false; |
juliatuttle | fcf4720 | 2017-05-23 15:53:02 | [diff] [blame] | 525 | |
| 526 | return cookie_settings_->IsCookieAccessAllowed(origin.GetURL(), |
| 527 | origin.GetURL()); |
| 528 | } |
| 529 | |
Douglas Creager | 7b07ea4 | 2018-02-27 21:08:08 | [diff] [blame] | 530 | void ChromeNetworkDelegate::OnCanSendReportingReports( |
| 531 | std::set<url::Origin> origins, |
| 532 | base::OnceCallback<void(std::set<url::Origin>)> result_callback) const { |
Douglas Creager | 81cad47 | 2018-05-17 14:34:09 | [diff] [blame^] | 533 | if (!reporting_permissions_checker_) { |
| 534 | origins.clear(); |
Douglas Creager | 7b07ea4 | 2018-02-27 21:08:08 | [diff] [blame] | 535 | std::move(result_callback).Run(std::move(origins)); |
| 536 | return; |
| 537 | } |
juliatuttle | fcf4720 | 2017-05-23 15:53:02 | [diff] [blame] | 538 | |
Douglas Creager | 81cad47 | 2018-05-17 14:34:09 | [diff] [blame^] | 539 | reporting_permissions_checker_->FilterReportingOrigins( |
| 540 | std::move(origins), std::move(result_callback)); |
juliatuttle | fcf4720 | 2017-05-23 15:53:02 | [diff] [blame] | 541 | } |
| 542 | |
| 543 | bool ChromeNetworkDelegate::OnCanSetReportingClient( |
| 544 | const url::Origin& origin, |
| 545 | const GURL& endpoint) const { |
| 546 | if (!cookie_settings_) |
Douglas Creager | 81cad47 | 2018-05-17 14:34:09 | [diff] [blame^] | 547 | return false; |
juliatuttle | fcf4720 | 2017-05-23 15:53:02 | [diff] [blame] | 548 | |
| 549 | return cookie_settings_->IsCookieAccessAllowed(endpoint, origin.GetURL()); |
| 550 | } |
| 551 | |
| 552 | bool ChromeNetworkDelegate::OnCanUseReportingClient( |
| 553 | const url::Origin& origin, |
| 554 | const GURL& endpoint) const { |
| 555 | if (!cookie_settings_) |
Douglas Creager | 81cad47 | 2018-05-17 14:34:09 | [diff] [blame^] | 556 | return false; |
juliatuttle | fcf4720 | 2017-05-23 15:53:02 | [diff] [blame] | 557 | |
| 558 | return cookie_settings_->IsCookieAccessAllowed(endpoint, origin.GetURL()); |
| 559 | } |
| 560 | |
sclittle | a133de0 | 2015-11-10 23:54:21 | [diff] [blame] | 561 | void ChromeNetworkDelegate::ReportDataUsageStats(net::URLRequest* request, |
| 562 | int64_t tx_bytes, |
| 563 | int64_t rx_bytes) { |
| 564 | if (!data_use_aggregator_) |
| 565 | return; |
| 566 | |
| 567 | if (is_data_usage_off_the_record_) { |
| 568 | data_use_aggregator_->ReportOffTheRecordDataUse(tx_bytes, rx_bytes); |
| 569 | return; |
| 570 | } |
| 571 | |
| 572 | data_use_aggregator_->ReportDataUse(request, tx_bytes, rx_bytes); |
| 573 | } |