Skip to content

GitLab

T
tangled
Commit 50ed8305 authored by Kunihiko Sakamoto's avatar Kunihiko Sakamoto Committed by Commit Bot
Browse files
Options

Remove Origin Trial code for Signed HTTP Exchange 

This removes SignedHTTPExchangeOriginTrial feature, and its accompanied
SignedHTTPExchangeAcceptHeader feature which is used for the Accept
header opt-in.

Bug: 827939,887201
Change-Id: I0794b886715a63cb6ac43c37a0adaddeb31f2af8
Reviewed-on: https://chromium-review.googlesource.com/c/1481181Reviewed-by: default avatarKinuko Yasuda <kinuko@chromium.org>
Reviewed-by: default avatarTsuyoshi Horo <horo@chromium.org>
Reviewed-by: default avatarKouhei Ueno <kouhei@chromium.org>
Commit-Queue: Kunihiko Sakamoto <ksakamoto@chromium.org>
Cr-Commit-Position: refs/heads/master@{#634519}
parent 5bcdd1ed
Hide whitespace changes
Inline Side-by-side
Showing with 89 additions and 677 deletions
content/browser/BUILD.gn
View file @ 50ed8305
......@@ -1825,8 +1825,6 @@ jumbo_source_set("browser") {
"web_contents/web_drag_utils_win.h",
"web_package/http_structured_header.cc",
"web_package/http_structured_header.h",
"web_package/origins_list.cc",
"web_package/origins_list.h",
"web_package/signed_exchange_cert_fetcher.cc",
"web_package/signed_exchange_cert_fetcher.h",
"web_package/signed_exchange_cert_fetcher_factory.cc",
......
content/browser/loader/navigation_url_loader_impl.cc
View file @ 50ed8305
......@@ -231,8 +231,7 @@ std::unique_ptr<network::ResourceRequest> CreateResourceRequest(
request_info->begin_params->headers);
std::string accept_value = network::kFrameAcceptHeader;
if (signed_exchange_utils::ShouldAdvertiseAcceptHeader(
url::Origin::Create(request_info->common_params.url))) {
if (signed_exchange_utils::IsSignedExchangeHandlingEnabled()) {
DCHECK(!accept_value.empty());
accept_value.append(kAcceptHeaderSignedExchangeSuffix);
}
......@@ -1104,25 +1103,6 @@ class NavigationURLLoaderImpl::URLLoaderRequestController
url_loader_removed_headers_ = removed_headers;
url_loader_modified_headers_ = modified_headers;
if (signed_exchange_utils::NeedToCheckRedirectedURLForAcceptHeader()) {
// Currently we send the SignedExchange accept header only for the limited
// origins when SignedHTTPExchangeOriginTrial feature is enabled without
// SignedHTTPExchange feature. We need to put the SignedExchange accept
// header on when redirecting to the origins in the OriginList of
// SignedHTTPExchangeAcceptHeader field trial, and need to remove it when
// redirecting to out of the OriginList.
std::string accept_value = network::kFrameAcceptHeader;
if (signed_exchange_utils::ShouldAdvertiseAcceptHeader(
url::Origin::Create(resource_request_->url))) {
DCHECK(!accept_value.empty());
accept_value.append(kAcceptHeaderSignedExchangeSuffix);
}
url_loader_modified_headers_.SetHeader(network::kAcceptHeader,
accept_value);
resource_request_->headers.SetHeader(network::kAcceptHeader,
accept_value);
}
Restart();
}
......
content/browser/loader/prefetch_url_loader.cc
View file @ 50ed8305
......@@ -50,9 +50,8 @@ PrefetchURLLoader::PrefetchURLLoader(
std::move(signed_exchange_prefetch_metric_recorder)) {
DCHECK(network_loader_factory_);
if (signed_exchange_utils::ShouldAdvertiseAcceptHeader(
url::Origin::Create(resource_request_.url))) {
// Set the SignedExchange accept header only for the limited origins.
if (signed_exchange_utils::IsSignedExchangeHandlingEnabled()) {
// Set the SignedExchange accept header.
// (https://wicg.github.io/webpackage/draft-yasskin-http-origin-signed-responses.html#internet-media-type-applicationsigned-exchange).
resource_request_.headers.SetHeader(
network::kAcceptHeader, kSignedExchangeEnabledAcceptHeaderForPrefetch);
......@@ -85,25 +84,9 @@ void PrefetchURLLoader::FollowRedirect(
return;
}
net::HttpRequestHeaders modified_request_headers_for_accept;
if (signed_exchange_utils::NeedToCheckRedirectedURLForAcceptHeader()) {
// Currently we send the SignedExchange accept header only for the limited
// origins when SignedHTTPExchangeOriginTrial feature is enabled without
// SignedHTTPExchange feature. So need to update the accept header by
// checking the new URL when redirected.
if (signed_exchange_utils::ShouldAdvertiseAcceptHeader(
url::Origin::Create(resource_request_.url))) {
modified_request_headers_for_accept.SetHeader(
network::kAcceptHeader,
kSignedExchangeEnabledAcceptHeaderForPrefetch);
} else {
modified_request_headers_for_accept.SetHeader(
network::kAcceptHeader, network::kDefaultAcceptHeader);
}
}
DCHECK(loader_);
loader_->FollowRedirect(removed_headers, modified_request_headers_for_accept,
loader_->FollowRedirect(removed_headers,
net::HttpRequestHeaders() /* modified_headers */,
base::nullopt);
}
......
content/browser/web_package/origins_list.cc deleted 100644 → 0
View file @ 5bcdd1ed
// Copyright 2018 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 "content/browser/web_package/origins_list.h"
#include "base/strings/string_split.h"
#include "url/gurl.h"
namespace content {
namespace signed_exchange_utils {
constexpr char kSubdomainMatchPrefix[] = "*.";
OriginsList::OriginsList() = default;
OriginsList::OriginsList(base::StringPiece str) {
std::vector<base::StringPiece> elements = base::SplitStringPiece(
str, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
for (base::StringPiece element : elements) {
bool subdomain_match = false;
if (base::StartsWith(element, kSubdomainMatchPrefix,
base::CompareCase::SENSITIVE)) {
subdomain_match = true;
element.remove_prefix(sizeof(kSubdomainMatchPrefix) - 1);
}
if (base::StartsWith(element,
"https:", base::CompareCase::INSENSITIVE_ASCII)) {
LOG(ERROR) << "OriginsList entry should omit https scheme: \"" << element
<< "\"";
continue;
}
std::string url_str("https://");
element.AppendToString(&url_str);
GURL url(url_str);
if (!url.is_valid()) {
LOG(ERROR) << "Failed to parse an OriginsList entry to a valid Origin: \""
<< element << "\"";
continue;
}
DCHECK(url.SchemeIs("https"));
url::Origin origin = url::Origin::Create(url);
if (subdomain_match) {
subdomain_match_origins_.push_back(origin);
} else {
exact_match_origins_.insert(origin);
}
}
}
OriginsList::OriginsList(OriginsList&&) = default;
OriginsList::~OriginsList() = default;
bool OriginsList::IsEmpty() const {
return exact_match_origins_.empty() && subdomain_match_origins_.empty();
}
bool OriginsList::Match(const url::Origin& origin) const {
// OriginsList only contains HTTPS scheme origins.
if (origin.scheme() != url::kHttpsScheme) {
return false;
}
if (exact_match_origins_.find(origin) != exact_match_origins_.end()) {
return true;
}
for (const auto& subdomain_match_origin : subdomain_match_origins_) {
if (origin.DomainIs(subdomain_match_origin.host()) &&
origin.port() == subdomain_match_origin.port()) {
return true;
}
}
return false;
}
} // namespace signed_exchange_utils
} // namespace content
content/browser/web_package/origins_list.h deleted 100644 → 0
View file @ 5bcdd1ed
// Copyright 2018 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.
#ifndef CONTENT_BROWSER_WEB_PACKAGE_ORIGINS_LIST_H_
#define CONTENT_BROWSER_WEB_PACKAGE_ORIGINS_LIST_H_
#include <vector>
#include "base/containers/flat_set.h"
#include "base/strings/string_piece.h"
#include "content/common/content_export.h"
#include "url/origin.h"
namespace content {
namespace signed_exchange_utils {
// OriginsList can query if a particular origin |Match|.
// OriginsList can only match HTTPS origins.
class CONTENT_EXPORT OriginsList {
public:
OriginsList();
// Creates an OriginsList from comma-separated list of hosts.
//
// Entries starting with "*." will match with subdomains.
//
// For example, "example.com,*.google.com" will create an
// OriginsList that match exactly "example.com" but not its
// subdomains, and all subdomains of "google.com".
//
// Note: Entries should NOT start with "https://", but start from hostname.
explicit OriginsList(base::StringPiece str);
OriginsList(OriginsList&&);
~OriginsList();
// Returns true when |this| has an empty list to match
// (i.e. no origins would match).
bool IsEmpty() const;
bool Match(const url::Origin& origin) const;
private:
base::flat_set<url::Origin> exact_match_origins_;
std::vector<url::Origin> subdomain_match_origins_;
};
} // namespace signed_exchange_utils
} // namespace content
#endif // CONTENT_BROWSER_WEB_PACKAGE_ORIGINS_LIST_H_
content/browser/web_package/origins_list_unittest.cc deleted 100644 → 0
View file @ 5bcdd1ed
// Copyright 2018 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 "content/browser/web_package/origins_list.h"
#include "base/callback.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "url/gurl.h"
#include "url/origin.h"
namespace content {
namespace signed_exchange_utils {
TEST(OriginsList, IsEmpty) {
OriginsList origins_list;
EXPECT_TRUE(origins_list.IsEmpty());
}
TEST(OriginsList, ExactMatch) {
OriginsList origins_list(
"example.com,test.example.com,https://invalid.entry,example.net:1234");
EXPECT_FALSE(origins_list.IsEmpty());
static constexpr const char* kShouldMatchList[] = {
"https://example.com", "https://test.example.com",
"https://example.net:1234",
};
for (const char* should_match : kShouldMatchList) {
EXPECT_TRUE(origins_list.Match(url::Origin::Create(GURL(should_match))))
<< "OriginList should match url: " << should_match;
}
static constexpr const char* kShouldNotMatchList[] = {
"http://example.com", "https://subdomain.example.com",
"https://notexample.com", "https://invalid.entry",
"https://example.net", "https://example.net:5432",
};
for (const char* should_not_match : kShouldNotMatchList) {
EXPECT_FALSE(
origins_list.Match(url::Origin::Create(GURL(should_not_match))))
<< "OriginList should not match url: " << should_not_match;
}
}
TEST(OriginsList, SubdomainMatch) {
OriginsList origins_list("*.example.com,*.example.net:1234");
EXPECT_FALSE(origins_list.IsEmpty());
static constexpr const char* kShouldMatchList[] = {
"https://example.com", "https://test.example.com",
"https://test.test2.example.com", "https://test.example.net:1234",
};
for (const char* should_match : kShouldMatchList) {
EXPECT_TRUE(origins_list.Match(url::Origin::Create(GURL(should_match))))
<< "OriginList should match url: " << should_match;
}
static constexpr const char* kShouldNotMatchList[] = {
"http://example.com", "https://notexample.com",
"https://test.example.net", "https://test.example.net:5432",
};
for (const char* should_not_match : kShouldNotMatchList) {
EXPECT_FALSE(
origins_list.Match(url::Origin::Create(GURL(should_not_match))))
<< "OriginList should not match url: " << should_not_match;
}
}
} // namespace signed_exchange_utils
} // namespace content
content/browser/web_package/signed_exchange_request_handler_browsertest.cc
View file @ 50ed8305
......@@ -755,17 +755,11 @@ INSTANTIATE_TEST_SUITE_P(
struct SignedExchangeAcceptHeaderBrowserTestParam {
SignedExchangeAcceptHeaderBrowserTestParam(
bool sxg_enabled,
bool sxg_origin_trial_enabled,
bool sxg_accept_header_enabled,
bool service_worker_servicification_enabled)
: sxg_enabled(sxg_enabled),
sxg_origin_trial_enabled(sxg_origin_trial_enabled),
sxg_accept_header_enabled(sxg_accept_header_enabled),
service_worker_servicification_enabled(
service_worker_servicification_enabled) {}
const bool sxg_enabled;
const bool sxg_origin_trial_enabled;
const bool sxg_accept_header_enabled;
const bool service_worker_servicification_enabled;
};
......@@ -776,8 +770,7 @@ class SignedExchangeAcceptHeaderBrowserTest
public:
using self = SignedExchangeAcceptHeaderBrowserTest;
SignedExchangeAcceptHeaderBrowserTest()
: enabled_https_server_(net::EmbeddedTestServer::TYPE_HTTPS),
disabled_https_server_(net::EmbeddedTestServer::TYPE_HTTPS) {}
: https_server_(net::EmbeddedTestServer::TYPE_HTTPS) {}
~SignedExchangeAcceptHeaderBrowserTest() override = default;
protected:
......@@ -789,11 +782,6 @@ class SignedExchangeAcceptHeaderBrowserTest
} else {
disable_features.push_back(features::kSignedHTTPExchange);
}
if (GetParam().sxg_origin_trial_enabled) {
enable_features.push_back(features::kSignedHTTPExchangeOriginTrial);
} else {
disable_features.push_back(features::kSignedHTTPExchangeOriginTrial);
}
if (GetParam().service_worker_servicification_enabled) {
enable_features.push_back(blink::features::kServiceWorkerServicification);
} else {
......@@ -802,27 +790,13 @@ class SignedExchangeAcceptHeaderBrowserTest
}
feature_list_.InitWithFeatures(enable_features, disable_features);
enabled_https_server_.ServeFilesFromSourceDirectory("content/test/data");
enabled_https_server_.RegisterRequestHandler(
https_server_.ServeFilesFromSourceDirectory("content/test/data");
https_server_.RegisterRequestHandler(
base::BindRepeating(&self::RedirectResponseHandler));
enabled_https_server_.RegisterRequestMonitor(
https_server_.RegisterRequestMonitor(
base::BindRepeating(&self::MonitorRequest, base::Unretained(this)));
ASSERT_TRUE(enabled_https_server_.Start());
ASSERT_TRUE(https_server_.Start());
disabled_https_server_.ServeFilesFromSourceDirectory("content/test/data");
disabled_https_server_.RegisterRequestHandler(
base::BindRepeating(&self::RedirectResponseHandler));
disabled_https_server_.RegisterRequestMonitor(
base::BindRepeating(&self::MonitorRequest, base::Unretained(this)));
ASSERT_TRUE(disabled_https_server_.Start());
if (GetParam().sxg_accept_header_enabled) {
std::map<std::string, std::string> feature_parameters;
feature_parameters["OriginsList"] =
base::StringPrintf("127.0.0.1:%u", enabled_https_server_.port());
feature_list_for_accept_header_.InitAndEnableFeatureWithParameters(
features::kSignedHTTPExchangeAcceptHeader, feature_parameters);
}
ContentBrowserTest::SetUp();
}
......@@ -834,25 +808,17 @@ class SignedExchangeAcceptHeaderBrowserTest
}
bool ShouldHaveSXGAcceptHeaderInEnabledOrigin() const {
return GetParam().sxg_enabled || (GetParam().sxg_origin_trial_enabled &&
GetParam().sxg_accept_header_enabled);
}
bool ShouldHaveSXGAcceptHeaderInDisabledOrigin() const {
return GetParam().sxg_enabled;
}
bool ShouldHaveSXGAcceptHeader() const { return GetParam().sxg_enabled; }
void CheckAcceptHeader(const GURL& url, bool is_navigation) {
const bool is_enabled_origin =
url.IntPort() == enabled_https_server_.port();
const bool should_have_sxg =
is_enabled_origin ? ShouldHaveSXGAcceptHeaderInEnabledOrigin()
: ShouldHaveSXGAcceptHeaderInDisabledOrigin();
const auto accept_header = GetInterceptedAcceptHeader(url);
ASSERT_TRUE(accept_header);
EXPECT_EQ(
*accept_header,
should_have_sxg
ShouldHaveSXGAcceptHeader()
? (is_navigation
? std::string(network::kFrameAcceptHeader) +
std::string(kAcceptHeaderSignedExchangeSuffix)
......@@ -885,8 +851,7 @@ class SignedExchangeAcceptHeaderBrowserTest
void ClearInterceptedAcceptHeaders() { url_accept_header_map_.clear(); }
net::EmbeddedTestServer enabled_https_server_;
net::EmbeddedTestServer disabled_https_server_;
net::EmbeddedTestServer https_server_;
private:
static std::unique_ptr<net::test_server::HttpResponse>
......@@ -917,121 +882,51 @@ class SignedExchangeAcceptHeaderBrowserTest
std::map<GURL, std::string> url_accept_header_map_;
};
IN_PROC_BROWSER_TEST_P(SignedExchangeAcceptHeaderBrowserTest, EnabledOrigin) {
const GURL enabled_test_url = enabled_https_server_.GetURL("/sxg/test.html");
IN_PROC_BROWSER_TEST_P(SignedExchangeAcceptHeaderBrowserTest, Simple) {
const GURL test_url = https_server_.GetURL("/sxg/test.html");
EXPECT_EQ(ShouldHaveSXGAcceptHeaderInEnabledOrigin(),
signed_exchange_utils::ShouldAdvertiseAcceptHeader(
url::Origin::Create(enabled_test_url)));
NavigateAndWaitForTitle(enabled_test_url, enabled_test_url.spec());
CheckNavigationAcceptHeader({enabled_test_url});
signed_exchange_utils::IsSignedExchangeHandlingEnabled());
NavigateAndWaitForTitle(test_url, test_url.spec());
CheckNavigationAcceptHeader({test_url});
}
IN_PROC_BROWSER_TEST_P(SignedExchangeAcceptHeaderBrowserTest, DisabledOrigin) {
const GURL disabled_test_url =
disabled_https_server_.GetURL("/sxg/test.html");
EXPECT_EQ(GetParam().sxg_enabled,
signed_exchange_utils::ShouldAdvertiseAcceptHeader(
url::Origin::Create(disabled_test_url)));
IN_PROC_BROWSER_TEST_P(SignedExchangeAcceptHeaderBrowserTest, Redirect) {
const GURL test_url = https_server_.GetURL("/sxg/test.html");
const GURL redirect_url = https_server_.GetURL("/r?" + test_url.spec());
const GURL redirect_redirect_url =
https_server_.GetURL("/r?" + redirect_url.spec());
NavigateAndWaitForTitle(redirect_redirect_url, test_url.spec());
NavigateAndWaitForTitle(disabled_test_url, disabled_test_url.spec());
CheckNavigationAcceptHeader({disabled_test_url});
}
IN_PROC_BROWSER_TEST_P(SignedExchangeAcceptHeaderBrowserTest,
RedirectEnabledToDisabledToEnabled) {
const GURL enabled_test_url = enabled_https_server_.GetURL("/sxg/test.html");
const GURL redirect_disabled_to_enabled_url =
disabled_https_server_.GetURL("/r?" + enabled_test_url.spec());
const GURL redirect_enabled_to_disabled_to_enabled_url =
enabled_https_server_.GetURL("/r?" +
redirect_disabled_to_enabled_url.spec());
NavigateAndWaitForTitle(redirect_enabled_to_disabled_to_enabled_url,
enabled_test_url.spec());
CheckNavigationAcceptHeader({redirect_enabled_to_disabled_to_enabled_url,
redirect_disabled_to_enabled_url,
enabled_test_url});
}
IN_PROC_BROWSER_TEST_P(SignedExchangeAcceptHeaderBrowserTest,
RedirectDisabledToEnabledToDisabled) {
const GURL disabled_test_url =
disabled_https_server_.GetURL("/sxg/test.html");
const GURL redirect_enabled_to_disabled_url =
enabled_https_server_.GetURL("/r?" + disabled_test_url.spec());
const GURL redirect_disabled_to_enabled_to_disabled_url =
disabled_https_server_.GetURL("/r?" +
redirect_enabled_to_disabled_url.spec());
NavigateAndWaitForTitle(redirect_disabled_to_enabled_to_disabled_url,
disabled_test_url.spec());
CheckNavigationAcceptHeader({redirect_disabled_to_enabled_to_disabled_url,
redirect_enabled_to_disabled_url,
disabled_test_url});
CheckNavigationAcceptHeader({redirect_redirect_url, redirect_url, test_url});
}
IN_PROC_BROWSER_TEST_P(SignedExchangeAcceptHeaderBrowserTest,
PrefetchEnabledPageEnabledTarget) {
const GURL enabled_target = enabled_https_server_.GetURL("/sxg/hello.txt");
const GURL enabled_page_url = enabled_https_server_.GetURL(
std::string("/sxg/prefetch.html#") + enabled_target.spec());
NavigateAndWaitForTitle(enabled_page_url, "OK");
CheckPrefetchAcceptHeader({enabled_target});
const GURL target = https_server_.GetURL("/sxg/hello.txt");
const GURL page_url =
https_server_.GetURL(std::string("/sxg/prefetch.html#") + target.spec());
NavigateAndWaitForTitle(page_url, "OK");
CheckPrefetchAcceptHeader({target});
}
IN_PROC_BROWSER_TEST_P(SignedExchangeAcceptHeaderBrowserTest,
PrefetchEnabledPageDisabledTarget) {
const GURL disabled_target = disabled_https_server_.GetURL("/sxg/hello.txt");
const GURL enabled_page_url = enabled_https_server_.GetURL(
std::string("/sxg/prefetch.html#") + disabled_target.spec());
NavigateAndWaitForTitle(enabled_page_url, "OK");
CheckPrefetchAcceptHeader({disabled_target});
}
PrefetchRedirect) {
const GURL target = https_server_.GetURL("/sxg/hello.txt");
const GURL redirect_url = https_server_.GetURL("/r?" + target.spec());
const GURL redirect_redirect_url =
https_server_.GetURL("/r?" + redirect_url.spec());
IN_PROC_BROWSER_TEST_P(SignedExchangeAcceptHeaderBrowserTest,
PrefetchDisabledPageEnabledTarget) {
const GURL enabled_target = enabled_https_server_.GetURL("/sxg/hello.txt");
const GURL disabled_page_url = disabled_https_server_.GetURL(
std::string("/sxg/prefetch.html#") + enabled_target.spec());
NavigateAndWaitForTitle(disabled_page_url, "OK");
CheckPrefetchAcceptHeader({enabled_target});
}
const GURL page_url = https_server_.GetURL(
std::string("/sxg/prefetch.html#") + redirect_redirect_url.spec());
IN_PROC_BROWSER_TEST_P(SignedExchangeAcceptHeaderBrowserTest,
PrefetchDisabledPageDisabledTarget) {
const GURL disabled_target = disabled_https_server_.GetURL("/sxg/hello.txt");
const GURL disabled_page_url = disabled_https_server_.GetURL(
std::string("/sxg/prefetch.html#") + disabled_target.spec());
NavigateAndWaitForTitle(disabled_page_url, "OK");
CheckPrefetchAcceptHeader({disabled_target});
}
NavigateAndWaitForTitle(page_url, "OK");
IN_PROC_BROWSER_TEST_P(
SignedExchangeAcceptHeaderBrowserTest,
PrefetchEnabledPageRedirectFromDisabledToEnabledToDisabledTarget) {
const GURL disabled_target = disabled_https_server_.GetURL("/sxg/hello.txt");
const GURL redirect_enabled_to_disabled_url =
enabled_https_server_.GetURL("/r?" + disabled_target.spec());
const GURL redirect_disabled_to_enabled_to_disabled_url =
disabled_https_server_.GetURL("/r?" +
redirect_enabled_to_disabled_url.spec());
const GURL enabled_page_url = enabled_https_server_.GetURL(
std::string("/sxg/prefetch.html#") +
redirect_disabled_to_enabled_to_disabled_url.spec());
NavigateAndWaitForTitle(enabled_page_url, "OK");
CheckPrefetchAcceptHeader({redirect_disabled_to_enabled_to_disabled_url,
redirect_enabled_to_disabled_url,
disabled_target});
CheckPrefetchAcceptHeader({redirect_redirect_url, redirect_url, target});
}
IN_PROC_BROWSER_TEST_P(SignedExchangeAcceptHeaderBrowserTest, ServiceWorker) {
NavigateAndWaitForTitle(
enabled_https_server_.GetURL("/sxg/service-worker.html"), "Done");
NavigateAndWaitForTitle(
disabled_https_server_.GetURL("/sxg/service-worker.html"), "Done");
NavigateAndWaitForTitle(https_server_.GetURL("/sxg/service-worker.html"),
"Done");
const std::string frame_accept = std::string(network::kFrameAcceptHeader);
const std::string frame_accept_with_sxg =
......@@ -1043,105 +938,53 @@ IN_PROC_BROWSER_TEST_P(SignedExchangeAcceptHeaderBrowserTest, ServiceWorker) {
SCOPED_TRACE(scope);
const bool is_generated_scope =
scope == std::string("/sxg/sw-scope-generated/");
const GURL enabled_target_url =
enabled_https_server_.GetURL(scope + "test.html");
const GURL disabled_target_url =
disabled_https_server_.GetURL(scope + "test.html");
const GURL redirect_disabled_to_enabled_target_url =
disabled_https_server_.GetURL("/r?" + enabled_target_url.spec());
const GURL redirect_enabled_to_disabled_to_enabled_target_url =
enabled_https_server_.GetURL(
"/r?" + redirect_disabled_to_enabled_target_url.spec());
const GURL redirect_enabled_to_disabled_target_url =
enabled_https_server_.GetURL("/r?" + disabled_target_url.spec());
const GURL redirect_disabled_to_enabled_to_disabled_target_url =
disabled_https_server_.GetURL(
"/r?" + redirect_enabled_to_disabled_target_url.spec());
const std::string expected_enabled_title =
is_generated_scope ? (ShouldHaveSXGAcceptHeaderInEnabledOrigin()
? frame_accept_with_sxg
: frame_accept)
: "Done";
const std::string expected_disabled_title =
is_generated_scope ? (ShouldHaveSXGAcceptHeaderInDisabledOrigin()
? frame_accept_with_sxg
: frame_accept)
: "Done";
const base::Optional<std::string> expected_enabled_target_accept_header =
is_generated_scope ? base::nullopt
: base::Optional<std::string>(
ShouldHaveSXGAcceptHeaderInEnabledOrigin()
? frame_accept_with_sxg
: frame_accept);
const base::Optional<std::string> expected_disabled_target_accept_header =
is_generated_scope ? base::nullopt
: base::Optional<std::string>(
ShouldHaveSXGAcceptHeaderInDisabledOrigin()
? frame_accept_with_sxg
: frame_accept);
NavigateAndWaitForTitle(enabled_target_url, expected_enabled_title);
EXPECT_EQ(expected_enabled_target_accept_header,
GetInterceptedAcceptHeader(enabled_target_url));
ClearInterceptedAcceptHeaders();
NavigateAndWaitForTitle(disabled_target_url, expected_disabled_title);
EXPECT_EQ(expected_disabled_target_accept_header,
GetInterceptedAcceptHeader(disabled_target_url));
ClearInterceptedAcceptHeaders();
NavigateAndWaitForTitle(redirect_disabled_to_enabled_target_url,
expected_enabled_title);
CheckNavigationAcceptHeader({redirect_disabled_to_enabled_target_url});
EXPECT_EQ(expected_enabled_target_accept_header,
GetInterceptedAcceptHeader(enabled_target_url));
const GURL target_url = https_server_.GetURL(scope + "test.html");
const GURL redirect_target_url =
https_server_.GetURL("/r?" + target_url.spec());
const GURL redirect_redirect_target_url =
https_server_.GetURL("/r?" + redirect_target_url.spec());
const std::string expected_title =
is_generated_scope
? (ShouldHaveSXGAcceptHeader() ? frame_accept_with_sxg
: frame_accept)
: "Done";
const base::Optional<std::string> expected_target_accept_header =
is_generated_scope
? base::nullopt
: base::Optional<std::string>(ShouldHaveSXGAcceptHeader()
? frame_accept_with_sxg
: frame_accept);
NavigateAndWaitForTitle(target_url, expected_title);
EXPECT_EQ(expected_target_accept_header,
GetInterceptedAcceptHeader(target_url));
ClearInterceptedAcceptHeaders();
NavigateAndWaitForTitle(redirect_enabled_to_disabled_target_url,
expected_disabled_title);
CheckNavigationAcceptHeader({redirect_enabled_to_disabled_target_url});
EXPECT_EQ(expected_disabled_target_accept_header,
GetInterceptedAcceptHeader(disabled_target_url));
NavigateAndWaitForTitle(redirect_target_url, expected_title);
CheckNavigationAcceptHeader({redirect_target_url});
EXPECT_EQ(expected_target_accept_header,
GetInterceptedAcceptHeader(target_url));
ClearInterceptedAcceptHeaders();
NavigateAndWaitForTitle(redirect_enabled_to_disabled_to_enabled_target_url,
expected_enabled_title);
NavigateAndWaitForTitle(redirect_redirect_target_url, expected_title);
CheckNavigationAcceptHeader(
{redirect_enabled_to_disabled_to_enabled_target_url,
redirect_disabled_to_enabled_target_url});
EXPECT_EQ(expected_enabled_target_accept_header,
GetInterceptedAcceptHeader(enabled_target_url));
{redirect_redirect_target_url, redirect_target_url});
EXPECT_EQ(expected_target_accept_header,
GetInterceptedAcceptHeader(target_url));
ClearInterceptedAcceptHeaders();
NavigateAndWaitForTitle(redirect_disabled_to_enabled_to_disabled_target_url,
expected_disabled_title);
CheckNavigationAcceptHeader(
{redirect_disabled_to_enabled_to_disabled_target_url,
redirect_enabled_to_disabled_target_url});
EXPECT_EQ(expected_disabled_target_accept_header,
GetInterceptedAcceptHeader(disabled_target_url));
}
}
IN_PROC_BROWSER_TEST_P(SignedExchangeAcceptHeaderBrowserTest,
ServiceWorkerPrefetch) {
NavigateAndWaitForTitle(
enabled_https_server_.GetURL("/sxg/service-worker-prefetch.html"),
"Done");
NavigateAndWaitForTitle(
disabled_https_server_.GetURL("/sxg/service-worker-prefetch.html"),
"Done");
https_server_.GetURL("/sxg/service-worker-prefetch.html"), "Done");
const std::string scope = "/sxg/sw-prefetch-scope/";
const GURL enabled_target_url =
enabled_https_server_.GetURL(scope + "test.html");
const GURL disabled_target_url =
disabled_https_server_.GetURL(scope + "test.html");
const GURL enabled_prefetch_target =
enabled_https_server_.GetURL(std::string("/sxg/hello.txt"));
const GURL disabled_prefetch_target =
disabled_https_server_.GetURL(std::string("/sxg/hello.txt"));
const GURL target_url = https_server_.GetURL(scope + "test.html");
const GURL prefetch_target =
https_server_.GetURL(std::string("/sxg/hello.txt"));
const std::string load_prefetch_script = base::StringPrintf(
"(function loadPrefetch(urls) {"
" for (let url of urls) {"
......@@ -1163,44 +1006,23 @@ IN_PROC_BROWSER_TEST_P(SignedExchangeAcceptHeaderBrowserTest,
" }"
" }"
" check();"
"})(['%s','%s'])",
enabled_prefetch_target.spec().c_str(),
disabled_prefetch_target.spec().c_str());
"})(['%s'])",
prefetch_target.spec().c_str());
bool unused = false;
NavigateAndWaitForTitle(enabled_target_url, "Done");
NavigateAndWaitForTitle(target_url, "Done");
EXPECT_TRUE(ExecuteScriptAndExtractBool(shell()->web_contents(),
load_prefetch_script, &unused));
CheckPrefetchAcceptHeader(
{enabled_prefetch_target, disabled_prefetch_target});
CheckPrefetchAcceptHeader({prefetch_target});
ClearInterceptedAcceptHeaders();
NavigateAndWaitForTitle(disabled_target_url, "Done");
EXPECT_TRUE(ExecuteScriptAndExtractBool(shell()->web_contents(),
load_prefetch_script, &unused));
CheckPrefetchAcceptHeader(
{enabled_prefetch_target, disabled_prefetch_target});
}
INSTANTIATE_TEST_SUITE_P(
SignedExchangeAcceptHeaderBrowserTest,
SignedExchangeAcceptHeaderBrowserTest,
testing::Values(
SignedExchangeAcceptHeaderBrowserTestParam(false, false, false, false),
SignedExchangeAcceptHeaderBrowserTestParam(false, false, false, true),
SignedExchangeAcceptHeaderBrowserTestParam(false, false, true, false),
SignedExchangeAcceptHeaderBrowserTestParam(false, false, true, true),
SignedExchangeAcceptHeaderBrowserTestParam(false, true, false, false),
SignedExchangeAcceptHeaderBrowserTestParam(false, true, false, true),
SignedExchangeAcceptHeaderBrowserTestParam(false, true, true, false),
SignedExchangeAcceptHeaderBrowserTestParam(false, true, true, true),
SignedExchangeAcceptHeaderBrowserTestParam(true, false, false, false),
SignedExchangeAcceptHeaderBrowserTestParam(true, false, false, true),
SignedExchangeAcceptHeaderBrowserTestParam(true, false, true, false),
SignedExchangeAcceptHeaderBrowserTestParam(true, false, true, true),
SignedExchangeAcceptHeaderBrowserTestParam(true, true, false, false),
SignedExchangeAcceptHeaderBrowserTestParam(true, true, false, true),
SignedExchangeAcceptHeaderBrowserTestParam(true, true, true, false),
SignedExchangeAcceptHeaderBrowserTestParam(true, true, true, true)));
testing::Values(SignedExchangeAcceptHeaderBrowserTestParam(false, false),
SignedExchangeAcceptHeaderBrowserTestParam(false, true),
SignedExchangeAcceptHeaderBrowserTestParam(true, false),
SignedExchangeAcceptHeaderBrowserTestParam(true, true)));
} // namespace content
content/browser/web_package/signed_exchange_utils.cc
View file @ 50ed8305
......@@ -6,14 +6,11 @@
#include "base/command_line.h"
#include "base/feature_list.h"
#include "base/metrics/field_trial_params.h"
#include "base/no_destructor.h"
#include "base/strings/string_piece.h"
#include "base/strings/string_util.h"
#include "base/time/time.h"
#include "base/trace_event/trace_event.h"
#include "content/browser/loader/download_utils_impl.h"
#include "content/browser/web_package/origins_list.h"
#include "content/browser/web_package/signed_exchange_devtools_proxy.h"
#include "content/browser/web_package/signed_exchange_error.h"
#include "content/browser/web_package/signed_exchange_request_handler.h"
......@@ -21,7 +18,6 @@
#include "content/public/common/content_switches.h"
#include "net/http/http_util.h"
#include "services/network/public/cpp/resource_response.h"
#include "third_party/blink/public/common/origin_trials/trial_token_validator.h"
namespace content {
namespace signed_exchange_utils {
......@@ -37,62 +33,12 @@ void ReportErrorAndTraceEvent(
devtools_proxy->ReportError(error_message, std::move(error_field));
}
namespace {
OriginsList CreateAdvertiseAcceptHeaderOriginsList() {
std::string param = base::GetFieldTrialParamValueByFeature(
features::kSignedHTTPExchangeAcceptHeader,
features::kSignedHTTPExchangeAcceptHeaderFieldTrialParamName);
if (param.empty())
DLOG(ERROR) << "The Accept-SXG origins list param is empty.";
return OriginsList(param);
}
bool IsSignedHTTPExchangeEnabledByFlags() {
bool IsSignedExchangeHandlingEnabled() {
return base::FeatureList::IsEnabled(features::kSignedHTTPExchange) ||
base::CommandLine::ForCurrentProcess()->HasSwitch(
switches::kEnableExperimentalWebPlatformFeatures);
}
} // namespace
bool NeedToCheckRedirectedURLForAcceptHeader() {
// When SignedHTTPExchange is enabled, the SignedExchange accept header must
// be sent to all origins. So we don't need to check the redirected URL.
return !IsSignedHTTPExchangeEnabledByFlags() &&
base::FeatureList::IsEnabled(
features::kSignedHTTPExchangeOriginTrial) &&
base::FeatureList::IsEnabled(
features::kSignedHTTPExchangeAcceptHeader);
}
bool ShouldAdvertiseAcceptHeader(const url::Origin& origin) {
// When SignedHTTPExchange is enabled, we must send the SignedExchange accept
// header to all origins.
if (IsSignedHTTPExchangeEnabledByFlags())
return true;
// When SignedHTTPExchangeOriginTrial is not enabled or
// SignedHTTPExchangeAcceptHeader is not enabled, we must not send the
// SignedExchange accept header.
if (!base::FeatureList::IsEnabled(features::kSignedHTTPExchangeOriginTrial) ||
!base::FeatureList::IsEnabled(
features::kSignedHTTPExchangeAcceptHeader)) {
return false;
}
// |origins_list| is initialized in a thread-safe manner.
// Querying OriginsList::Match() should be safe since it's read-only access.
static base::NoDestructor<OriginsList> origins_list(
CreateAdvertiseAcceptHeaderOriginsList());
return origins_list->Match(origin);
}
bool IsSignedExchangeHandlingEnabled() {
return IsSignedHTTPExchangeEnabledByFlags() ||
base::FeatureList::IsEnabled(features::kSignedHTTPExchangeOriginTrial);
}
bool ShouldHandleAsSignedHTTPExchange(
const GURL& request_url,
const network::ResourceResponseHead& head) {
......@@ -107,15 +53,7 @@ bool ShouldHandleAsSignedHTTPExchange(
head.mime_type)) {
return false;
}
if (IsSignedHTTPExchangeEnabledByFlags())
return true;
if (!base::FeatureList::IsEnabled(features::kSignedHTTPExchangeOriginTrial))
return false;
std::unique_ptr<blink::TrialTokenValidator> validator =
std::make_unique<blink::TrialTokenValidator>();
return validator->RequestEnablesFeature(
request_url, head.headers.get(),
features::kSignedHTTPExchangeOriginTrial.name, base::Time::Now());
return IsSignedExchangeHandlingEnabled();
}
base::Optional<SignedExchangeVersion> GetSignedExchangeVersion(
......
content/browser/web_package/signed_exchange_utils.h
View file @ 50ed8305
......@@ -8,17 +8,12 @@
#include <string>
#include "base/optional.h"
#include "content/browser/web_package/origins_list.h"
#include "content/browser/web_package/signed_exchange_consts.h"
#include "content/browser/web_package/signed_exchange_error.h"
#include "content/browser/web_package/signed_exchange_signature_verifier.h"
#include "content/common/content_export.h"
#include "url/gurl.h"
namespace url {
class Origin;
} // namespace url
namespace network {
struct ResourceResponseHead;
} // namespace network
......@@ -47,23 +42,11 @@ void ReportErrorAndTraceEvent(
base::Optional<SignedExchangeError::FieldIndexPair> error_field =
base::nullopt);
// Returns true when SignedHTTPExchange feature is NOT enabled and
// SignedHTTPExchangeOriginTrial and SignedHTTPExchangeAcceptHeader features are
// enabled.
bool NeedToCheckRedirectedURLForAcceptHeader();
// Returns true if Accept headers should be sent with
// "application/signed-exchange".
CONTENT_EXPORT bool ShouldAdvertiseAcceptHeader(const url::Origin& origin);
// Returns true when SignedHTTPExchange feature or SignedHTTPExchangeOriginTrial
// feature is enabled.
bool IsSignedExchangeHandlingEnabled();
// Returns true when SignedHTTPExchange feature is enabled.
CONTENT_EXPORT bool IsSignedExchangeHandlingEnabled();
// Returns true when the response should be handled as a signed exchange by
// checking the mime type and the feature flags. When SignedHTTPExchange feature
// is not enabled and SignedHTTPExchangeOriginTrial feature is enabled, this
// method also checks the Origin Trial header.
// checking the mime type and the feature flags.
bool ShouldHandleAsSignedHTTPExchange(
const GURL& request_url,
const network::ResourceResponseHead& head);
......
content/public/common/content_features.cc
View file @ 50ed8305
......@@ -443,17 +443,6 @@ const base::Feature kSignedExchangeReportingForDistributors{
const base::Feature kSignedHTTPExchange{"SignedHTTPExchange",
base::FEATURE_ENABLED_BY_DEFAULT};
// Send "Accept: application/signed-exchange" header to origins who opt-in.
const base::Feature kSignedHTTPExchangeAcceptHeader{
"SignedHTTPExchangeAcceptHeader", base::FEATURE_DISABLED_BY_DEFAULT};
// Field trial parameter containing the list of origins that opted-in to receive
// "Accept: application/signed-exchange" header.
const char kSignedHTTPExchangeAcceptHeaderFieldTrialParamName[] = "OriginsList";
// Origin Trial of Origin-Signed HTTP Exchanges (for WebPackage Loading)
const base::Feature kSignedHTTPExchangeOriginTrial{
"SignedHTTPExchangeOriginTrial", base::FEATURE_ENABLED_BY_DEFAULT};
// Controls whether SpareRenderProcessHostManager tries to always have a warm
// spare renderer process around for the most recently requested BrowserContext.
// This feature is only consulted in site-per-process mode.
......
content/public/common/content_features.h
View file @ 50ed8305
......@@ -104,10 +104,6 @@ CONTENT_EXPORT extern const base::Feature kSharedArrayBuffer;
CONTENT_EXPORT extern const base::Feature
kSignedExchangeReportingForDistributors;
CONTENT_EXPORT extern const base::Feature kSignedHTTPExchange;
CONTENT_EXPORT extern const base::Feature kSignedHTTPExchangeAcceptHeader;
CONTENT_EXPORT extern const char
kSignedHTTPExchangeAcceptHeaderFieldTrialParamName[];
CONTENT_EXPORT extern const base::Feature kSignedHTTPExchangeOriginTrial;
CONTENT_EXPORT extern const base::Feature kSkipBrowserTouchFilter;
CONTENT_EXPORT extern const char kSkipBrowserTouchFilterTypeParamName[];
CONTENT_EXPORT extern const char
......
content/test/BUILD.gn
View file @ 50ed8305
......@@ -1681,7 +1681,6 @@ test("content_unittests") {
"../browser/web_contents/web_drag_dest_mac_unittest.mm",
"../browser/web_contents/web_drag_source_mac_unittest.mm",
"../browser/web_package/http_structured_header_unittest.cc",
"../browser/web_package/origins_list_unittest.cc",
"../browser/web_package/signed_exchange_cert_fetcher_unittest.cc",
"../browser/web_package/signed_exchange_certificate_chain_unittest.cc",
"../browser/web_package/signed_exchange_envelope_unittest.cc",
......
third_party/blink/web_tests/VirtualTestSuites
View file @ 50ed8305
......@@ -632,18 +632,6 @@
"base": "external/wpt/signed-exchange",
"args": ["--enable-features=NetworkService"]
},
{
"prefix": "sxg-origin-trial",
"base": "http/tests/loading/sxg",
"args": ["--stable-release-mode",
"--enable-features=SignedHTTPExchangeOriginTrial"]
},
{
"prefix": "sxg-origin-trial-with-network-service",
"base": "http/tests/loading/sxg",
"args": ["--stable-release-mode",
"--enable-features=SignedHTTPExchangeOriginTrial,NetworkService"]
},
{
"prefix": "disabled-service-worker-servicification",
"base": "http/tests/serviceworker",
......
third_party/blink/web_tests/http/tests/loading/sxg/resources/sxg-location-origin-trial.php deleted 100644 → 0
View file @ 5bcdd1ed
<?php
header('HTTP/1.0 200 OK');
// generate_token.py http://127.0.0.1:8000 SignedHTTPExchangeOriginTrial --expire-timestamp=2000000000
header("Origin-Trial: AqVs+066F+i9lgx2N0bCs5B31heTh9PJOfVM00yDS34V3FqBzWCuI3VKOpHPDeeujnaqJRVPHG8q+jBXjPNoLwkAAABleyJvcmlnaW4iOiAiaHR0cDovLzEyNy4wLjAuMTo4MDAwIiwgImZlYXR1cmUiOiAiU2lnbmVkSFRUUEV4Y2hhbmdlT3JpZ2luVHJpYWwiLCAiZXhwaXJ5IjogMjAwMDAwMDAwMH0=");
header("Content-Type: application/signed-exchange;v=b3");
$name = 'sxg-location.sxg';
$fp = fopen($name, 'rb');
header("Content-Length: " . filesize($name));
fpassthru($fp);
?>
third_party/blink/web_tests/http/tests/loading/sxg/sxg-location-origin-trial-redirect.html deleted 100644 → 0
View file @ 5bcdd1ed
<!DOCTYPE html>
<title>Location of SignedHTTPExchange with Origin-Trial header after redirect</title>
<script src="../../resources/testharness.js"></script>
<script src="../../resources/testharnessreport.js"></script>
<script src="./resources/sxg-util.js"></script>
<body>
<script>
promise_test(async (t) => {
await waitUntilDidFinishLoadForFrame;
const url =
'http://localhost:8000/resources/redirect.php?url=' +
encodeURIComponent(
'http://127.0.0.1:8000/loading/sxg/resources/sxg-location-origin-trial.php');
const message = await openSXGInIframeAndWaitForMessage(t, url);
assert_equals(message.location, 'https://127.0.0.1:8443/loading/sxg/resources/inner-url.html');
assert_false(message.is_fallback);
}, 'Location of SignedHTTPExchange with Origin-Trial header after redirect');
</script>
</body>
third_party/blink/web_tests/http/tests/loading/sxg/sxg-location-origin-trial.html deleted 100644 → 0
View file @ 5bcdd1ed
<!DOCTYPE html>
<title>Location of SignedHTTPExchange with Origin-Trial header</title>
<script src="../../resources/testharness.js"></script>
<script src="../../resources/testharnessreport.js"></script>
<script src="./resources/sxg-util.js"></script>
<body>
<script>
promise_test(async (t) => {
await waitUntilDidFinishLoadForFrame;
const message = await openSXGInIframeAndWaitForMessage(t, 'resources/sxg-location-origin-trial.php');
assert_equals(message.location, 'https://127.0.0.1:8443/loading/sxg/resources/inner-url.html');
assert_false(message.is_fallback);
}, 'Location of SignedHTTPExchange with Origin-Trial header');
</script>
</body>
third_party/blink/web_tests/virtual/sxg-origin-trial-with-network-service/http/tests/loading/sxg/README.txt deleted 100644 → 0
View file @ 5bcdd1ed
This directory is for testing the SignedHTTPExchangeOriginTrial feature.
This suite runs the tests with --stable-release-mode, with which we
run tests with only stable feature (no experiments).
third_party/blink/web_tests/virtual/sxg-origin-trial/http/tests/loading/sxg/README.txt deleted 100644 → 0
View file @ 5bcdd1ed
This directory is for testing the SignedHTTPExchangeOriginTrial feature.
This suite runs the tests with --stable-release-mode, with which we
run tests with only stable feature (no experiments).
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment