Add disabled origin trial feature list

chrome/browser/component_updater/origin_trials_component_installer.cc

 // Copyright 2016 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 "chrome/browser/component_updater/origin_trials_component_installer.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/path_service.h"
+#include "base/strings/string_util.h"
 #include "chrome/common/chrome_switches.h"
 #include "components/component_updater/component_updater_paths.h"
 
 // The client-side configuration for the origin trial framework can be
 // overridden by an installed component named 'OriginTrials' (extension id
 // kfoklmclfodeliojeaekpoflbkkhojea. This component currently consists of just a
 // manifest.json file, which can contain a custom key named 'origin-trials'. The
 // value of this key is a dictionary:
 //
 // {
 //   "public-key": "<base64-encoding of replacement public key>",
 //   "disabled-features": [<list of features to disable>],
 //   "revoked-tokens": "<base64-encoded data>"
 // }
 //
-// TODO(iclelland): Implement support for revoked tokens and disabled features.
+// TODO(iclelland): Implement support for revoked tokens.
 //
 // If the component is not present in the user data directory, the default
 // configuration will be used.
 
 namespace component_updater {
 
 namespace {
 
 // Extension id is kfoklmclfodeliojeaekpoflbkkhojea
 const uint8_t kSha256Hash[] = {0xa5, 0xea, 0xbc, 0x2b, 0x5e, 0x34, 0xb8, 0xe9,
@@ skipping 28 matching lines @@
     const base::Version& version,
     const base::FilePath& install_dir,
     std::unique_ptr<base::DictionaryValue> manifest) {
   // Read the public key from the manifest and set the command line.
   std::string override_public_key;
   if (manifest->GetString("origin-trials.public-key", &override_public_key)) {
     base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
     command_line->AppendSwitchASCII(switches::kOriginTrialPublicKey,
                                     override_public_key);
   }
+  base::ListValue* override_disabled_feature_list;
+  if (manifest->GetList("origin-trials.disabled-features",
+                        &override_disabled_feature_list)) {
+    std::string disabled_feature;
+    std::vector<std::string> disabled_features;
+    for (const auto& item : *override_disabled_feature_list) {
+      if (item->GetAsString(&disabled_feature)) {
+        disabled_features.push_back(disabled_feature);
+      }
+    }
+    if (!disabled_features.empty()) {
+      std::string override_disabled_features =
+          base::JoinString(disabled_features, "|");
+      base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
+      command_line->AppendSwitchASCII(switches::kOriginTrialDisabledFeatures,
+                                      override_disabled_features);

[waffles, 2016/05/27 17:10:06]

Hm, are you sure this will run in time? ComponentReady is called asynchronously
during browser start-up, so I'm not sure if your changes in main_delegate will
pick it up or not.

[iclelland, 2016/05/30 18:54:06]

That's a good question -- It appears to be run in time, at least in all of my
testing. I added a sleep(20) to this method for debugging, and logged the
renderer command line. In that case, the browser window doesn't start until this
method returns, and the command line is always set correctly.

So something is ensuring that the initial window startup is blocking on this
method, and it appears to be working as expected. (I haven't traced through all
of the code to see exactly why that is the case, and if or how it could be
broken.)

It's not critical that the renderer be informed of any updates immediately; if a
new version of the component is downloaded, it's okay if the browser sees the
old version until the next restart. At that point, though, I'd want it to always
use the version on disk, even for the first window that gets instantiated.

[iclelland, 2016/05/31 14:50:13]

So the StartupTaskRunner in BrowserMainLoop is blocking on the
ComponentUpdateService, and so the renderer processes don't start until CUS is
finished. However, this is desktop only; on Android, it appears that the startup
tasks run asynchronously, so we may need another way of doing this (for both
this CL, and for the existing public key override)

+    }
+  }
 }
 
 base::FilePath OriginTrialsComponentInstallerTraits::GetRelativeInstallDir()
     const {
   return base::FilePath(FILE_PATH_LITERAL("OriginTrials"));
 }
 
 void OriginTrialsComponentInstallerTraits::GetHash(
     std::vector<uint8_t>* hash) const {
   if (!hash)
@@ skipping 13 matching lines @@
                                    const base::FilePath& user_data_dir) {
   std::unique_ptr<ComponentInstallerTraits> traits(
       new OriginTrialsComponentInstallerTraits());
   // |cus| will take ownership of |installer| during installer->Register(cus).
   DefaultComponentInstaller* installer =
       new DefaultComponentInstaller(std::move(traits));
   installer->Register(cus, base::Closure());
 }
 
 }  // namespace component_updater