0

Move OriginTrialPolicy implementation into //components

This can now be shared between //chrome, //headless, and //weblayer.

Bug: 1050722, 1049317
Change-Id: I3fdc6979926b7ba8d27a8543cace8909b5c3f75f
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2134691
Commit-Queue: Clark DuVall <cduvall@chromium.org>
Reviewed-by: Jason Chase <chasej@chromium.org>
Reviewed-by: John Abd-El-Malek <jam@chromium.org>
Cr-Commit-Position: refs/heads/master@{#756438}
This commit is contained in:
Clark DuVall
2020-04-03 23:07:32 +00:00
committed by Commit Bot
parent 0921b31208
commit 3d4e89b95b
36 changed files with 247 additions and 336 deletions

@ -115,6 +115,7 @@
#include "chrome/grit/generated_resources.h"
#include "chrome/installer/util/google_update_settings.h"
#include "components/device_event_log/device_event_log.h"
#include "components/embedder_support/switches.h"
#include "components/flags_ui/pref_service_flags_storage.h"
#include "components/google/core/common/google_util.h"
#include "components/language/content/browser/geo_language_provider.h"
@ -580,16 +581,17 @@ void ChromeBrowserMainParts::RecordBrowserStartupTime() {
void ChromeBrowserMainParts::SetupOriginTrialsCommandLine(
PrefService* local_state) {
base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
if (!command_line->HasSwitch(switches::kOriginTrialPublicKey)) {
if (!command_line->HasSwitch(embedder_support::kOriginTrialPublicKey)) {
std::string new_public_key =
local_state->GetString(prefs::kOriginTrialPublicKey);
if (!new_public_key.empty()) {
command_line->AppendSwitchASCII(
switches::kOriginTrialPublicKey,
embedder_support::kOriginTrialPublicKey,
local_state->GetString(prefs::kOriginTrialPublicKey));
}
}
if (!command_line->HasSwitch(switches::kOriginTrialDisabledFeatures)) {
if (!command_line->HasSwitch(
embedder_support::kOriginTrialDisabledFeatures)) {
const base::ListValue* override_disabled_feature_list =
local_state->GetList(prefs::kOriginTrialDisabledFeatures);
if (override_disabled_feature_list) {
@ -603,12 +605,13 @@ void ChromeBrowserMainParts::SetupOriginTrialsCommandLine(
if (!disabled_features.empty()) {
const std::string override_disabled_features =
base::JoinString(disabled_features, "|");
command_line->AppendSwitchASCII(switches::kOriginTrialDisabledFeatures,
override_disabled_features);
command_line->AppendSwitchASCII(
embedder_support::kOriginTrialDisabledFeatures,
override_disabled_features);
}
}
}
if (!command_line->HasSwitch(switches::kOriginTrialDisabledTokens)) {
if (!command_line->HasSwitch(embedder_support::kOriginTrialDisabledTokens)) {
const base::ListValue* disabled_token_list =
local_state->GetList(prefs::kOriginTrialDisabledTokens);
if (disabled_token_list) {
@ -622,8 +625,9 @@ void ChromeBrowserMainParts::SetupOriginTrialsCommandLine(
if (!disabled_tokens.empty()) {
const std::string disabled_token_switch =
base::JoinString(disabled_tokens, "|");
command_line->AppendSwitchASCII(switches::kOriginTrialDisabledTokens,
disabled_token_switch);
command_line->AppendSwitchASCII(
embedder_support::kOriginTrialDisabledTokens,
disabled_token_switch);
}
}
}

@ -205,6 +205,7 @@
#include "components/data_reduction_proxy/core/common/data_reduction_proxy_params.h"
#include "components/dom_distiller/core/dom_distiller_switches.h"
#include "components/dom_distiller/core/url_constants.h"
#include "components/embedder_support/switches.h"
#include "components/error_page/common/error_page_switches.h"
#include "components/feature_engagement/public/feature_constants.h"
#include "components/feature_engagement/public/feature_list.h"
@ -2192,9 +2193,9 @@ void ChromeContentBrowserClient::AppendExtraCommandLineSwitches(
switches::kForceUIDirection,
switches::kJavaScriptHarmony,
switches::kEnableExperimentalWebAssemblyFeatures,
switches::kOriginTrialDisabledFeatures,
switches::kOriginTrialDisabledTokens,
switches::kOriginTrialPublicKey,
embedder_support::kOriginTrialDisabledFeatures,
embedder_support::kOriginTrialDisabledTokens,
embedder_support::kOriginTrialPublicKey,
switches::kPpapiFlashArgs,
switches::kPpapiFlashPath,
switches::kPpapiFlashVersion,

@ -5,10 +5,10 @@
#include "base/command_line.h"
#include "build/build_config.h"
#include "chrome/browser/browser_process.h"
#include "chrome/common/chrome_switches.h"
#include "chrome/common/pref_names.h"
#include "chrome/test/base/in_process_browser_test.h"
#include "chrome/test/base/testing_browser_process.h"
#include "components/embedder_support/switches.h"
#include "components/prefs/scoped_user_pref_update.h"
#include "testing/gtest/include/gtest/gtest.h"
@ -76,17 +76,20 @@ class ChromeOriginTrialsTest : public InProcessBrowserTest {
IN_PROC_BROWSER_TEST_F(ChromeOriginTrialsTest, NoPublicKeySet) {
base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
EXPECT_FALSE(command_line->HasSwitch(switches::kOriginTrialPublicKey));
EXPECT_FALSE(
command_line->HasSwitch(embedder_support::kOriginTrialPublicKey));
}
IN_PROC_BROWSER_TEST_F(ChromeOriginTrialsTest, NoDisabledFeatures) {
base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
EXPECT_FALSE(command_line->HasSwitch(switches::kOriginTrialDisabledFeatures));
EXPECT_FALSE(
command_line->HasSwitch(embedder_support::kOriginTrialDisabledFeatures));
}
IN_PROC_BROWSER_TEST_F(ChromeOriginTrialsTest, NoDisabledTokens) {
base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
EXPECT_FALSE(command_line->HasSwitch(switches::kOriginTrialDisabledTokens));
EXPECT_FALSE(
command_line->HasSwitch(embedder_support::kOriginTrialDisabledTokens));
}
// Tests to verify that the public key is correctly read from prefs and
@ -100,7 +103,8 @@ IN_PROC_BROWSER_TEST_F(ChromeOriginTrialsTest, PRE_PublicKeySetOnCommandLine) {
IN_PROC_BROWSER_TEST_F(ChromeOriginTrialsTest, PublicKeySetOnCommandLine) {
ASSERT_EQ(kNewPublicKey,
local_state()->GetString(prefs::kOriginTrialPublicKey));
std::string actual = GetCommandLineSwitch(switches::kOriginTrialPublicKey);
std::string actual =
GetCommandLineSwitch(embedder_support::kOriginTrialPublicKey);
EXPECT_EQ(kNewPublicKey, actual);
}
@ -120,7 +124,7 @@ IN_PROC_BROWSER_TEST_P(ChromeOriginTrialsDisabledFeaturesTest,
DisabledFeaturesSetOnCommandLine) {
ASSERT_TRUE(local_state()->HasPrefPath(prefs::kOriginTrialDisabledFeatures));
std::string actual =
GetCommandLineSwitch(switches::kOriginTrialDisabledFeatures);
GetCommandLineSwitch(embedder_support::kOriginTrialDisabledFeatures);
EXPECT_EQ(GetParam().expected_switch, actual);
}
@ -144,7 +148,7 @@ IN_PROC_BROWSER_TEST_P(ChromeOriginTrialsDisabledTokensTest,
DisabledTokensSetOnCommandLine) {
ASSERT_TRUE(local_state()->HasPrefPath(prefs::kOriginTrialDisabledTokens));
std::string actual =
GetCommandLineSwitch(switches::kOriginTrialDisabledTokens);
GetCommandLineSwitch(embedder_support::kOriginTrialDisabledTokens);
EXPECT_EQ(GetParam().expected_switch, actual);
}

@ -10,9 +10,9 @@
#include "base/strings/string_util.h"
#include "base/test/bind_test_util.h"
#include "base/threading/thread_restrictions.h"
#include "chrome/common/chrome_switches.h"
#include "chrome/test/base/in_process_browser_test.h"
#include "chrome/test/base/ui_test_utils.h"
#include "components/embedder_support/switches.h"
#include "components/performance_manager/graph/page_node_impl.h"
#include "components/performance_manager/performance_manager_impl.h"
#include "components/performance_manager/public/graph/frame_node.h"
@ -254,7 +254,7 @@ class PageNodeImplBrowserTest : public InProcessBrowserTest {
void SetUpDefaultCommandLine(base::CommandLine* command_line) override {
InProcessBrowserTest::SetUpDefaultCommandLine(command_line);
command_line->AppendSwitchASCII(switches::kOriginTrialPublicKey,
command_line->AppendSwitchASCII(embedder_support::kOriginTrialPublicKey,
kOriginTrialTestPublicKey);
}

@ -17,8 +17,8 @@
#include "chrome/browser/web_applications/components/file_handler_manager.h"
#include "chrome/browser/web_applications/components/web_app_prefs_utils.h"
#include "chrome/browser/web_applications/components/web_app_provider_base.h"
#include "chrome/common/chrome_switches.h"
#include "chrome/common/web_application_info.h"
#include "components/embedder_support/switches.h"
#include "content/public/test/browser_test_utils.h"
#include "content/public/test/test_navigation_observer.h"
#include "content/public/test/url_loader_interceptor.h"
@ -429,7 +429,7 @@ class WebAppFileHandlingOriginTrialTest
public:
void SetUpCommandLine(base::CommandLine* command_line) override {
WebAppControllerBrowserTest::SetUpCommandLine(command_line);
command_line->AppendSwitchASCII(switches::kOriginTrialPublicKey,
command_line->AppendSwitchASCII(embedder_support::kOriginTrialPublicKey,
kOriginTrialPublicKeyForTesting);
}

@ -142,8 +142,6 @@ static_library("common") {
"multi_process_lock_linux.cc",
"multi_process_lock_mac.cc",
"multi_process_lock_win.cc",
"origin_trials/chrome_origin_trial_policy.cc",
"origin_trials/chrome_origin_trial_policy.h",
"pdf_util.cc",
"pdf_util.h",
"pref_names_util.cc",
@ -206,6 +204,7 @@ static_library("common") {
"//components/content_settings/core/common",
"//components/crash/core/common",
"//components/dom_distiller/core",
"//components/embedder_support/origin_trials",
"//components/error_page/common",
"//components/favicon_base",
"//components/flags_ui:switches",

@ -16,6 +16,7 @@ include_rules = [
"+components/crx_file",
"+components/data_reduction_proxy/core/common",
"+components/dom_distiller/core",
"+components/embedder_support/origin_trials",
"+components/favicon_base",
"+components/flags_ui/flags_ui_switches.h",
"+components/gcm_driver",

@ -39,6 +39,7 @@
#include "chrome/grit/common_resources.h"
#include "components/crash/core/common/crash_key.h"
#include "components/dom_distiller/core/url_constants.h"
#include "components/embedder_support/origin_trials/origin_trial_policy_impl.h"
#include "components/net_log/chrome_net_log.h"
#include "components/services/heap_profiling/public/cpp/profiling_client.h"
#include "content/public/common/cdm_info.h"
@ -831,7 +832,8 @@ blink::OriginTrialPolicy* ChromeContentClient::GetOriginTrialPolicy() {
// separate worker thread).
base::AutoLock auto_lock(origin_trial_policy_lock_);
if (!origin_trial_policy_)
origin_trial_policy_ = std::make_unique<ChromeOriginTrialPolicy>();
origin_trial_policy_ =
std::make_unique<embedder_support::OriginTrialPolicyImpl>();
return origin_trial_policy_.get();
}

@ -15,7 +15,6 @@
#include "base/synchronization/lock.h"
#include "build/build_config.h"
#include "chrome/common/buildflags.h"
#include "chrome/common/origin_trials/chrome_origin_trial_policy.h"
#include "components/nacl/common/buildflags.h"
#include "content/public/common/content_client.h"
#include "pdf/buildflags.h"
@ -25,6 +24,10 @@
#include "content/public/common/pepper_plugin_info.h"
#endif
namespace embedder_support {
class OriginTrialPolicyImpl;
}
class ChromeContentClient : public content::ContentClient {
public:
#if defined(GOOGLE_CHROME_BUILD)
@ -109,7 +112,7 @@ class ChromeContentClient : public content::ContentClient {
private:
// Used to lock when |origin_trial_policy_| is initialized.
base::Lock origin_trial_policy_lock_;
std::unique_ptr<ChromeOriginTrialPolicy> origin_trial_policy_;
std::unique_ptr<embedder_support::OriginTrialPolicyImpl> origin_trial_policy_;
};
#endif // CHROME_COMMON_CHROME_CONTENT_CLIENT_H_

@ -443,18 +443,6 @@ const char kOnTheFlyMhtmlHashComputation[] =
// Launches URL in new browser window.
const char kOpenInNewWindow[] = "new-window";
// Contains a list of feature names for which origin trial experiments should
// be disabled. Names should be separated by "|" characters.
const char kOriginTrialDisabledFeatures[] = "origin-trial-disabled-features";
// Contains a list of token signatures for which origin trial experiments should
// be disabled. Tokens should be separated by "|" characters.
const char kOriginTrialDisabledTokens[] = "origin-trial-disabled-tokens";
// Comma-separated list of keys which will override the default public keys for
// checking origin trial tokens.
const char kOriginTrialPublicKey[] = "origin-trial-public-key";
// Packages an extension to a .crx installable file from a given directory.
const char kPackExtension[] = "pack-extension";

@ -133,9 +133,6 @@ extern const char kNoStartupWindow[];
extern const char kNoSupervisedUserAcknowledgmentCheck[];
extern const char kOnTheFlyMhtmlHashComputation[];
extern const char kOpenInNewWindow[];
extern const char kOriginTrialDisabledFeatures[];
extern const char kOriginTrialDisabledTokens[];
extern const char kOriginTrialPublicKey[];
extern const char kPackExtension[];
extern const char kPackExtensionKey[];
extern const char kPermissionRequestApiScope[];

@ -3480,7 +3480,6 @@ test("unit_tests") {
"../common/media_router/media_sink_unittest.cc",
"../common/media_router/media_source_unittest.cc",
"../common/net/safe_search_util_unittest.cc",
"../common/origin_trials/chrome_origin_trial_policy_unittest.cc",
"../common/pref_names_util_unittest.cc",
"../common/profiler/thread_profiler_unittest.cc",
"../common/qr_code_generator/qr_code_generator_unittest.cc",

@ -80,7 +80,6 @@ test("components_unittests") {
"//components/device_event_log:unit_tests",
"//components/dom_distiller/core:unit_tests",
"//components/download:unit_tests",
"//components/embedder_support:unit_tests",
"//components/encrypted_messages:unit_tests",
"//components/favicon/core:unit_tests",
"//components/favicon_base:unit_tests",
@ -234,6 +233,7 @@ test("components_unittests") {
"//components/dom_distiller/content/browser:unit_tests",
"//components/domain_reliability:unit_tests",
"//components/drive:unit_tests",
"//components/embedder_support:unit_tests",
"//components/favicon/content:unit_tests",
"//components/gcm_driver/instance_id:unit_tests",
"//components/history/content/browser:unit_tests",

@ -13,9 +13,14 @@ static_library("embedder_support") {
source_set("unit_tests") {
testonly = true
sources = []
sources = [ "origin_trials/origin_trial_policy_impl_unittest.cc" ]
deps = []
deps = [
"//base",
"//components/embedder_support",
"//components/embedder_support/origin_trials",
"//testing/gtest",
]
if (is_android) {
sources += [ "android/util/url_utilities_unittest.cc" ]
@ -23,8 +28,6 @@ source_set("unit_tests") {
"android:native_j_unittests_jni_headers",
"android:native_java_unittests_java",
"android:util",
"//base",
"//testing/gtest",
]
}
}

@ -0,0 +1,16 @@
# Copyright 2020 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.
source_set("origin_trials") {
sources = [
"origin_trial_policy_impl.cc",
"origin_trial_policy_impl.h",
]
deps = [
"//base",
"//components/embedder_support",
"//content/public/common",
"//third_party/blink/public/common",
]
}

@ -0,0 +1,4 @@
include_rules = [
"+content/public/common",
"+third_party/blink/public/common",
]

@ -2,10 +2,9 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/common/origin_trials/chrome_origin_trial_policy.h"
#include "components/embedder_support/origin_trials/origin_trial_policy_impl.h"
#include <stdint.h>
#include <vector>
#include "base/base64.h"
@ -13,10 +12,12 @@
#include "base/feature_list.h"
#include "base/stl_util.h"
#include "base/strings/string_split.h"
#include "chrome/common/chrome_switches.h"
#include "components/embedder_support/switches.h"
#include "content/public/common/content_features.h"
#include "content/public/common/origin_util.h"
namespace embedder_support {
// This is the default public key used for validating signatures.
static const uint8_t kDefaultPublicKey[] = {
0x7c, 0xc4, 0xb8, 0x9a, 0x93, 0xba, 0x6e, 0xe2, 0xd0, 0xfd, 0x03,
@ -24,7 +25,7 @@ static const uint8_t kDefaultPublicKey[] = {
0x51, 0x14, 0x66, 0xaa, 0x02, 0x53, 0x4e, 0x33, 0xa1, 0x15,
};
ChromeOriginTrialPolicy::ChromeOriginTrialPolicy() {
OriginTrialPolicyImpl::OriginTrialPolicyImpl() {
public_keys_.push_back(
std::string(reinterpret_cast<const char*>(kDefaultPublicKey),
base::size(kDefaultPublicKey)));
@ -34,28 +35,28 @@ ChromeOriginTrialPolicy::ChromeOriginTrialPolicy() {
// will remain active.
if (base::CommandLine::InitializedForCurrentProcess()) {
base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
if (command_line->HasSwitch(switches::kOriginTrialPublicKey)) {
if (command_line->HasSwitch(kOriginTrialPublicKey)) {
SetPublicKeysFromASCIIString(
command_line->GetSwitchValueASCII(switches::kOriginTrialPublicKey));
command_line->GetSwitchValueASCII(kOriginTrialPublicKey));
}
if (command_line->HasSwitch(switches::kOriginTrialDisabledFeatures)) {
SetDisabledFeatures(command_line->GetSwitchValueASCII(
switches::kOriginTrialDisabledFeatures));
if (command_line->HasSwitch(kOriginTrialDisabledFeatures)) {
SetDisabledFeatures(
command_line->GetSwitchValueASCII(kOriginTrialDisabledFeatures));
}
if (command_line->HasSwitch(switches::kOriginTrialDisabledTokens)) {
SetDisabledTokens(command_line->GetSwitchValueASCII(
switches::kOriginTrialDisabledTokens));
if (command_line->HasSwitch(kOriginTrialDisabledTokens)) {
SetDisabledTokens(
command_line->GetSwitchValueASCII(kOriginTrialDisabledTokens));
}
}
}
ChromeOriginTrialPolicy::~ChromeOriginTrialPolicy() {}
OriginTrialPolicyImpl::~OriginTrialPolicyImpl() = default;
bool ChromeOriginTrialPolicy::IsOriginTrialsSupported() const {
bool OriginTrialPolicyImpl::IsOriginTrialsSupported() const {
return true;
}
std::vector<base::StringPiece> ChromeOriginTrialPolicy::GetPublicKeys() const {
std::vector<base::StringPiece> OriginTrialPolicyImpl::GetPublicKeys() const {
std::vector<base::StringPiece> casted_public_keys;
for (auto const& key : public_keys_) {
casted_public_keys.push_back(base::StringPiece(key));
@ -63,25 +64,24 @@ std::vector<base::StringPiece> ChromeOriginTrialPolicy::GetPublicKeys() const {
return casted_public_keys;
}
bool ChromeOriginTrialPolicy::IsFeatureDisabled(
base::StringPiece feature) const {
bool OriginTrialPolicyImpl::IsFeatureDisabled(base::StringPiece feature) const {
return disabled_features_.count(feature.as_string()) > 0;
}
bool ChromeOriginTrialPolicy::IsTokenDisabled(
bool OriginTrialPolicyImpl::IsTokenDisabled(
base::StringPiece token_signature) const {
return disabled_tokens_.count(token_signature.as_string()) > 0;
}
bool ChromeOriginTrialPolicy::IsOriginSecure(const GURL& url) const {
bool OriginTrialPolicyImpl::IsOriginSecure(const GURL& url) const {
return content::IsOriginSecure(url);
}
bool ChromeOriginTrialPolicy::SetPublicKeysFromASCIIString(
bool OriginTrialPolicyImpl::SetPublicKeysFromASCIIString(
const std::string& ascii_public_keys) {
std::vector<std::string> new_public_keys;
const auto public_keys = base::SplitString(ascii_public_keys, ",",
base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
const auto public_keys = base::SplitString(
ascii_public_keys, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
for (const auto& ascii_public_key : public_keys) {
// Base64-decode the incoming string. Set the key if it is correctly
// formatted
@ -99,7 +99,7 @@ bool ChromeOriginTrialPolicy::SetPublicKeysFromASCIIString(
return false;
}
bool ChromeOriginTrialPolicy::SetDisabledFeatures(
bool OriginTrialPolicyImpl::SetDisabledFeatures(
const std::string& disabled_feature_list) {
std::set<std::string> new_disabled_features;
const std::vector<std::string> features =
@ -111,7 +111,7 @@ bool ChromeOriginTrialPolicy::SetDisabledFeatures(
return true;
}
bool ChromeOriginTrialPolicy::SetDisabledTokens(
bool OriginTrialPolicyImpl::SetDisabledTokens(
const std::string& disabled_token_list) {
std::set<std::string> new_disabled_tokens;
const std::vector<std::string> tokens =
@ -128,3 +128,5 @@ bool ChromeOriginTrialPolicy::SetDisabledTokens(
disabled_tokens_.swap(new_disabled_tokens);
return true;
}
} // namespace embedder_support

@ -2,8 +2,8 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CHROME_COMMON_ORIGIN_TRIALS_CHROME_ORIGIN_TRIAL_POLICY_H_
#define CHROME_COMMON_ORIGIN_TRIALS_CHROME_ORIGIN_TRIAL_POLICY_H_
#ifndef COMPONENTS_EMBEDDER_SUPPORT_ORIGIN_TRIALS_ORIGIN_TRIAL_POLICY_IMPL_H_
#define COMPONENTS_EMBEDDER_SUPPORT_ORIGIN_TRIALS_ORIGIN_TRIAL_POLICY_IMPL_H_
#include <set>
#include <string>
@ -12,12 +12,14 @@
#include "base/strings/string_piece.h"
#include "third_party/blink/public/common/origin_trials/origin_trial_policy.h"
namespace embedder_support {
// This class is instantiated on the main/ui thread, but its methods can be
// accessed from any thread.
class ChromeOriginTrialPolicy : public blink::OriginTrialPolicy {
class OriginTrialPolicyImpl : public blink::OriginTrialPolicy {
public:
ChromeOriginTrialPolicy();
~ChromeOriginTrialPolicy() override;
OriginTrialPolicyImpl();
~OriginTrialPolicyImpl() override;
// blink::OriginTrialPolicy interface
bool IsOriginTrialsSupported() const override;
@ -35,7 +37,9 @@ class ChromeOriginTrialPolicy : public blink::OriginTrialPolicy {
std::set<std::string> disabled_features_;
std::set<std::string> disabled_tokens_;
DISALLOW_COPY_AND_ASSIGN(ChromeOriginTrialPolicy);
DISALLOW_COPY_AND_ASSIGN(OriginTrialPolicyImpl);
};
#endif // CHROME_COMMON_ORIGIN_TRIALS_CHROME_ORIGIN_TRIAL_POLICY_H_
} // namespace embedder_support
#endif // COMPONENTS_EMBEDDER_SUPPORT_ORIGIN_TRIALS_ORIGIN_TRIAL_POLICY_IMPL_H_

@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/common/origin_trials/chrome_origin_trial_policy.h"
#include "components/embedder_support/origin_trials/origin_trial_policy_impl.h"
#include <memory>
@ -11,9 +11,11 @@
#include "base/stl_util.h"
#include "base/strings/string_piece.h"
#include "base/strings/string_util.h"
#include "chrome/common/chrome_switches.h"
#include "components/embedder_support/switches.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace embedder_support {
const uint8_t kTestPublicKey[] = {
0x75, 0x10, 0xac, 0xf9, 0x3a, 0x1c, 0xb8, 0xa9, 0x28, 0x70, 0xd2,
0x9a, 0xd0, 0x0b, 0x59, 0xe1, 0xac, 0x2b, 0xb7, 0xd5, 0xca, 0x1f,
@ -25,16 +27,16 @@ const char kTestPublicKeyString[] =
"dRCs+TocuKkocNKa0AtZ4awrt9XKH2SQCI6o4FY6BNA=";
const uint8_t kTwoTestPublicKeys[][32] = {
{
0x75, 0x10, 0xac, 0xf9, 0x3a, 0x1c, 0xb8, 0xa9, 0x28, 0x70, 0xd2,
0x9a, 0xd0, 0x0b, 0x59, 0xe1, 0xac, 0x2b, 0xb7, 0xd5, 0xca, 0x1f,
0x64, 0x90, 0x08, 0x8e, 0xa8, 0xe0, 0x56, 0x3a, 0x04, 0xd0,
},
{
0x50, 0x07, 0x4d, 0x76, 0x55, 0x56, 0x42, 0x17, 0x2d, 0x8a, 0x9c,
0x47, 0x96, 0x25, 0xda, 0x70, 0xaa, 0xb9, 0xfd, 0x53, 0x5d, 0x51,
0x3e, 0x16, 0xab, 0xb4, 0x86, 0xea, 0xf3, 0x35, 0xc6, 0xca,
}};
{
0x75, 0x10, 0xac, 0xf9, 0x3a, 0x1c, 0xb8, 0xa9, 0x28, 0x70, 0xd2,
0x9a, 0xd0, 0x0b, 0x59, 0xe1, 0xac, 0x2b, 0xb7, 0xd5, 0xca, 0x1f,
0x64, 0x90, 0x08, 0x8e, 0xa8, 0xe0, 0x56, 0x3a, 0x04, 0xd0,
},
{
0x50, 0x07, 0x4d, 0x76, 0x55, 0x56, 0x42, 0x17, 0x2d, 0x8a, 0x9c,
0x47, 0x96, 0x25, 0xda, 0x70, 0xaa, 0xb9, 0xfd, 0x53, 0x5d, 0x51,
0x3e, 0x16, 0xab, 0xb4, 0x86, 0xea, 0xf3, 0x35, 0xc6, 0xca,
}};
const int kTwoTestPublicKeysSize = 2;
// Comma-separated Base64 encodings of the above sample public keys.
@ -100,9 +102,9 @@ const char kToken3SignatureEncoded[] =
"mhktqL2v3xCA==";
const char kTokenSeparator[] = "|";
class ChromeOriginTrialPolicyTest : public testing::Test {
class OriginTrialPolicyImplTest : public testing::Test {
protected:
ChromeOriginTrialPolicyTest()
OriginTrialPolicyImplTest()
: token1_signature_(
std::string(reinterpret_cast<const char*>(kToken1Signature),
base::size(kToken1Signature))),
@ -119,7 +121,7 @@ class ChromeOriginTrialPolicyTest : public testing::Test {
base::JoinString({kToken1SignatureEncoded, kToken2SignatureEncoded,
kToken3SignatureEncoded},
kTokenSeparator)),
manager_(base::WrapUnique(new ChromeOriginTrialPolicy())),
manager_(base::WrapUnique(new OriginTrialPolicyImpl())),
default_keys_(manager_->GetPublicKeys()) {
test_keys_.push_back(
base::StringPiece(reinterpret_cast<const char*>(kTestPublicKey),
@ -131,7 +133,7 @@ class ChromeOriginTrialPolicyTest : public testing::Test {
}
}
ChromeOriginTrialPolicy* manager() { return manager_.get(); }
OriginTrialPolicyImpl* manager() { return manager_.get(); }
std::vector<base::StringPiece> default_keys() { return default_keys_; }
std::vector<base::StringPiece> test_keys() { return test_keys_; }
std::vector<base::StringPiece> test_keys2() { return test_keys2_; }
@ -142,13 +144,13 @@ class ChromeOriginTrialPolicyTest : public testing::Test {
std::string three_disabled_tokens_;
private:
std::unique_ptr<ChromeOriginTrialPolicy> manager_;
std::unique_ptr<OriginTrialPolicyImpl> manager_;
std::vector<base::StringPiece> default_keys_;
std::vector<base::StringPiece> test_keys_;
std::vector<base::StringPiece> test_keys2_;
};
TEST_F(ChromeOriginTrialPolicyTest, DefaultConstructor) {
TEST_F(OriginTrialPolicyImplTest, DefaultConstructor) {
// We don't specify here what the keys should be, but make sure those are
// returned, valid and consistent.
for (base::StringPiece key : manager()->GetPublicKeys()) {
@ -157,79 +159,79 @@ TEST_F(ChromeOriginTrialPolicyTest, DefaultConstructor) {
EXPECT_EQ(default_keys(), manager()->GetPublicKeys());
}
TEST_F(ChromeOriginTrialPolicyTest, DefaultKeysAreConsistent) {
ChromeOriginTrialPolicy manager2;
TEST_F(OriginTrialPolicyImplTest, DefaultKeysAreConsistent) {
OriginTrialPolicyImpl manager2;
EXPECT_EQ(manager()->GetPublicKeys(), manager2.GetPublicKeys());
}
TEST_F(ChromeOriginTrialPolicyTest, OverridePublicKeys) {
TEST_F(OriginTrialPolicyImplTest, OverridePublicKeys) {
EXPECT_TRUE(manager()->SetPublicKeysFromASCIIString(kTestPublicKeyString));
EXPECT_EQ(test_keys(), manager()->GetPublicKeys());
}
TEST_F(ChromeOriginTrialPolicyTest, OverridePublicKeysWithTwoKeys) {
TEST_F(OriginTrialPolicyImplTest, OverridePublicKeysWithTwoKeys) {
EXPECT_TRUE(
manager()->SetPublicKeysFromASCIIString(kTwoTestPublicKeysString));
EXPECT_EQ(test_keys2(), manager()->GetPublicKeys());
}
TEST_F(ChromeOriginTrialPolicyTest, OverrideKeysNotBase64) {
TEST_F(OriginTrialPolicyImplTest, OverrideKeysNotBase64) {
EXPECT_FALSE(
manager()->SetPublicKeysFromASCIIString(kBadEncodingPublicKeyString));
EXPECT_EQ(default_keys(), manager()->GetPublicKeys());
}
TEST_F(ChromeOriginTrialPolicyTest, OverrideKeysTooShort) {
TEST_F(OriginTrialPolicyImplTest, OverrideKeysTooShort) {
EXPECT_FALSE(
manager()->SetPublicKeysFromASCIIString(kTooShortPublicKeyString));
EXPECT_EQ(default_keys(), manager()->GetPublicKeys());
}
TEST_F(ChromeOriginTrialPolicyTest, OverrideKeysTooLong) {
TEST_F(OriginTrialPolicyImplTest, OverrideKeysTooLong) {
EXPECT_FALSE(
manager()->SetPublicKeysFromASCIIString(kTooLongPublicKeyString));
EXPECT_EQ(default_keys(), manager()->GetPublicKeys());
}
TEST_F(ChromeOriginTrialPolicyTest, OverridePublicKeysWithBadAndGoodKey) {
TEST_F(OriginTrialPolicyImplTest, OverridePublicKeysWithBadAndGoodKey) {
EXPECT_FALSE(
manager()->SetPublicKeysFromASCIIString(kTwoPublicKeysString_BadAndGood));
EXPECT_EQ(default_keys(), manager()->GetPublicKeys());
}
TEST_F(ChromeOriginTrialPolicyTest, OverridePublicKeysWithTwoBadKeys) {
TEST_F(OriginTrialPolicyImplTest, OverridePublicKeysWithTwoBadKeys) {
EXPECT_FALSE(
manager()->SetPublicKeysFromASCIIString(kTwoBadPublicKeysString));
EXPECT_EQ(default_keys(), manager()->GetPublicKeys());
}
TEST_F(ChromeOriginTrialPolicyTest, NoDisabledFeatures) {
TEST_F(OriginTrialPolicyImplTest, NoDisabledFeatures) {
EXPECT_FALSE(manager()->IsFeatureDisabled("A"));
EXPECT_FALSE(manager()->IsFeatureDisabled("B"));
EXPECT_FALSE(manager()->IsFeatureDisabled("C"));
}
TEST_F(ChromeOriginTrialPolicyTest, DisableOneFeature) {
TEST_F(OriginTrialPolicyImplTest, DisableOneFeature) {
EXPECT_TRUE(manager()->SetDisabledFeatures(kOneDisabledFeature));
EXPECT_TRUE(manager()->IsFeatureDisabled("A"));
EXPECT_FALSE(manager()->IsFeatureDisabled("B"));
}
TEST_F(ChromeOriginTrialPolicyTest, DisableTwoFeatures) {
TEST_F(OriginTrialPolicyImplTest, DisableTwoFeatures) {
EXPECT_TRUE(manager()->SetDisabledFeatures(kTwoDisabledFeatures));
EXPECT_TRUE(manager()->IsFeatureDisabled("A"));
EXPECT_TRUE(manager()->IsFeatureDisabled("B"));
EXPECT_FALSE(manager()->IsFeatureDisabled("C"));
}
TEST_F(ChromeOriginTrialPolicyTest, DisableThreeFeatures) {
TEST_F(OriginTrialPolicyImplTest, DisableThreeFeatures) {
EXPECT_TRUE(manager()->SetDisabledFeatures(kThreeDisabledFeatures));
EXPECT_TRUE(manager()->IsFeatureDisabled("A"));
EXPECT_TRUE(manager()->IsFeatureDisabled("B"));
EXPECT_TRUE(manager()->IsFeatureDisabled("C"));
}
TEST_F(ChromeOriginTrialPolicyTest, DisableFeatureWithSpace) {
TEST_F(OriginTrialPolicyImplTest, DisableFeatureWithSpace) {
EXPECT_TRUE(manager()->SetDisabledFeatures(kSpacesInDisabledFeatures));
EXPECT_TRUE(manager()->IsFeatureDisabled("A"));
EXPECT_TRUE(manager()->IsFeatureDisabled("B C"));
@ -237,26 +239,26 @@ TEST_F(ChromeOriginTrialPolicyTest, DisableFeatureWithSpace) {
EXPECT_FALSE(manager()->IsFeatureDisabled("C"));
}
TEST_F(ChromeOriginTrialPolicyTest, NoDisabledTokens) {
TEST_F(OriginTrialPolicyImplTest, NoDisabledTokens) {
EXPECT_FALSE(manager()->IsTokenDisabled(token1_signature_));
EXPECT_FALSE(manager()->IsTokenDisabled(token2_signature_));
EXPECT_FALSE(manager()->IsTokenDisabled(token3_signature_));
}
TEST_F(ChromeOriginTrialPolicyTest, DisableOneToken) {
TEST_F(OriginTrialPolicyImplTest, DisableOneToken) {
EXPECT_TRUE(manager()->SetDisabledTokens(kToken1SignatureEncoded));
EXPECT_TRUE(manager()->IsTokenDisabled(token1_signature_));
EXPECT_FALSE(manager()->IsTokenDisabled(token2_signature_));
}
TEST_F(ChromeOriginTrialPolicyTest, DisableTwoTokens) {
TEST_F(OriginTrialPolicyImplTest, DisableTwoTokens) {
EXPECT_TRUE(manager()->SetDisabledTokens(two_disabled_tokens_));
EXPECT_TRUE(manager()->IsTokenDisabled(token1_signature_));
EXPECT_TRUE(manager()->IsTokenDisabled(token2_signature_));
EXPECT_FALSE(manager()->IsTokenDisabled(token3_signature_));
}
TEST_F(ChromeOriginTrialPolicyTest, DisableThreeTokens) {
TEST_F(OriginTrialPolicyImplTest, DisableThreeTokens) {
EXPECT_TRUE(manager()->SetDisabledTokens(three_disabled_tokens_));
EXPECT_TRUE(manager()->IsTokenDisabled(token1_signature_));
EXPECT_TRUE(manager()->IsTokenDisabled(token2_signature_));
@ -264,53 +266,54 @@ TEST_F(ChromeOriginTrialPolicyTest, DisableThreeTokens) {
}
// Tests for initialization from command line
class ChromeOriginTrialPolicyInitializationTest
: public ChromeOriginTrialPolicyTest {
class OriginTrialPolicyImplInitializationTest
: public OriginTrialPolicyImplTest {
protected:
ChromeOriginTrialPolicyInitializationTest() {}
OriginTrialPolicyImplInitializationTest() {}
ChromeOriginTrialPolicy* initialized_manager() {
OriginTrialPolicyImpl* initialized_manager() {
return initialized_manager_.get();
}
void SetUp() override {
ChromeOriginTrialPolicyTest::SetUp();
OriginTrialPolicyImplTest::SetUp();
base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
ASSERT_FALSE(command_line->HasSwitch(switches::kOriginTrialPublicKey));
ASSERT_FALSE(
command_line->HasSwitch(switches::kOriginTrialDisabledFeatures));
ASSERT_FALSE(command_line->HasSwitch(switches::kOriginTrialDisabledTokens));
ASSERT_FALSE(command_line->HasSwitch(kOriginTrialPublicKey));
ASSERT_FALSE(command_line->HasSwitch(kOriginTrialDisabledFeatures));
ASSERT_FALSE(command_line->HasSwitch(kOriginTrialDisabledTokens));
// Setup command line with various updated values
// New public key
command_line->AppendSwitchASCII(switches::kOriginTrialPublicKey,
command_line->AppendSwitchASCII(kOriginTrialPublicKey,
kTestPublicKeyString);
// One disabled feature
command_line->AppendSwitchASCII(switches::kOriginTrialDisabledFeatures,
command_line->AppendSwitchASCII(kOriginTrialDisabledFeatures,
kOneDisabledFeature);
// One disabled token
command_line->AppendSwitchASCII(switches::kOriginTrialDisabledTokens,
command_line->AppendSwitchASCII(kOriginTrialDisabledTokens,
kToken1SignatureEncoded);
initialized_manager_ = base::WrapUnique(new ChromeOriginTrialPolicy());
initialized_manager_ = base::WrapUnique(new OriginTrialPolicyImpl());
}
private:
std::unique_ptr<ChromeOriginTrialPolicy> initialized_manager_;
std::unique_ptr<OriginTrialPolicyImpl> initialized_manager_;
};
TEST_F(ChromeOriginTrialPolicyInitializationTest, PublicKeyInitialized) {
TEST_F(OriginTrialPolicyImplInitializationTest, PublicKeyInitialized) {
EXPECT_NE(default_keys(), initialized_manager()->GetPublicKeys());
EXPECT_EQ(test_keys(), initialized_manager()->GetPublicKeys());
}
TEST_F(ChromeOriginTrialPolicyInitializationTest, DisabledFeaturesInitialized) {
TEST_F(OriginTrialPolicyImplInitializationTest, DisabledFeaturesInitialized) {
EXPECT_TRUE(initialized_manager()->IsFeatureDisabled("A"));
EXPECT_FALSE(initialized_manager()->IsFeatureDisabled("B"));
}
TEST_F(ChromeOriginTrialPolicyInitializationTest, DisabledTokensInitialized) {
TEST_F(OriginTrialPolicyImplInitializationTest, DisabledTokensInitialized) {
EXPECT_TRUE(initialized_manager()->IsTokenDisabled(token1_signature_));
EXPECT_FALSE(initialized_manager()->IsTokenDisabled(token2_signature_));
}
} // namespace embedder_support

@ -9,4 +9,16 @@ namespace embedder_support {
// Disables pop-up blocking.
const char kDisablePopupBlocking[] = "disable-popup-blocking";
// Contains a list of feature names for which origin trial experiments should
// be disabled. Names should be separated by "|" characters.
const char kOriginTrialDisabledFeatures[] = "origin-trial-disabled-features";
// Contains a list of token signatures for which origin trial experiments should
// be disabled. Tokens should be separated by "|" characters.
const char kOriginTrialDisabledTokens[] = "origin-trial-disabled-tokens";
// Comma-separated list of keys which will override the default public keys for
// checking origin trial tokens.
const char kOriginTrialPublicKey[] = "origin-trial-public-key";
} // namespace embedder_support

@ -12,6 +12,9 @@
namespace embedder_support {
extern const char kDisablePopupBlocking[];
extern const char kOriginTrialDisabledFeatures[];
extern const char kOriginTrialDisabledTokens[];
extern const char kOriginTrialPublicKey[];
} // namespace embedder_support

@ -250,8 +250,6 @@ jumbo_source_set("headless_shared_sources") {
"app/headless_shell_switches.h",
"lib/headless_content_client.cc",
"lib/headless_content_client.h",
"lib/headless_origin_trial_policy.cc",
"lib/headless_origin_trial_policy.h",
"public/headless_browser.cc",
"public/headless_browser.h",
"public/headless_export.h",
@ -279,6 +277,7 @@ jumbo_source_set("headless_shared_sources") {
":protocol_sources",
":version_header",
"//base:base_static",
"//components/embedder_support/origin_trials",
"//content/public/common",
"//content/public/common:service_names",
"//third_party/inspector_protocol:crdtp",

@ -2,8 +2,8 @@ specific_include_rules = {
"headless_browser_browsertest.cc": [
"+third_party/crashpad/crashpad/client",
],
"headless_content_client.h|headless_origin_trial_policy.h": [
"+third_party/blink/public/common/origin_trials/origin_trial_policy.h",
"headless_content_client.cc": [
"+components/embedder_support/origin_trials",
],
"headless_content_main_delegate.cc": [
"+cc/base/switches.h",

@ -1,5 +1,6 @@
include_rules = [
"+cc/base",
"+components/embedder_support",
"+components/keyed_service/core",
"+components/printing/browser",
"+components/printing/common",

@ -16,6 +16,7 @@
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_split.h"
#include "build/build_config.h"
#include "components/embedder_support/switches.h"
#include "content/public/browser/browser_context.h"
#include "content/public/browser/browser_thread.h"
#include "content/public/browser/client_certificate_delegate.h"
@ -213,6 +214,15 @@ void HeadlessContentBrowserClient::AppendExtraCommandLineSwitches(
languages[0].as_string());
}
}
// Please keep this in alphabetical order.
static const char* const kSwitchNames[] = {
embedder_support::kOriginTrialDisabledFeatures,
embedder_support::kOriginTrialDisabledTokens,
embedder_support::kOriginTrialPublicKey,
};
command_line->CopySwitchesFrom(old_command_line, kSwitchNames,
base::size(kSwitchNames));
}
if (append_command_line_flags_callback_) {

@ -4,6 +4,7 @@
#include "headless/lib/headless_content_client.h"
#include "components/embedder_support/origin_trials/origin_trial_policy_impl.h"
#include "ui/base/l10n/l10n_util.h"
#include "ui/base/resource/resource_bundle.h"
@ -41,7 +42,8 @@ blink::OriginTrialPolicy* HeadlessContentClient::GetOriginTrialPolicy() {
// separate worker thread).
base::AutoLock auto_lock(origin_trial_policy_lock_);
if (!origin_trial_policy_)
origin_trial_policy_ = std::make_unique<HeadlessOriginTrialPolicy>();
origin_trial_policy_ =
std::make_unique<embedder_support::OriginTrialPolicyImpl>();
return origin_trial_policy_.get();
}

@ -9,7 +9,10 @@
#include "base/synchronization/lock.h"
#include "content/public/common/content_client.h"
#include "headless/lib/headless_origin_trial_policy.h"
namespace embedder_support {
class OriginTrialPolicyImpl;
}
namespace headless {
@ -29,7 +32,7 @@ class HeadlessContentClient : public content::ContentClient {
private:
// Used to lock when |origin_trial_policy_| is initialized.
base::Lock origin_trial_policy_lock_;
std::unique_ptr<HeadlessOriginTrialPolicy> origin_trial_policy_;
std::unique_ptr<embedder_support::OriginTrialPolicyImpl> origin_trial_policy_;
DISALLOW_COPY_AND_ASSIGN(HeadlessContentClient);
};

@ -1,144 +0,0 @@
// Copyright 2020 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 "headless/lib/headless_origin_trial_policy.h"
#include <stdint.h>
#include <vector>
#include "base/base64.h"
#include "base/command_line.h"
#include "base/stl_util.h"
#include "base/strings/string_split.h"
#include "content/public/common/origin_util.h"
// This is the default public key used for validating signatures.
static const uint8_t kDefaultPublicKey[] = {
0x7c, 0xc4, 0xb8, 0x9a, 0x93, 0xba, 0x6e, 0xe2, 0xd0, 0xfd, 0x03,
0x1d, 0xfb, 0x32, 0x66, 0xc7, 0x3b, 0x72, 0xfd, 0x54, 0x3a, 0x07,
0x51, 0x14, 0x66, 0xaa, 0x02, 0x53, 0x4e, 0x33, 0xa1, 0x15,
};
// TODO(crbug.com/1049317): Move the Chrome definition of these switches into
// a shared location (see
// https://source.chromium.org/chromium/chromium/src/+/master:chrome/common/chrome_switches.h;l=137;drc=66ee8f655d42c11d34d527e42f6043db540fee79).
// Contains a list of feature names for which origin trial experiments should
// be disabled. Names should be separated by "|" characters.
const char kOriginTrialDisabledFeatures[] = "origin-trial-disabled-features";
// Contains a list of token signatures for which origin trial experiments should
// be disabled. Tokens should be separated by "|" characters.
const char kOriginTrialDisabledTokens[] = "origin-trial-disabled-tokens";
// Comma-separated list of keys which will override the default public keys for
// checking origin trial tokens.
const char kOriginTrialPublicKey[] = "origin-trial-public-key";
HeadlessOriginTrialPolicy::HeadlessOriginTrialPolicy()
: public_keys_(1,
std::string(reinterpret_cast<const char*>(kDefaultPublicKey),
base::size(kDefaultPublicKey))) {
// Set the public key and disabled feature list for the origin trial key
// manager, based on the command line flags which were passed to this process.
// If the flags are not present, or are incorrectly formatted, the defaults
// will remain active.
if (base::CommandLine::InitializedForCurrentProcess()) {
base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
if (command_line->HasSwitch(kOriginTrialPublicKey)) {
SetPublicKeysFromASCIIString(
command_line->GetSwitchValueASCII(kOriginTrialPublicKey));
}
if (command_line->HasSwitch(kOriginTrialDisabledFeatures)) {
SetDisabledFeatures(
command_line->GetSwitchValueASCII(kOriginTrialDisabledFeatures));
}
if (command_line->HasSwitch(kOriginTrialDisabledTokens)) {
SetDisabledTokens(
command_line->GetSwitchValueASCII(kOriginTrialDisabledTokens));
}
}
}
HeadlessOriginTrialPolicy::~HeadlessOriginTrialPolicy() = default;
bool HeadlessOriginTrialPolicy::IsOriginTrialsSupported() const {
return true;
}
std::vector<base::StringPiece> HeadlessOriginTrialPolicy::GetPublicKeys()
const {
std::vector<base::StringPiece> casted_public_keys;
for (auto const& key : public_keys_) {
casted_public_keys.push_back(base::StringPiece(key));
}
return casted_public_keys;
}
bool HeadlessOriginTrialPolicy::IsFeatureDisabled(
base::StringPiece feature) const {
return disabled_features_.count(feature.as_string()) > 0;
}
bool HeadlessOriginTrialPolicy::IsTokenDisabled(
base::StringPiece token_signature) const {
return disabled_tokens_.count(token_signature.as_string()) > 0;
}
bool HeadlessOriginTrialPolicy::IsOriginSecure(const GURL& url) const {
return content::IsOriginSecure(url);
}
bool HeadlessOriginTrialPolicy::SetPublicKeysFromASCIIString(
const std::string& ascii_public_keys) {
std::vector<std::string> new_public_keys;
const auto public_keys = base::SplitString(
ascii_public_keys, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
for (const auto& ascii_public_key : public_keys) {
// Base64-decode the incoming string. Set the key if it is correctly
// formatted
std::string new_public_key;
if (!base::Base64Decode(ascii_public_key, &new_public_key))
return false;
if (new_public_key.size() != 32)
return false;
new_public_keys.push_back(new_public_key);
}
if (!new_public_keys.empty()) {
public_keys_.swap(new_public_keys);
return true;
}
return false;
}
bool HeadlessOriginTrialPolicy::SetDisabledFeatures(
const std::string& disabled_feature_list) {
std::set<std::string> new_disabled_features;
const std::vector<std::string> features =
base::SplitString(disabled_feature_list, "|", base::TRIM_WHITESPACE,
base::SPLIT_WANT_NONEMPTY);
for (const std::string& feature : features)
new_disabled_features.insert(feature);
disabled_features_.swap(new_disabled_features);
return true;
}
bool HeadlessOriginTrialPolicy::SetDisabledTokens(
const std::string& disabled_token_list) {
std::set<std::string> new_disabled_tokens;
const std::vector<std::string> tokens =
base::SplitString(disabled_token_list, "|", base::TRIM_WHITESPACE,
base::SPLIT_WANT_NONEMPTY);
for (const std::string& ascii_token : tokens) {
std::string token_signature;
if (!base::Base64Decode(ascii_token, &token_signature))
continue;
if (token_signature.size() != 64)
continue;
new_disabled_tokens.insert(token_signature);
}
disabled_tokens_.swap(new_disabled_tokens);
return true;
}

@ -1,50 +0,0 @@
// Copyright 2020 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 HEADLESS_LIB_HEADLESS_ORIGIN_TRIAL_POLICY_H_
#define HEADLESS_LIB_HEADLESS_ORIGIN_TRIAL_POLICY_H_
#include <set>
#include <string>
#include <vector>
#include "base/macros.h"
#include "base/strings/string_piece.h"
#include "third_party/blink/public/common/origin_trials/origin_trial_policy.h"
// This class implements an OriginTrialPolicy to allow origin trials to be
// enabled in headless mode. For more information on origin trials, see:
// 1)
// https://github.com/GoogleChrome/OriginTrials/blob/gh-pages/developer-guide.md
// 2)
// https://dev.chromium.org/blink/origin-trials/running-an-origin-trial#TOC-How-do-Origin-Trials-work-in-Chrome-
// This class is instantiated on the main/ui thread, but its methods can be
// accessed from any thread.
// TODO(crbug.com/1049317): Figure out how to share implementation with the
// other class ChromeOriginTrialPolicy.
class HeadlessOriginTrialPolicy : public blink::OriginTrialPolicy {
public:
HeadlessOriginTrialPolicy();
~HeadlessOriginTrialPolicy() override;
// blink::OriginTrialPolicy interface
bool IsOriginTrialsSupported() const override;
std::vector<base::StringPiece> GetPublicKeys() const override;
bool IsFeatureDisabled(base::StringPiece feature) const override;
bool IsTokenDisabled(base::StringPiece token_signature) const override;
bool IsOriginSecure(const GURL& url) const override;
bool SetPublicKeysFromASCIIString(const std::string& ascii_public_key);
bool SetDisabledFeatures(const std::string& disabled_feature_list);
bool SetDisabledTokens(const std::string& disabled_token_list);
private:
std::vector<std::string> public_keys_;
std::set<std::string> disabled_features_;
std::set<std::string> disabled_tokens_;
DISALLOW_COPY_AND_ASSIGN(HeadlessOriginTrialPolicy);
};
#endif // HEADLESS_LIB_HEADLESS_ORIGIN_TRIAL_POLICY_H_

@ -238,6 +238,7 @@ source_set("weblayer_lib_base") {
"//components/crash/core/app",
"//components/crash/core/common",
"//components/embedder_support",
"//components/embedder_support/origin_trials",
"//components/find_in_page",
"//components/keyed_service/content",
"//components/metrics",

@ -560,4 +560,23 @@ void ContentBrowserClientImpl::GetAdditionalMappedFilesForChildProcess(
}
#endif // defined(OS_LINUX) || defined(OS_ANDROID)
void ContentBrowserClientImpl::AppendExtraCommandLineSwitches(
base::CommandLine* command_line,
int child_process_id) {
const base::CommandLine& browser_command_line(
*base::CommandLine::ForCurrentProcess());
std::string process_type =
command_line->GetSwitchValueASCII(::switches::kProcessType);
if (process_type == ::switches::kRendererProcess) {
// Please keep this in alphabetical order.
static const char* const kSwitchNames[] = {
embedder_support::kOriginTrialDisabledFeatures,
embedder_support::kOriginTrialDisabledTokens,
embedder_support::kOriginTrialPublicKey,
};
command_line->CopySwitchesFrom(browser_command_line, kSwitchNames,
base::size(kSwitchNames));
}
}
} // namespace weblayer

@ -90,13 +90,14 @@ class ContentBrowserClientImpl : public content::ContentBrowserClient {
void RenderProcessWillLaunch(content::RenderProcessHost* host) override;
scoped_refptr<content::QuotaPermissionContext> CreateQuotaPermissionContext()
override;
#if defined(OS_LINUX) || defined(OS_ANDROID)
void GetAdditionalMappedFilesForChildProcess(
const base::CommandLine& command_line,
int child_process_id,
content::PosixFileDescriptorInfo* mappings) override;
#endif // defined(OS_LINUX) || defined(OS_ANDROID)
void AppendExtraCommandLineSwitches(base::CommandLine* command_line,
int child_process_id) override;
void CreateFeatureListAndFieldTrials();

@ -1,4 +1,5 @@
include_rules = [
"+components/embedder_support/origin_trials",
"+content/app/resources",
"+content/public/common",
"+gpu/config",

@ -5,6 +5,7 @@
#include "weblayer/common/content_client_impl.h"
#include "build/build_config.h"
#include "components/embedder_support/origin_trials/origin_trial_policy_impl.h"
#include "content/app/resources/grit/content_resources.h"
#include "gpu/config/gpu_info.h"
#include "gpu/config/gpu_util.h"
@ -14,9 +15,9 @@
namespace weblayer {
ContentClientImpl::ContentClientImpl() {}
ContentClientImpl::ContentClientImpl() = default;
ContentClientImpl::~ContentClientImpl() {}
ContentClientImpl::~ContentClientImpl() = default;
base::string16 ContentClientImpl::GetLocalizedString(int message_id) {
return l10n_util::GetStringUTF16(message_id);
@ -50,4 +51,15 @@ gfx::Image& ContentClientImpl::GetNativeImageNamed(int resource_id) {
resource_id);
}
blink::OriginTrialPolicy* ContentClientImpl::GetOriginTrialPolicy() {
// Prevent initialization race (see crbug.com/721144). There may be a
// race when the policy is needed for worker startup (which happens on a
// separate worker thread).
base::AutoLock auto_lock(origin_trial_policy_lock_);
if (!origin_trial_policy_)
origin_trial_policy_ =
std::make_unique<embedder_support::OriginTrialPolicyImpl>();
return origin_trial_policy_.get();
}
} // namespace weblayer

@ -5,8 +5,13 @@
#ifndef WEBLAYER_COMMON_CONTENT_CLIENT_IMPL_H_
#define WEBLAYER_COMMON_CONTENT_CLIENT_IMPL_H_
#include "base/synchronization/lock.h"
#include "content/public/common/content_client.h"
namespace embedder_support {
class OriginTrialPolicyImpl;
}
namespace weblayer {
class ContentClientImpl : public content::ContentClient {
@ -22,6 +27,12 @@ class ContentClientImpl : public content::ContentClient {
base::RefCountedMemory* GetDataResourceBytes(int resource_id) override;
void SetGpuInfo(const gpu::GPUInfo& gpu_info) override;
gfx::Image& GetNativeImageNamed(int resource_id) override;
blink::OriginTrialPolicy* GetOriginTrialPolicy() override;
private:
// Used to lock when |origin_trial_policy_| is initialized.
base::Lock origin_trial_policy_lock_;
std::unique_ptr<embedder_support::OriginTrialPolicyImpl> origin_trial_policy_;
};
} // namespace weblayer