mirror of
https://codeberg.org/kiss-community/repo
synced 2024-08-23 14:26:18 +00:00
589 lines
22 KiB
Diff
589 lines
22 KiB
Diff
# Disables various detections of Google hosts and functionality specific to them
|
|
|
|
--- a/net/base/url_util.cc
|
|
+++ b/net/base/url_util.cc
|
|
@@ -392,28 +392,6 @@ void GetIdentityFromURL(const GURL& url,
|
|
}
|
|
|
|
bool HasGoogleHost(const GURL& url) {
|
|
- static const char* kGoogleHostSuffixes[] = {
|
|
- ".google.com",
|
|
- ".youtube.com",
|
|
- ".gmail.com",
|
|
- ".doubleclick.net",
|
|
- ".gstatic.com",
|
|
- ".googlevideo.com",
|
|
- ".googleusercontent.com",
|
|
- ".googlesyndication.com",
|
|
- ".google-analytics.com",
|
|
- ".googleadservices.com",
|
|
- ".googleapis.com",
|
|
- ".ytimg.com",
|
|
- };
|
|
- base::StringPiece host = url.host_piece();
|
|
- for (const char* suffix : kGoogleHostSuffixes) {
|
|
- // Here it's possible to get away with faster case-sensitive comparisons
|
|
- // because the list above is all lowercase, and a GURL's host name will
|
|
- // always be canonicalized to lowercase as well.
|
|
- if (base::EndsWith(host, suffix, base::CompareCase::SENSITIVE))
|
|
- return true;
|
|
- }
|
|
return false;
|
|
}
|
|
|
|
--- a/components/variations/net/variations_http_headers.cc
|
|
+++ b/components/variations/net/variations_http_headers.cc
|
|
@@ -29,10 +29,6 @@ namespace variations {
|
|
|
|
namespace {
|
|
|
|
-// The name string for the header for variations information.
|
|
-// Note that prior to M33 this header was named X-Chrome-Variations.
|
|
-const char kClientDataHeader[] = "X-Client-Data";
|
|
-
|
|
// The result of checking if a URL should have variations headers appended.
|
|
// This enum is used to record UMA histogram values, and should not be
|
|
// reordered.
|
|
@@ -96,34 +92,7 @@ class VariationsHeaderHelper {
|
|
: VariationsHeaderHelper(request, null_url_request, variations_header) {}
|
|
|
|
bool AppendHeaderIfNeeded(const GURL& url, InIncognito incognito) {
|
|
- // Note the criteria for attaching client experiment headers:
|
|
- // 1. We only transmit to Google owned domains which can evaluate
|
|
- // experiments.
|
|
- // 1a. These include hosts which have a standard postfix such as:
|
|
- // *.doubleclick.net or *.googlesyndication.com or
|
|
- // exactly www.googleadservices.com or
|
|
- // international TLD domains *.google.<TLD> or *.youtube.<TLD>.
|
|
- // 2. Only transmit for non-Incognito profiles.
|
|
- // 3. For the X-Client-Data header, only include non-empty variation IDs.
|
|
- if ((incognito == InIncognito::kYes) || !ShouldAppendVariationsHeader(url))
|
|
- return false;
|
|
-
|
|
- if (variations_header_.empty())
|
|
- return false;
|
|
-
|
|
- if (resource_request_) {
|
|
- // Set the variations header to cors_exempt_headers rather than headers
|
|
- // to be exempted from CORS checks.
|
|
- resource_request_->cors_exempt_headers.SetHeaderIfMissing(
|
|
- kClientDataHeader, variations_header_);
|
|
- } else if (url_request_) {
|
|
- url_request_->SetExtraRequestHeaderByName(kClientDataHeader,
|
|
- variations_header_, false);
|
|
- } else {
|
|
- NOTREACHED();
|
|
- return false;
|
|
- }
|
|
- return true;
|
|
+ return false;
|
|
}
|
|
|
|
private:
|
|
@@ -189,14 +158,10 @@ void RemoveVariationsHeaderIfNeeded(
|
|
const net::RedirectInfo& redirect_info,
|
|
const network::ResourceResponseHead& response_head,
|
|
std::vector<std::string>* to_be_removed_headers) {
|
|
- if (!ShouldAppendVariationsHeader(redirect_info.new_url))
|
|
- to_be_removed_headers->push_back(kClientDataHeader);
|
|
}
|
|
|
|
void StripVariationsHeaderIfNeeded(const GURL& new_location,
|
|
net::URLRequest* request) {
|
|
- if (!ShouldAppendVariationsHeader(new_location))
|
|
- request->RemoveRequestHeaderByName(kClientDataHeader);
|
|
}
|
|
|
|
std::unique_ptr<network::SimpleURLLoader>
|
|
@@ -226,11 +191,11 @@ CreateSimpleURLLoaderWithVariationsHeade
|
|
}
|
|
|
|
bool IsVariationsHeader(const std::string& header_name) {
|
|
- return header_name == kClientDataHeader;
|
|
+ return false;
|
|
}
|
|
|
|
bool HasVariationsHeader(const network::ResourceRequest& request) {
|
|
- return request.cors_exempt_headers.HasHeader(kClientDataHeader);
|
|
+ return false;
|
|
}
|
|
|
|
bool ShouldAppendVariationsHeaderForTesting(const GURL& url) {
|
|
@@ -239,7 +204,6 @@ bool ShouldAppendVariationsHeaderForTest
|
|
|
|
void UpdateCorsExemptHeaderForVariations(
|
|
network::mojom::NetworkContextParams* params) {
|
|
- params->cors_exempt_header_list.push_back(kClientDataHeader);
|
|
}
|
|
|
|
} // namespace variations
|
|
--- a/chrome/browser/page_load_metrics/page_load_metrics_util.cc
|
|
+++ b/chrome/browser/page_load_metrics/page_load_metrics_util.cc
|
|
@@ -169,9 +169,7 @@ bool DidObserveLoadingBehaviorInAnyFrame
|
|
}
|
|
|
|
bool IsGoogleSearchHostname(const GURL& url) {
|
|
- base::Optional<std::string> result =
|
|
- page_load_metrics::GetGoogleHostnamePrefix(url);
|
|
- return result && result.value() == "www";
|
|
+ return false;
|
|
}
|
|
|
|
bool IsGoogleSearchResultUrl(const GURL& url) {
|
|
--- a/components/search_engines/template_url.cc
|
|
+++ b/components/search_engines/template_url.cc
|
|
@@ -505,11 +505,7 @@ base::string16 TemplateURLRef::SearchTer
|
|
bool TemplateURLRef::HasGoogleBaseURLs(
|
|
const SearchTermsData& search_terms_data) const {
|
|
ParseIfNecessary(search_terms_data);
|
|
- return std::any_of(replacements_.begin(), replacements_.end(),
|
|
- [](const Replacement& replacement) {
|
|
- return replacement.type == GOOGLE_BASE_URL ||
|
|
- replacement.type == GOOGLE_BASE_SUGGEST_URL;
|
|
- });
|
|
+ return false;
|
|
}
|
|
|
|
bool TemplateURLRef::ExtractSearchTermsFromURL(
|
|
--- a/components/google/core/common/google_util.cc
|
|
+++ b/components/google/core/common/google_util.cc
|
|
@@ -45,120 +45,16 @@ bool gUseMockLinkDoctorBaseURLForTesting
|
|
|
|
bool g_ignore_port_numbers = false;
|
|
|
|
-bool IsPathHomePageBase(base::StringPiece path) {
|
|
- return (path == "/") || (path == "/webhp");
|
|
-}
|
|
-
|
|
-// Removes a single trailing dot if present in |host|.
|
|
-void StripTrailingDot(base::StringPiece* host) {
|
|
- if (host->ends_with("."))
|
|
- host->remove_suffix(1);
|
|
-}
|
|
-
|
|
-// True if the given canonical |host| is "[www.]<domain_in_lower_case>.<TLD>"
|
|
-// with a valid TLD. If |subdomain_permission| is ALLOW_SUBDOMAIN, we check
|
|
-// against host "*.<domain_in_lower_case>.<TLD>" instead. Will return the TLD
|
|
-// string in |tld|, if specified and the |host| can be parsed.
|
|
-bool IsValidHostName(base::StringPiece host,
|
|
- base::StringPiece domain_in_lower_case,
|
|
- SubdomainPermission subdomain_permission,
|
|
- base::StringPiece* tld) {
|
|
- // Fast path to avoid searching the registry set.
|
|
- if (host.find(domain_in_lower_case) == base::StringPiece::npos)
|
|
- return false;
|
|
-
|
|
- size_t tld_length =
|
|
- net::registry_controlled_domains::GetCanonicalHostRegistryLength(
|
|
- host, net::registry_controlled_domains::EXCLUDE_UNKNOWN_REGISTRIES,
|
|
- net::registry_controlled_domains::EXCLUDE_PRIVATE_REGISTRIES);
|
|
- if ((tld_length == 0) || (tld_length == std::string::npos))
|
|
- return false;
|
|
-
|
|
- // Removes the tld and the preceding dot.
|
|
- base::StringPiece host_minus_tld =
|
|
- host.substr(0, host.length() - tld_length - 1);
|
|
-
|
|
- if (tld)
|
|
- *tld = host.substr(host.length() - tld_length);
|
|
-
|
|
- if (base::LowerCaseEqualsASCII(host_minus_tld, domain_in_lower_case))
|
|
- return true;
|
|
-
|
|
- if (subdomain_permission == ALLOW_SUBDOMAIN) {
|
|
- std::string dot_domain(".");
|
|
- domain_in_lower_case.AppendToString(&dot_domain);
|
|
- return base::EndsWith(host_minus_tld, dot_domain,
|
|
- base::CompareCase::INSENSITIVE_ASCII);
|
|
- }
|
|
-
|
|
- std::string www_domain("www.");
|
|
- domain_in_lower_case.AppendToString(&www_domain);
|
|
- return base::LowerCaseEqualsASCII(host_minus_tld, www_domain);
|
|
-}
|
|
-
|
|
-// True if |url| is a valid URL with HTTP or HTTPS scheme. If |port_permission|
|
|
-// is DISALLOW_NON_STANDARD_PORTS, this also requires |url| to use the standard
|
|
-// port for its scheme (80 for HTTP, 443 for HTTPS).
|
|
-bool IsValidURL(const GURL& url, PortPermission port_permission) {
|
|
- return url.is_valid() && url.SchemeIsHTTPOrHTTPS() &&
|
|
- (url.port().empty() || g_ignore_port_numbers ||
|
|
- (port_permission == ALLOW_NON_STANDARD_PORTS));
|
|
-}
|
|
-
|
|
-bool IsCanonicalHostGoogleHostname(base::StringPiece canonical_host,
|
|
- SubdomainPermission subdomain_permission) {
|
|
- const GURL& base_url(CommandLineGoogleBaseURL());
|
|
- if (base_url.is_valid() && (canonical_host == base_url.host_piece()))
|
|
- return true;
|
|
-
|
|
- base::StringPiece tld;
|
|
- if (!IsValidHostName(canonical_host, "google", subdomain_permission, &tld))
|
|
- return false;
|
|
-
|
|
- // Remove the trailing dot from tld if present, as for google domain it's the
|
|
- // same page.
|
|
- StripTrailingDot(&tld);
|
|
-
|
|
- static const base::NoDestructor<base::flat_set<base::StringPiece>>
|
|
- google_tlds(std::initializer_list<base::StringPiece>({GOOGLE_TLD_LIST}));
|
|
- return google_tlds->contains(tld);
|
|
-}
|
|
-
|
|
-// True if |url| is a valid URL with a host that is in the static list of
|
|
-// Google subdomains for google search, and an HTTP or HTTPS scheme. Requires
|
|
-// |url| to use the standard port for its scheme (80 for HTTP, 443 for HTTPS).
|
|
-bool IsGoogleSearchSubdomainUrl(const GURL& url) {
|
|
- if (!IsValidURL(url, PortPermission::DISALLOW_NON_STANDARD_PORTS))
|
|
- return false;
|
|
-
|
|
- base::StringPiece host(url.host_piece());
|
|
- StripTrailingDot(&host);
|
|
-
|
|
- static const base::NoDestructor<base::flat_set<base::StringPiece>>
|
|
- google_subdomains(std::initializer_list<base::StringPiece>(
|
|
- {"ipv4.google.com", "ipv6.google.com"}));
|
|
-
|
|
- return google_subdomains->contains(host);
|
|
-}
|
|
-
|
|
} // namespace
|
|
|
|
// Global functions -----------------------------------------------------------
|
|
|
|
bool HasGoogleSearchQueryParam(base::StringPiece str) {
|
|
- url::Component query(0, static_cast<int>(str.length())), key, value;
|
|
- while (url::ExtractQueryKeyValue(str.data(), &query, &key, &value)) {
|
|
- base::StringPiece key_str = str.substr(key.begin, key.len);
|
|
- if (key_str == "q" || key_str == "as_q")
|
|
- return true;
|
|
- }
|
|
return false;
|
|
}
|
|
|
|
GURL LinkDoctorBaseURL() {
|
|
- if (gUseMockLinkDoctorBaseURLForTesting)
|
|
- return GURL("http://mock.linkdoctor.url/for?testing");
|
|
- return GURL(LINKDOCTOR_SERVER_REQUEST_URL);
|
|
+ return GURL();
|
|
}
|
|
|
|
void SetMockLinkDoctorBaseURLForTesting() {
|
|
@@ -172,162 +68,53 @@ std::string GetGoogleLocale(const std::s
|
|
|
|
GURL AppendGoogleLocaleParam(const GURL& url,
|
|
const std::string& application_locale) {
|
|
- return net::AppendQueryParameter(url, "hl",
|
|
- GetGoogleLocale(application_locale));
|
|
+ return url;
|
|
}
|
|
|
|
std::string GetGoogleCountryCode(const GURL& google_homepage_url) {
|
|
- base::StringPiece google_hostname = google_homepage_url.host_piece();
|
|
- // TODO(igorcov): This needs a fix for case when the host has a trailing dot,
|
|
- // like "google.com./". https://crbug.com/720295.
|
|
- const size_t last_dot = google_hostname.find_last_of('.');
|
|
- if (last_dot == std::string::npos)
|
|
- return std::string();
|
|
- base::StringPiece country_code = google_hostname.substr(last_dot + 1);
|
|
- // Assume the com TLD implies the US.
|
|
- if (country_code == "com")
|
|
- return "us";
|
|
- // Google uses the Unicode Common Locale Data Repository (CLDR), and the CLDR
|
|
- // code for the UK is "gb".
|
|
- if (country_code == "uk")
|
|
- return "gb";
|
|
- // Catalonia does not have a CLDR country code, since it's a region in Spain,
|
|
- // so use Spain instead.
|
|
- if (country_code == "cat")
|
|
- return "es";
|
|
- return country_code.as_string();
|
|
+ return "nolocale";
|
|
}
|
|
|
|
GURL GetGoogleSearchURL(const GURL& google_homepage_url) {
|
|
- // To transform the homepage URL into the corresponding search URL, add the
|
|
- // "search" and the "q=" query string.
|
|
- GURL::Replacements replacements;
|
|
- replacements.SetPathStr("search");
|
|
- replacements.SetQueryStr("q=");
|
|
- return google_homepage_url.ReplaceComponents(replacements);
|
|
+ return google_homepage_url;
|
|
}
|
|
|
|
const GURL& CommandLineGoogleBaseURL() {
|
|
- // Unit tests may add command-line flags after the first call to this
|
|
- // function, so we don't simply initialize a static |base_url| directly and
|
|
- // then unconditionally return it.
|
|
- static base::NoDestructor<std::string> switch_value;
|
|
static base::NoDestructor<GURL> base_url;
|
|
- std::string current_switch_value(
|
|
- base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
|
|
- switches::kGoogleBaseURL));
|
|
- if (current_switch_value != *switch_value) {
|
|
- *switch_value = current_switch_value;
|
|
- *base_url = url_formatter::FixupURL(*switch_value, std::string());
|
|
- if (!base_url->is_valid() || base_url->has_query() || base_url->has_ref())
|
|
- *base_url = GURL();
|
|
- }
|
|
+ *base_url = GURL();
|
|
return *base_url;
|
|
}
|
|
|
|
bool StartsWithCommandLineGoogleBaseURL(const GURL& url) {
|
|
- const GURL& base_url(CommandLineGoogleBaseURL());
|
|
- return base_url.is_valid() &&
|
|
- base::StartsWith(url.possibly_invalid_spec(), base_url.spec(),
|
|
- base::CompareCase::SENSITIVE);
|
|
+ return false;
|
|
}
|
|
|
|
bool IsGoogleHostname(base::StringPiece host,
|
|
SubdomainPermission subdomain_permission) {
|
|
- url::CanonHostInfo host_info;
|
|
- return IsCanonicalHostGoogleHostname(net::CanonicalizeHost(host, &host_info),
|
|
- subdomain_permission);
|
|
+ return false;
|
|
}
|
|
|
|
bool IsGoogleDomainUrl(const GURL& url,
|
|
SubdomainPermission subdomain_permission,
|
|
PortPermission port_permission) {
|
|
- return IsValidURL(url, port_permission) &&
|
|
- IsCanonicalHostGoogleHostname(url.host_piece(), subdomain_permission);
|
|
+ return false;
|
|
}
|
|
|
|
bool IsGoogleHomePageUrl(const GURL& url) {
|
|
- // First check to see if this has a Google domain.
|
|
- if (!IsGoogleDomainUrl(url, DISALLOW_SUBDOMAIN,
|
|
- DISALLOW_NON_STANDARD_PORTS) &&
|
|
- !IsGoogleSearchSubdomainUrl(url)) {
|
|
- return false;
|
|
- }
|
|
-
|
|
- // Make sure the path is a known home page path.
|
|
- base::StringPiece path(url.path_piece());
|
|
- return IsPathHomePageBase(path) ||
|
|
- base::StartsWith(path, "/ig", base::CompareCase::INSENSITIVE_ASCII);
|
|
+ return false;
|
|
}
|
|
|
|
bool IsGoogleSearchUrl(const GURL& url) {
|
|
- // First check to see if this has a Google domain.
|
|
- if (!IsGoogleDomainUrl(url, DISALLOW_SUBDOMAIN,
|
|
- DISALLOW_NON_STANDARD_PORTS) &&
|
|
- !IsGoogleSearchSubdomainUrl(url)) {
|
|
- return false;
|
|
- }
|
|
-
|
|
- // Make sure the path is a known search path.
|
|
- base::StringPiece path(url.path_piece());
|
|
- bool is_home_page_base = IsPathHomePageBase(path);
|
|
- if (!is_home_page_base && (path != "/search"))
|
|
- return false;
|
|
-
|
|
- // Check for query parameter in URL parameter and hash fragment, depending on
|
|
- // the path type.
|
|
- return HasGoogleSearchQueryParam(url.ref_piece()) ||
|
|
- (!is_home_page_base && HasGoogleSearchQueryParam(url.query_piece()));
|
|
+ return false;
|
|
}
|
|
|
|
bool IsYoutubeDomainUrl(const GURL& url,
|
|
SubdomainPermission subdomain_permission,
|
|
PortPermission port_permission) {
|
|
- return IsValidURL(url, port_permission) &&
|
|
- IsValidHostName(url.host_piece(), "youtube", subdomain_permission,
|
|
- nullptr);
|
|
+ return false;
|
|
}
|
|
|
|
bool IsGoogleAssociatedDomainUrl(const GURL& url) {
|
|
- if (IsGoogleDomainUrl(url, ALLOW_SUBDOMAIN, ALLOW_NON_STANDARD_PORTS))
|
|
- return true;
|
|
-
|
|
- if (IsYoutubeDomainUrl(url, ALLOW_SUBDOMAIN, ALLOW_NON_STANDARD_PORTS))
|
|
- return true;
|
|
-
|
|
- // Some domains don't have international TLD extensions, so testing for them
|
|
- // is very straightforward.
|
|
- static const char* kSuffixesToSetHeadersFor[] = {
|
|
- ".android.com",
|
|
- ".doubleclick.com",
|
|
- ".doubleclick.net",
|
|
- ".ggpht.com",
|
|
- ".googleadservices.com",
|
|
- ".googleapis.com",
|
|
- ".googlesyndication.com",
|
|
- ".googleusercontent.com",
|
|
- ".googlevideo.com",
|
|
- ".gstatic.com",
|
|
- ".litepages.googlezip.net",
|
|
- ".ytimg.com",
|
|
- };
|
|
- const std::string host = url.host();
|
|
- for (size_t i = 0; i < base::size(kSuffixesToSetHeadersFor); ++i) {
|
|
- if (base::EndsWith(host, kSuffixesToSetHeadersFor[i],
|
|
- base::CompareCase::INSENSITIVE_ASCII)) {
|
|
- return true;
|
|
- }
|
|
- }
|
|
-
|
|
- // Exact hostnames in lowercase to set headers for.
|
|
- static const char* kHostsToSetHeadersFor[] = {
|
|
- "googleweblight.com",
|
|
- };
|
|
- for (size_t i = 0; i < base::size(kHostsToSetHeadersFor); ++i) {
|
|
- if (base::LowerCaseEqualsASCII(host, kHostsToSetHeadersFor[i]))
|
|
- return true;
|
|
- }
|
|
-
|
|
return false;
|
|
}
|
|
|
|
--- a/chrome/common/page_load_metrics/page_load_metrics_util.cc
|
|
+++ b/chrome/common/page_load_metrics/page_load_metrics_util.cc
|
|
@@ -12,38 +12,7 @@
|
|
namespace page_load_metrics {
|
|
|
|
base::Optional<std::string> GetGoogleHostnamePrefix(const GURL& url) {
|
|
- const size_t registry_length =
|
|
- net::registry_controlled_domains::GetRegistryLength(
|
|
- url,
|
|
-
|
|
- // Do not include unknown registries (registries that don't have any
|
|
- // matches in effective TLD names).
|
|
- net::registry_controlled_domains::EXCLUDE_UNKNOWN_REGISTRIES,
|
|
-
|
|
- // Do not include private registries, such as appspot.com. We don't
|
|
- // want to match URLs like www.google.appspot.com.
|
|
- net::registry_controlled_domains::EXCLUDE_PRIVATE_REGISTRIES);
|
|
-
|
|
- const base::StringPiece hostname = url.host_piece();
|
|
- if (registry_length == 0 || registry_length == std::string::npos ||
|
|
- registry_length >= hostname.length()) {
|
|
- return base::Optional<std::string>();
|
|
- }
|
|
-
|
|
- // Removes the tld and the preceding dot.
|
|
- const base::StringPiece hostname_minus_registry =
|
|
- hostname.substr(0, hostname.length() - (registry_length + 1));
|
|
-
|
|
- if (hostname_minus_registry == "google")
|
|
- return std::string("");
|
|
-
|
|
- if (!base::EndsWith(hostname_minus_registry, ".google",
|
|
- base::CompareCase::INSENSITIVE_ASCII)) {
|
|
- return base::Optional<std::string>();
|
|
- }
|
|
-
|
|
- return std::string(hostname_minus_registry.substr(
|
|
- 0, hostname_minus_registry.length() - strlen(".google")));
|
|
+ return base::Optional<std::string>();
|
|
}
|
|
|
|
bool IsGoogleHostname(const GURL& url) {
|
|
--- a/chrome/common/google_url_loader_throttle.cc
|
|
+++ b/chrome/common/google_url_loader_throttle.cc
|
|
@@ -8,10 +8,6 @@
|
|
#include "components/variations/net/variations_http_headers.h"
|
|
#include "services/network/public/cpp/features.h"
|
|
|
|
-#if BUILDFLAG(ENABLE_EXTENSIONS)
|
|
-#include "extensions/common/extension_urls.h"
|
|
-#endif
|
|
-
|
|
GoogleURLLoaderThrottle::GoogleURLLoaderThrottle(
|
|
bool is_off_the_record,
|
|
chrome::mojom::DynamicParams dynamic_params)
|
|
@@ -25,36 +21,6 @@ void GoogleURLLoaderThrottle::DetachFrom
|
|
void GoogleURLLoaderThrottle::WillStartRequest(
|
|
network::ResourceRequest* request,
|
|
bool* defer) {
|
|
- variations::AppendVariationsHeaderWithCustomValue(
|
|
- request->url,
|
|
- is_off_the_record_ ? variations::InIncognito::kYes
|
|
- : variations::InIncognito::kNo,
|
|
- dynamic_params_.variation_ids_header, request);
|
|
-
|
|
- if (dynamic_params_.force_safe_search) {
|
|
- GURL new_url;
|
|
- safe_search_util::ForceGoogleSafeSearch(request->url, &new_url);
|
|
- if (!new_url.is_empty())
|
|
- request->url = new_url;
|
|
- }
|
|
-
|
|
- static_assert(safe_search_util::YOUTUBE_RESTRICT_OFF == 0,
|
|
- "OFF must be first");
|
|
- if (dynamic_params_.youtube_restrict >
|
|
- safe_search_util::YOUTUBE_RESTRICT_OFF &&
|
|
- dynamic_params_.youtube_restrict <
|
|
- safe_search_util::YOUTUBE_RESTRICT_COUNT) {
|
|
- safe_search_util::ForceYouTubeRestrict(
|
|
- request->url, &request->headers,
|
|
- static_cast<safe_search_util::YouTubeRestrictMode>(
|
|
- dynamic_params_.youtube_restrict));
|
|
- }
|
|
-
|
|
- if (!dynamic_params_.allowed_domains_for_apps.empty() &&
|
|
- request->url.DomainIs("google.com")) {
|
|
- request->headers.SetHeader(safe_search_util::kGoogleAppsAllowedDomains,
|
|
- dynamic_params_.allowed_domains_for_apps);
|
|
- }
|
|
}
|
|
|
|
void GoogleURLLoaderThrottle::WillRedirectRequest(
|
|
@@ -63,33 +29,6 @@ void GoogleURLLoaderThrottle::WillRedire
|
|
bool* /* defer */,
|
|
std::vector<std::string>* to_be_removed_headers,
|
|
net::HttpRequestHeaders* modified_headers) {
|
|
- variations::RemoveVariationsHeaderIfNeeded(*redirect_info, response_head,
|
|
- to_be_removed_headers);
|
|
-
|
|
- // URLLoaderThrottles can only change the redirect URL when the network
|
|
- // service is enabled. The non-network service path handles this in
|
|
- // ChromeNetworkDelegate.
|
|
- if (dynamic_params_.force_safe_search &&
|
|
- base::FeatureList::IsEnabled(network::features::kNetworkService)) {
|
|
- safe_search_util::ForceGoogleSafeSearch(redirect_info->new_url,
|
|
- &redirect_info->new_url);
|
|
- }
|
|
-
|
|
- if (dynamic_params_.youtube_restrict >
|
|
- safe_search_util::YOUTUBE_RESTRICT_OFF &&
|
|
- dynamic_params_.youtube_restrict <
|
|
- safe_search_util::YOUTUBE_RESTRICT_COUNT) {
|
|
- safe_search_util::ForceYouTubeRestrict(
|
|
- redirect_info->new_url, modified_headers,
|
|
- static_cast<safe_search_util::YouTubeRestrictMode>(
|
|
- dynamic_params_.youtube_restrict));
|
|
- }
|
|
-
|
|
- if (!dynamic_params_.allowed_domains_for_apps.empty() &&
|
|
- redirect_info->new_url.DomainIs("google.com")) {
|
|
- modified_headers->SetHeader(safe_search_util::kGoogleAppsAllowedDomains,
|
|
- dynamic_params_.allowed_domains_for_apps);
|
|
- }
|
|
}
|
|
|
|
#if BUILDFLAG(ENABLE_EXTENSIONS)
|
|
@@ -97,17 +36,5 @@ void GoogleURLLoaderThrottle::WillProces
|
|
const GURL& response_url,
|
|
network::ResourceResponseHead* response_head,
|
|
bool* defer) {
|
|
- // Built-in additional protection for the chrome web store origin.
|
|
- GURL webstore_url(extension_urls::GetWebstoreLaunchURL());
|
|
- if (response_url.SchemeIsHTTPOrHTTPS() &&
|
|
- response_url.DomainIs(webstore_url.host_piece())) {
|
|
- if (response_head && response_head->headers &&
|
|
- !response_head->headers->HasHeaderValue("x-frame-options", "deny") &&
|
|
- !response_head->headers->HasHeaderValue("x-frame-options",
|
|
- "sameorigin")) {
|
|
- response_head->headers->RemoveHeader("x-frame-options");
|
|
- response_head->headers->AddHeader("x-frame-options: sameorigin");
|
|
- }
|
|
- }
|
|
}
|
|
#endif
|