Enable FeatureList for the GPU process.

content/app/content_main_runner.cc

 // Copyright (c) 2012 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/public/app/content_main_runner.h"
 
 #include <stddef.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include <memory>
 #include <string>
 #include <utility>
 
 #include "base/allocator/allocator_check.h"
 #include "base/allocator/allocator_extension.h"
 #include "base/at_exit.h"
+#include "base/base_switches.h"
 #include "base/command_line.h"
 #include "base/debug/debugger.h"
 #include "base/debug/stack_trace.h"
+#include "base/feature_list.h"
 #include "base/files/file_path.h"
 #include "base/i18n/icu_util.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/scoped_vector.h"
+#include "base/metrics/field_trial.h"
 #include "base/metrics/histogram_base.h"
 #include "base/metrics/statistics_recorder.h"
 #include "base/path_service.h"
 #include "base/process/launch.h"
 #include "base/process/memory.h"
 #include "base/process/process_handle.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
@@ skipping 81 matching lines @@
 #endif
 extern int RendererMain(const content::MainFunctionParams&);
 extern int UtilityMain(const MainFunctionParams&);
 #if defined(OS_ANDROID)
 extern int DownloadMain(const MainFunctionParams&);
 #endif
 }  // namespace content
 
 namespace content {
 
+namespace {
+
+// This sets up two singletons responsible for managing field trials. The
+// |field_trial_list| singleton lives on the stack and must outlive the Run()
+// method of the process.
+void InitializeFieldTrialAndFeatureList(
+    std::unique_ptr<base::FieldTrialList>* field_trial_list) {
+  const base::CommandLine& command_line =
+      *base::CommandLine::ForCurrentProcess();
+  std::string process_type =
+      command_line.GetSwitchValueASCII(switches::kProcessType);
+
+  // TODO(asvitkine): This logic should run for all child processes.

[jam, 2016/05/03 19:45:08]

why isn't this change doing it for all processes? I don't see a particular
reason not to do this now.

[erikchen, 2016/05/03 19:55:05]

Moving this logic to contain_main_runner causes problems with the global
descriptor table for renderer zygote processes on Linux. I spent some time
looking into it and couldn't figure it out, and didn't want to pour too much
time into this.

https://build.chromium.org/p/tryserver.chromium.linux/builders/linux_chromium...

[jam, 2016/05/03 20:07:38]

In general when we plumb stuff like this to child processes, we treat all child
processes the same. Otherwise it kicks the can down the road and we'll have to
solve this problem later (after some time debugging why a feature doesn't work
in a child process).

I really prefer to keep child processes as similar as possible for this code in
base/.

Thanks for the link, I looked at it and nothing stuck out as obvious. Can you
share how far you got? We can also loop in folks that are most familiar with
zygote.

+  // https://crbug.com/563705.
+  if (process_type == switches::kGpuProcess ||
+#if defined(ENABLE_PLUGINS)
+      process_type == switches::kPpapiPluginProcess ||
+#endif  // ENABLE_PLUGINS
+      process_type == switches::kUtilityProcess) {
+    // Initialize statistical testing infrastructure.  We set the entropy
+    // provider to nullptr to disallow non-browser processes from creating
+    // their own one-time randomized trials; they should be created in the
+    // browser process.
+    field_trial_list->reset(new base::FieldTrialList(nullptr));
+
+    // Ensure any field trials in browser are reflected into the child
+    // process.
+    if (command_line.HasSwitch(switches::kForceFieldTrials)) {
+      bool result = base::FieldTrialList::CreateTrialsFromString(
+          command_line.GetSwitchValueASCII(switches::kForceFieldTrials),
+          std::set<std::string>());
+      DCHECK(result);
+    }
+
+    std::unique_ptr<base::FeatureList> feature_list(new base::FeatureList);
+    feature_list->InitializeFromCommandLine(
+        command_line.GetSwitchValueASCII(switches::kEnableFeatures),
+        command_line.GetSwitchValueASCII(switches::kDisableFeatures));
+    base::FeatureList::SetInstance(std::move(feature_list));
+  }
+}
+
+}  // namespace
+
 #if !defined(CHROME_MULTIPLE_DLL_CHILD)
 base::LazyInstance<ContentBrowserClient>
     g_empty_content_browser_client = LAZY_INSTANCE_INITIALIZER;
 #endif  //  !CHROME_MULTIPLE_DLL_CHILD
 
 #if !defined(CHROME_MULTIPLE_DLL_BROWSER)
 base::LazyInstance<ContentGpuClient>
     g_empty_content_gpu_client = LAZY_INSTANCE_INITIALIZER;
 base::LazyInstance<ContentRendererClient>
     g_empty_content_renderer_client = LAZY_INSTANCE_INITIALIZER;
@@ skipping 156 matching lines @@
   // line so update it here with the new version.
   const base::CommandLine& command_line =
       *base::CommandLine::ForCurrentProcess();
   std::string process_type =
       command_line.GetSwitchValueASCII(switches::kProcessType);
   ContentClientInitializer::Set(process_type, delegate);
 
   MainFunctionParams main_params(command_line);
   main_params.zygote_child = true;
 
+  std::unique_ptr<base::FieldTrialList> field_trial_list;
+  InitializeFieldTrialAndFeatureList(&field_trial_list);
+
   for (size_t i = 0; i < arraysize(kMainFunctions); ++i) {
     if (process_type == kMainFunctions[i].name)
       return kMainFunctions[i].function(main_params);
   }
 
   if (delegate)
     return delegate->RunProcess(process_type, main_params);
 
   NOTREACHED() << "Unknown zygote process type: " << process_type;
   return 1;
@@ skipping 408 matching lines @@
   }
 
   int Run() override {
     DCHECK(is_initialized_);
     DCHECK(!is_shutdown_);
     const base::CommandLine& command_line =
         *base::CommandLine::ForCurrentProcess();
     std::string process_type =
         command_line.GetSwitchValueASCII(switches::kProcessType);
 
+    std::unique_ptr<base::FieldTrialList> field_trial_list;
+    InitializeFieldTrialAndFeatureList(&field_trial_list);
+
     base::HistogramBase::EnableActivityReportHistogram(process_type);
 
     MainFunctionParams main_params(command_line);
     main_params.ui_task = ui_task_;
 #if defined(OS_WIN)
     main_params.sandbox_info = &sandbox_info_;
 #elif defined(OS_MACOSX)
     main_params.autorelease_pool = autorelease_pool_.get();
 #endif
 
@@ skipping 56 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(ContentMainRunnerImpl);
 };
 
 // static
 ContentMainRunner* ContentMainRunner::Create() {
   return new ContentMainRunnerImpl();
 }
 
 }  // namespace content