Hook up variations::VariationsService in WebLayer

Unlike WebView it looks like VariationsService is a better fit than a
custom java fetcher since we expect to have network permissions.

Note without backend changes this patch should be a NOP since no trials
currently target WebLayer as a platform.

WebLayerFieldTrials is a stub and as such it doesn't currently
support WebLayer specific trials. AFAIK this doesn't prevent a trial's
config specifying WebLayer only.

The variations service itself has plenty of tests but there doesn't seem
to be any tests for the equivalent hookup code in Chrome/WebView.

Bug: 1025612
Change-Id: Ib7dfe64455a323cfafd160b2612f148872e0fa25
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2028770
Commit-Queue: Alex Clarke <alexclarke@chromium.org>
Auto-Submit: Alex Clarke <alexclarke@chromium.org>
Reviewed-by: Alexei Svitkine <asvitkine@chromium.org>
Reviewed-by: Richard Coles <torne@chromium.org>
Reviewed-by: Tobias Sargeant <tobiasjs@chromium.org>
Cr-Commit-Position: refs/heads/master@{#738518}

components/embedder_support/android/metrics/android_metrics_service_client.h

@@ -126,6 +126,10 @@ class AndroidMetricsServiceClient : public MetricsServiceClient,
                const content::NotificationSource& source,
                const content::NotificationDetails& details) override;
 
+  metrics::MetricsStateManager* metrics_state_manager() const {
+    return metrics_state_manager_.get();
+  }
+
  protected:
   // Called by Initialize() to allow embedder specific initialization.
   virtual void InitInternal() = 0;

weblayer/BUILD.gn

@@ -144,8 +144,11 @@ jumbo_static_library("weblayer_lib") {
     "browser/weblayer_browser_interface_binders.h",
     "browser/weblayer_content_browser_overlay_manifest.cc",
     "browser/weblayer_content_browser_overlay_manifest.h",
+    "browser/weblayer_field_trials.h",
     "browser/weblayer_security_blocking_page_factory.cc",
     "browser/weblayer_security_blocking_page_factory.h",
+    "browser/weblayer_variations_service_client.cc",
+    "browser/weblayer_variations_service_client.h",
     "browser/webui/web_ui_controller_factory.cc",
     "browser/webui/web_ui_controller_factory.h",
     "browser/webui/weblayer_internals_ui.cc",

weblayer/app/content_main_delegate_impl.cc

@@ -143,6 +143,16 @@ bool ContentMainDelegateImpl::BasicStartupComplete(int* exit_code) {
   return false;
 }
 
+bool ContentMainDelegateImpl::ShouldCreateFeatureList() {
+#if defined(OS_ANDROID)
+  // On android WebLayer is in charge of creating its own FeatureList.
+  return false;
+#else
+  // TODO(weblayer-dev): Support feature lists on desktop.
+  return true;
+#endif
+}
+
 void ContentMainDelegateImpl::PreSandboxStartup() {
 #if defined(ARCH_CPU_ARM_FAMILY) && (defined(OS_ANDROID) || defined(OS_LINUX))
   // Create an instance of the CPU class to parse /proc/cpuinfo and cache
@@ -179,6 +189,10 @@ void ContentMainDelegateImpl::PreSandboxStartup() {
 #endif
 }
 
+void ContentMainDelegateImpl::PostEarlyInitialization(bool is_running_tests) {
+  browser_client_->CreateFeatureListAndFieldTrials();
+}
+
 int ContentMainDelegateImpl::RunProcess(
     const std::string& process_type,
     const content::MainFunctionParams& main_function_params) {

weblayer/app/content_main_delegate_impl.h

@@ -26,7 +26,9 @@ class ContentMainDelegateImpl : public content::ContentMainDelegate {
 
   // ContentMainDelegate implementation:
   bool BasicStartupComplete(int* exit_code) override;
+  bool ShouldCreateFeatureList() override;
   void PreSandboxStartup() override;
+  void PostEarlyInitialization(bool is_running_tests) override;
   int RunProcess(
       const std::string& process_type,
       const content::MainFunctionParams& main_function_params) override;

weblayer/browser/DEPS

@@ -24,6 +24,7 @@ include_rules = [
   "+components/ssl_errors",
   "+components/startup_metric_utils",
   "+components/strings",
+  "+components/variations",
   "+components/version_info",
   "+components/web_cache/browser",
   "+content/public",

weblayer/browser/browser_main_parts_impl.cc

@@ -90,6 +90,7 @@ int BrowserMainPartsImpl::PreCreateThreads() {
 
   return service_manager::RESULT_CODE_NORMAL_EXIT;
 }
+
 void BrowserMainPartsImpl::PreMainMessageLoopStart() {
 #if defined(USE_AURA) && defined(USE_X11)
   ui::TouchFactory::SetTouchDeviceListFromCommandLine();
@@ -116,12 +117,6 @@ int BrowserMainPartsImpl::PreEarlyInitialization() {
   return service_manager::RESULT_CODE_NORMAL_EXIT;
 }
 
-void BrowserMainPartsImpl::PostEarlyInitialization() {
-#if defined(OS_ANDROID)
-  CreateLocalState();
-#endif
-}
-
 void BrowserMainPartsImpl::PreMainMessageLoopRun() {
   ui::MaterialDesignController::Initialize();
   // It's necessary to have a complete dependency graph of
@@ -166,12 +161,4 @@ void BrowserMainPartsImpl::PreDefaultMainMessageLoopRun(
       base::BindOnce(StopMessageLoop, std::move(quit_closure)));
 }
 
-void BrowserMainPartsImpl::CreateLocalState() {
-  DCHECK(!local_state_);
-  feature_list_creator_ = std::make_unique<FeatureListCreator>();
-  feature_list_creator_->CreateLocalState();
-  local_state_ = feature_list_creator_->TakePrefService();
-  CHECK(local_state_);
-}
-
 }  // namespace weblayer

weblayer/browser/browser_main_parts_impl.h

@@ -11,10 +11,8 @@
 #include "base/metrics/field_trial.h"
 #include "build/build_config.h"
 #include "components/embedder_support/android/metrics/memory_metrics_logger.h"
-#include "components/prefs/pref_service.h"
 #include "content/public/browser/browser_main_parts.h"
 #include "content/public/common/main_function_params.h"
-#include "weblayer/browser/feature_list_creator.h"
 
 namespace weblayer {
 class BrowserProcess;
@@ -29,7 +27,6 @@ class BrowserMainPartsImpl : public content::BrowserMainParts {
   // BrowserMainParts overrides.
   int PreCreateThreads() override;
   int PreEarlyInitialization() override;
-  void PostEarlyInitialization() override;
   void PreMainMessageLoopStart() override;
   void PreMainMessageLoopRun() override;
   void PostMainMessageLoopRun() override;
@@ -45,8 +42,6 @@ class BrowserMainPartsImpl : public content::BrowserMainParts {
 #if defined(OS_ANDROID)
   std::unique_ptr<metrics::MemoryMetricsLogger> memory_metrics_logger_;
 #endif  // defined(OS_ANDROID)
-  std::unique_ptr<FeatureListCreator> feature_list_creator_;
-  std::unique_ptr<PrefService> local_state_;
 
   // For running weblayer_browsertests.
   const content::MainFunctionParams main_function_params_;

weblayer/browser/content_browser_client_impl.cc

@@ -43,6 +43,7 @@
 #include "url/origin.h"
 #include "weblayer/browser/browser_main_parts_impl.h"
 #include "weblayer/browser/browser_process.h"
+#include "weblayer/browser/feature_list_creator.h"
 #include "weblayer/browser/i18n_util.h"
 #include "weblayer/browser/profile_impl.h"
 #include "weblayer/browser/system_network_context_manager.h"
@@ -146,7 +147,14 @@ void HandleSSLErrorWrapper(
 namespace weblayer {
 
 ContentBrowserClientImpl::ContentBrowserClientImpl(MainParams* params)
-    : params_(params) {}
+    : params_(params),
+      feature_list_creator_(std::make_unique<FeatureListCreator>()) {
+  if (!SystemNetworkContextManager::HasInstance())
+    SystemNetworkContextManager::CreateInstance(GetUserAgent());
+
+  feature_list_creator_->SetSystemNetworkContextManager(
+      SystemNetworkContextManager::GetInstance());
+}
 
 ContentBrowserClientImpl::~ContentBrowserClientImpl() = default;
 
@@ -281,14 +289,6 @@ void ContentBrowserClientImpl::OnNetworkServiceCreated(
   network::mojom::CryptConfigPtr config = network::mojom::CryptConfig::New();
   content::GetNetworkService()->SetCryptConfig(std::move(config));
 #endif
-
-  // Create SystemNetworkContextManager if it has not been created yet. We need
-  // to set up global NetworkService state before anything else uses it and this
-  // is the first opportunity to initialize SystemNetworkContextManager with the
-  // NetworkService.
-  if (!SystemNetworkContextManager::HasInstance())
-    SystemNetworkContextManager::CreateInstance(GetUserAgent());
-
   SystemNetworkContextManager::GetInstance()->OnNetworkServiceCreated(
       network_service);
 }
@@ -443,6 +443,10 @@ void ContentBrowserClientImpl::RegisterBrowserInterfaceBindersForFrame(
   PopulateWebLayerFrameBinders(render_frame_host, map);
 }
 
+void ContentBrowserClientImpl::CreateFeatureListAndFieldTrials() {
+  feature_list_creator_->CreateFeatureListAndFieldTrials();
+}
+
 #if defined(OS_ANDROID)
 SafeBrowsingService* ContentBrowserClientImpl::GetSafeBrowsingService() {
   if (!safe_browsing_service_) {

weblayer/browser/content_browser_client_impl.h

@@ -17,6 +17,7 @@
 
 namespace weblayer {
 
+class FeatureListCreator;
 class SafeBrowsingService;
 struct MainParams;
 
@@ -104,6 +105,8 @@ class ContentBrowserClientImpl : public content::ContentBrowserClient {
                                 bool* ignore_navigation) override;
 #endif
 
+  void CreateFeatureListAndFieldTrials();
+
  private:
   MainParams* params_;
 
@@ -111,6 +114,8 @@ class ContentBrowserClientImpl : public content::ContentBrowserClient {
   SafeBrowsingService* GetSafeBrowsingService();
   std::unique_ptr<SafeBrowsingService> safe_browsing_service_;
 #endif
+
+  std::unique_ptr<FeatureListCreator> feature_list_creator_;
 };
 
 }  // namespace weblayer

weblayer/browser/feature_list_creator.cc

@@ -5,20 +5,36 @@
 #include "weblayer/browser/feature_list_creator.h"
 
 #include "base/base_switches.h"
+#include "base/debug/leak_annotations.h"
 #include "base/path_service.h"
 #include "build/build_config.h"
+#include "cc/base/switches.h"
 #include "components/metrics/metrics_pref_names.h"
 #include "components/metrics/metrics_service.h"
+#include "components/metrics/metrics_state_manager.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/prefs/in_memory_pref_store.h"
 #include "components/prefs/json_pref_store.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/pref_service.h"
 #include "components/prefs/pref_service_factory.h"
+#include "components/variations/pref_names.h"
+#include "components/variations/service/ui_string_overrider.h"
+#include "components/variations/variations_crash_keys.h"
+#include "content/public/browser/network_service_instance.h"
+#include "content/public/common/content_switch_dependent_feature_overrides.h"
+#include "services/network/public/cpp/shared_url_loader_factory.h"
 #include "weblayer/browser/android/metrics/weblayer_metrics_service_client.h"
+#include "weblayer/browser/system_network_context_manager.h"
+#include "weblayer/browser/weblayer_variations_service_client.h"
 
-namespace weblayer {
+#if defined(OS_ANDROID)
+namespace switches {
+const char kDisableBackgroundNetworking[] = "disable-background-networking";
+}  // namespace switches
+#endif
 
+namespace weblayer {
 namespace {
 
 void HandleReadError(PersistentPrefStore::PrefReadError error) {}
@@ -38,7 +54,7 @@ std::unique_ptr<PrefService> CreatePrefService() {
 #if defined(OS_ANDROID)
   metrics::AndroidMetricsServiceClient::RegisterPrefs(pref_registry.get());
 #endif
-  // TODO(weblayer-dev): Register prefs with VariationsService
+  variations::VariationsService::RegisterPrefs(pref_registry.get());
   PrefServiceFactory pref_service_factory;
 
 #if defined(OS_ANDROID)
@@ -63,11 +79,65 @@ FeatureListCreator::FeatureListCreator() = default;
 
 FeatureListCreator::~FeatureListCreator() = default;
 
-void FeatureListCreator::CreateLocalState() {
+void FeatureListCreator::SetSystemNetworkContextManager(
+    SystemNetworkContextManager* system_network_context_manager) {
+  system_network_context_manager_ = system_network_context_manager;
+}
+
+void FeatureListCreator::SetUpFieldTrials() {
+#if defined(OS_ANDROID)
+  auto* metrics_client = WebLayerMetricsServiceClient::GetInstance();
+
+  // Initialize FieldTrialList to support FieldTrials. If an instance already
+  // exists, this is likely a test scenario with a ScopedFeatureList active,
+  // so use that one to apply any overrides.
+  if (!base::FieldTrialList::GetInstance()) {
+    // Note: This is intentionally leaked since it needs to live for the
+    // duration of the browser process and there's no benefit in cleaning it up
+    // at exit.
+    // Note: We deliberately use CreateLowEntropyProvider because
+    // CreateDefaultEntropyProvider needs to know if user conset has been given
+    // but getting consent from GMS is slow.
+    base::FieldTrialList* leaked_field_trial_list = new base::FieldTrialList(
+        metrics_client->metrics_state_manager()->CreateLowEntropyProvider());
+    ANNOTATE_LEAKING_OBJECT_PTR(leaked_field_trial_list);
+    ignore_result(leaked_field_trial_list);
+  }
+
+  DCHECK(system_network_context_manager_);
+  variations_service_ = variations::VariationsService::Create(
+      std::make_unique<WebLayerVariationsServiceClient>(
+          system_network_context_manager_->GetSharedURLLoaderFactory()),
+      local_state_.get(), metrics_client->metrics_state_manager(),
+      switches::kDisableBackgroundNetworking, variations::UIStringOverrider(),
+      base::BindOnce(&content::GetNetworkConnectionTracker));
+  variations_service_->OverridePlatform(
+      variations::Study::PLATFORM_ANDROID_WEBLAYER, "android_weblayer");
+
+  std::set<std::string> unforceable_field_trials;
+  std::vector<std::string> variation_ids;
+  auto feature_list = std::make_unique<base::FeatureList>();
+
+  variations_service_->PerformPreMainMessageLoopStartup();
+  variations_service_->SetupFieldTrials(
+      cc::switches::kEnableGpuBenchmarking, switches::kEnableFeatures,
+      switches::kDisableFeatures, unforceable_field_trials, variation_ids,
+      content::GetSwitchDependentFeatureOverrides(
+          *base::CommandLine::ForCurrentProcess()),
+      std::move(feature_list), &weblayer_field_trials_);
+  variations::InitCrashKeys();
+#else
+  // TODO(weblayer-dev): Support variations on desktop.
+#endif
+}
+
+void FeatureListCreator::CreateFeatureListAndFieldTrials() {
   local_state_ = CreatePrefService();
+  CHECK(local_state_);
 #if defined(OS_ANDROID)
   WebLayerMetricsServiceClient::GetInstance()->Initialize(local_state_.get());
 #endif
+  SetUpFieldTrials();
 }
 
 }  // namespace weblayer

weblayer/browser/feature_list_creator.h

@@ -8,27 +8,40 @@
 #include <memory>
 
 #include "components/prefs/pref_service.h"
+#include "components/variations/service/variations_service.h"
+#include "weblayer/browser/weblayer_field_trials.h"
 
 namespace weblayer {
+class SystemNetworkContextManager;
 
-// TODO(weblayer-dev): // Set up field trials based on the stored variations
-// seed data.
+// Used by WebLayer to set up field trials based on the stored variations
+// seed data. Once created this object must exist for the lifetime of the
+// process as it contains the FieldTrialList that can be queried for the state
+// of experiments.
 class FeatureListCreator {
  public:
   FeatureListCreator();
   ~FeatureListCreator();
 
-  void CreateLocalState();
+  void SetSystemNetworkContextManager(
+      SystemNetworkContextManager* system_network_context_manager);
 
-  // Passes ownership of the |local_state_| to the caller.
-  std::unique_ptr<PrefService> TakePrefService() {
-    DCHECK(local_state_);
-    return std::move(local_state_);
-  }
+  // Must be called after SetSharedURLLoaderFactory.
+  void CreateFeatureListAndFieldTrials();
+
+  PrefService* local_state() const { return local_state_.get(); }
 
  private:
+  void SetUpFieldTrials();
+
   std::unique_ptr<PrefService> local_state_;
 
+  SystemNetworkContextManager* system_network_context_manager_;  // NOT OWNED.
+
+  std::unique_ptr<variations::VariationsService> variations_service_;
+
+  WebLayerFieldTrials weblayer_field_trials_;
+
   DISALLOW_COPY_AND_ASSIGN(FeatureListCreator);
 };
 

weblayer/browser/java/BUILD.gn

@@ -78,6 +78,7 @@ android_library("java") {
     "//components/minidump_uploader:minidump_uploader_java",
     "//components/security_interstitials/content/android:java",
     "//components/spellcheck/browser/android:java",
+    "//components/variations/android:variations_java",
     "//components/version_info/android:version_constants_java",
     "//content/public/android:content_java",
     "//net/android:net_java",

weblayer/browser/system_network_context_manager.cc

@@ -41,17 +41,7 @@ bool SystemNetworkContextManager::HasInstance() {
 
 // static
 SystemNetworkContextManager* SystemNetworkContextManager::GetInstance() {
-  if (!g_system_network_context_manager) {
-    // Initialize the network service, which will trigger
-    // ChromeContentBrowserClient::OnNetworkServiceCreated(), which calls
-    // CreateInstance() to initialize |g_system_network_context_manager|.
-    content::GetNetworkService();
-
-    // TODO(crbug.com/981057): There should be a DCHECK() here to make sure
-    // |g_system_network_context_manager| has been created, but that is not
-    // true in many unit tests.
-  }
-
+  DCHECK(g_system_network_context_manager);
   return g_system_network_context_manager;
 }
 

weblayer/browser/system_network_context_manager.h

@@ -27,9 +27,8 @@ class SystemNetworkContextManager {
   // Checks if the global SystemNetworkContextManager has been created.
   static bool HasInstance();
 
-  // Gets the global SystemNetworkContextManager instance. If it has not been
-  // created yet, NetworkService is called, which will cause the
-  // SystemNetworkContextManager to be created.
+  // Gets the global SystemNetworkContextManager instance or DCHECKs if there
+  // isn't one..
   static SystemNetworkContextManager* GetInstance();
 
   // Destroys the global SystemNetworkContextManager instance.

weblayer/browser/weblayer_field_trials.h

+// Copyright 2019 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 WEBLAYER_BROWSER_WEBLAYER_FIELD_TRIALS_H_
+#define WEBLAYER_BROWSER_WEBLAYER_FIELD_TRIALS_H_
+
+#include "base/macros.h"
+#include "components/variations/platform_field_trials.h"
+
+namespace weblayer {
+
+// Responsible for setting up field trials specific to WebLayer. Currently all
+// functions are stubs, as WebLayer has no specific field trials.
+class WebLayerFieldTrials : public variations::PlatformFieldTrials {
+ public:
+  WebLayerFieldTrials() {}
+  ~WebLayerFieldTrials() override {}
+
+  // variations::PlatformFieldTrials:
+  void SetupFieldTrials() override {}
+  void SetupFeatureControllingFieldTrials(
+      bool has_seed,
+      base::FeatureList* feature_list) override {}
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(WebLayerFieldTrials);
+};
+
+}  // namespace weblayer
+
+#endif  // WEBLAYER_BROWSER_WEBLAYER_FIELD_TRIALS_H_

weblayer/browser/weblayer_variations_service_client.cc

+// Copyright 2019 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 "weblayer/browser/weblayer_variations_service_client.h"
+
+#include "base/bind.h"
+#include "base/threading/scoped_blocking_call.h"
+#include "build/build_config.h"
+#include "components/version_info/android/channel_getter.h"
+#include "services/network/public/cpp/shared_url_loader_factory.h"
+
+using version_info::Channel;
+
+namespace weblayer {
+namespace {
+
+// Gets the version number to use for variations seed simulation. Must be called
+// on a thread where IO is allowed.
+base::Version GetVersionForSimulation() {
+  base::ScopedBlockingCall scoped_blocking_call(FROM_HERE,
+                                                base::BlockingType::MAY_BLOCK);
+  return version_info::GetVersion();
+}
+
+}  // namespace
+
+WebLayerVariationsServiceClient::WebLayerVariationsServiceClient(
+    scoped_refptr<network::SharedURLLoaderFactory> shared_url_loader_factory)
+    : shared_url_loader_factory_(std::move(shared_url_loader_factory)) {}
+
+WebLayerVariationsServiceClient::~WebLayerVariationsServiceClient() = default;
+
+base::OnceCallback<base::Version()>
+WebLayerVariationsServiceClient::GetVersionForSimulationCallback() {
+  return base::BindOnce(&GetVersionForSimulation);
+}
+
+scoped_refptr<network::SharedURLLoaderFactory>
+WebLayerVariationsServiceClient::GetURLLoaderFactory() {
+  return shared_url_loader_factory_;
+}
+
+network_time::NetworkTimeTracker*
+WebLayerVariationsServiceClient::GetNetworkTimeTracker() {
+  return nullptr;
+}
+
+Channel WebLayerVariationsServiceClient::GetChannel() {
+  return version_info::android::GetChannel();
+}
+
+bool WebLayerVariationsServiceClient::OverridesRestrictParameter(
+    std::string* parameter) {
+  return false;
+}
+
+bool WebLayerVariationsServiceClient::IsEnterprise() {
+  return false;
+}
+
+}  // namespace weblayer

weblayer/browser/weblayer_variations_service_client.h

+// Copyright 2019 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 WEBLAYER_BROWSER_WEBLAYER_VARIATIONS_SERVICE_CLIENT_H_
+#define WEBLAYER_BROWSER_WEBLAYER_VARIATIONS_SERVICE_CLIENT_H_
+
+#include <string>
+
+#include "base/macros.h"
+#include "base/memory/scoped_refptr.h"
+#include "components/variations/service/variations_service_client.h"
+
+namespace network {
+class SharedURLLoaderFactory;
+}  // namespace network
+
+namespace weblayer {
+
+// WebLayerVariationsServiceClient provides an implementation of
+// VariationsServiceClient, all members are currently stubs for WebLayer.
+class WebLayerVariationsServiceClient
+    : public variations::VariationsServiceClient {
+ public:
+  explicit WebLayerVariationsServiceClient(
+      scoped_refptr<network::SharedURLLoaderFactory> shared_url_loader_factory);
+  ~WebLayerVariationsServiceClient() override;
+
+ private:
+  base::OnceCallback<base::Version(void)> GetVersionForSimulationCallback()
+      override;
+  scoped_refptr<network::SharedURLLoaderFactory> GetURLLoaderFactory() override;
+  network_time::NetworkTimeTracker* GetNetworkTimeTracker() override;
+  version_info::Channel GetChannel() override;
+  bool OverridesRestrictParameter(std::string* parameter) override;
+  bool IsEnterprise() override;
+
+  scoped_refptr<network::SharedURLLoaderFactory> shared_url_loader_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(WebLayerVariationsServiceClient);
+};
+
+}  // namespace weblayer
+
+#endif  // WEBLAYER_BROWSER_WEBLAYER_VARIATIONS_SERVICE_CLIENT_H_