Allow overriding variation parameter via chrome://flags.

components/flags_ui/flags_state.cc

 // Copyright 2015 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 "components/flags_ui/flags_state.h"
 
 #include "base/callback.h"
 #include "base/feature_list.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/metrics/field_trial.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "components/flags_ui/feature_entry.h"
 #include "components/flags_ui/flags_storage.h"
 #include "components/flags_ui/flags_ui_switches.h"
+#include "components/variations/variations_associated_data.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace flags_ui {
 
 namespace {
 
 // Convert switch constants to proper CommandLine::StringType strings.
 base::CommandLine::StringType GetSwitchString(const std::string& flag) {
   base::CommandLine cmd_line(base::CommandLine::NO_PROGRAM);
   cmd_line.AppendSwitch(flag);
@@ skipping 60 matching lines @@
 // Adds the internal names for the specified entry to |names|.
 void AddInternalName(const FeatureEntry& e, std::set<std::string>* names) {
   switch (e.type) {
     case FeatureEntry::SINGLE_VALUE:
     case FeatureEntry::SINGLE_DISABLE_VALUE:
       names->insert(e.internal_name);
       break;
     case FeatureEntry::MULTI_VALUE:
     case FeatureEntry::ENABLE_DISABLE_VALUE:
     case FeatureEntry::FEATURE_VALUE:
-      for (int i = 0; i < e.num_choices; ++i)
-        names->insert(e.NameForChoice(i));
+    case FeatureEntry::FEATURE_WITH_VARIATIONS_VALUE:
+      for (int i = 0; i < e.num_options; ++i)
+        names->insert(e.NameForOption(i));
       break;
   }
 }
 
 // Confirms that an entry is valid, used in a DCHECK in
 // SanitizeList below.
 bool ValidateFeatureEntry(const FeatureEntry& e) {
   switch (e.type) {
     case FeatureEntry::SINGLE_VALUE:
     case FeatureEntry::SINGLE_DISABLE_VALUE:
-      DCHECK_EQ(0, e.num_choices);
+      DCHECK_EQ(0, e.num_options);
       DCHECK(!e.choices);
       return true;
     case FeatureEntry::MULTI_VALUE:
-      DCHECK_GT(e.num_choices, 0);
+      DCHECK_GT(e.num_options, 0);
       DCHECK(e.choices);
       DCHECK(e.choices[0].command_line_switch);
       DCHECK_EQ('\0', e.choices[0].command_line_switch[0]);
       return true;
     case FeatureEntry::ENABLE_DISABLE_VALUE:
-      DCHECK_EQ(3, e.num_choices);
+      DCHECK_EQ(3, e.num_options);
       DCHECK(!e.choices);
       DCHECK(e.command_line_switch);
       DCHECK(e.command_line_value);
       DCHECK(e.disable_command_line_switch);
       DCHECK(e.disable_command_line_value);
       return true;
     case FeatureEntry::FEATURE_VALUE:
-      DCHECK_EQ(3, e.num_choices);
+      DCHECK_EQ(3, e.num_options);
       DCHECK(!e.choices);
       DCHECK(e.feature);
       return true;
+    case FeatureEntry::FEATURE_WITH_VARIATIONS_VALUE:
+      DCHECK_GT(e.num_options, 2);
+      DCHECK(!e.choices);
+      DCHECK(e.feature);
+      DCHECK(e.feature_variations);
+      DCHECK(e.feature_trial);
+      return true;
   }
   NOTREACHED();
   return false;
 }
 
 // Returns true if none of this entry's options have been enabled.
 bool IsDefaultValue(const FeatureEntry& entry,
                     const std::set<std::string>& enabled_entries) {
   switch (entry.type) {
     case FeatureEntry::SINGLE_VALUE:
     case FeatureEntry::SINGLE_DISABLE_VALUE:
       return enabled_entries.count(entry.internal_name) == 0;
     case FeatureEntry::MULTI_VALUE:
     case FeatureEntry::ENABLE_DISABLE_VALUE:
     case FeatureEntry::FEATURE_VALUE:
-      for (int i = 0; i < entry.num_choices; ++i) {
-        if (enabled_entries.count(entry.NameForChoice(i)) > 0)
+    case FeatureEntry::FEATURE_WITH_VARIATIONS_VALUE:
+      for (int i = 0; i < entry.num_options; ++i) {
+        if (enabled_entries.count(entry.NameForOption(i)) > 0)
           return false;
       }
       return true;
   }
   NOTREACHED();
   return true;
 }
 
 // Returns the Value representing the choice data in the specified entry.
-base::Value* CreateChoiceData(const FeatureEntry& entry,
-                              const std::set<std::string>& enabled_entries) {
+base::Value* CreateOptionsData(const FeatureEntry& entry,
+                               const std::set<std::string>& enabled_entries) {
   DCHECK(entry.type == FeatureEntry::MULTI_VALUE ||
          entry.type == FeatureEntry::ENABLE_DISABLE_VALUE ||
-         entry.type == FeatureEntry::FEATURE_VALUE);
+         entry.type == FeatureEntry::FEATURE_VALUE ||
+         entry.type == FeatureEntry::FEATURE_WITH_VARIATIONS_VALUE);
   base::ListValue* result = new base::ListValue;
-  for (int i = 0; i < entry.num_choices; ++i) {
+  for (int i = 0; i < entry.num_options; ++i) {
     base::DictionaryValue* value = new base::DictionaryValue;
-    const std::string name = entry.NameForChoice(i);
+    const std::string name = entry.NameForOption(i);
     value->SetString("internal_name", name);
-    value->SetString("description", entry.DescriptionForChoice(i));
+    value->SetString("description", entry.DescriptionForOption(i));
     value->SetBoolean("selected", enabled_entries.count(name) > 0);
     result->Append(value);
   }
   return result;
 }
 
 }  // namespace
 
 // Keeps track of affected switches for each FeatureEntry, based on which
 // choice is selected for it.
@@ skipping 34 matching lines @@
   std::map<std::string, SwitchEntry> name_to_switch_map;
   for (size_t i = 0; i < num_feature_entries_; ++i) {
     const FeatureEntry& e = feature_entries_[i];
     switch (e.type) {
       case FeatureEntry::SINGLE_VALUE:
       case FeatureEntry::SINGLE_DISABLE_VALUE:
         AddSwitchMapping(e.internal_name, e.command_line_switch,
                          e.command_line_value, &name_to_switch_map);
         break;
       case FeatureEntry::MULTI_VALUE:
-        for (int j = 0; j < e.num_choices; ++j) {
-          AddSwitchMapping(e.NameForChoice(j), e.choices[j].command_line_switch,
+        for (int j = 0; j < e.num_options; ++j) {
+          AddSwitchMapping(e.NameForOption(j), e.choices[j].command_line_switch,
                            e.choices[j].command_line_value,
                            &name_to_switch_map);
         }
         break;
       case FeatureEntry::ENABLE_DISABLE_VALUE:
-        AddSwitchMapping(e.NameForChoice(0), std::string(), std::string(),
+        AddSwitchMapping(e.NameForOption(0), std::string(), std::string(),
                          &name_to_switch_map);
-        AddSwitchMapping(e.NameForChoice(1), e.command_line_switch,
+        AddSwitchMapping(e.NameForOption(1), e.command_line_switch,
                          e.command_line_value, &name_to_switch_map);
-        AddSwitchMapping(e.NameForChoice(2), e.disable_command_line_switch,
+        AddSwitchMapping(e.NameForOption(2), e.disable_command_line_switch,
                          e.disable_command_line_value, &name_to_switch_map);
         break;
       case FeatureEntry::FEATURE_VALUE:
-        AddFeatureMapping(e.NameForChoice(0), std::string(), false,
-                          &name_to_switch_map);
-        AddFeatureMapping(e.NameForChoice(1), e.feature->name, true,
-                          &name_to_switch_map);
-        AddFeatureMapping(e.NameForChoice(2), e.feature->name, false,
-                          &name_to_switch_map);
+      case FeatureEntry::FEATURE_WITH_VARIATIONS_VALUE:
+        for (int j = 0; j < e.num_options; ++j) {
+          FeatureEntry::State state = e.StateForOption(j);
+          if (state == FeatureEntry::State::DEFAULT) {
+            AddFeatureMapping(e.NameForOption(j), std::string(), false,
+                              &name_to_switch_map);
+          } else {
+            const std::string& key = e.NameForOption(j);

[Alexei Svitkine (slow), 2016/06/08 18:54:35]

Nit: Just inline this below

[jkrcal, 2016/06/09 09:55:15]

Done.

+            AddFeatureMapping(key, e.feature->name,
+                              state == FeatureEntry::State::ENABLED,
+                              &name_to_switch_map);
+          }
+        }
         break;
     }
   }
 
   AddSwitchesToCommandLine(enabled_entries, name_to_switch_map, sentinels,
                            command_line, enable_features_flag_name,
                            disable_features_flag_name);
 }
 
 bool FlagsState::IsRestartNeededToCommitChanges() {
@@ skipping 40 matching lines @@
     else
       needs_restart_ |= (enabled_entries.erase(internal_name) > 0);
   } else if (e->type == FeatureEntry::SINGLE_DISABLE_VALUE) {
     if (!enable)
       needs_restart_ |= enabled_entries.insert(internal_name).second;
     else
       needs_restart_ |= (enabled_entries.erase(internal_name) > 0);
   } else {
     if (enable) {
       // Enable the first choice.
-      needs_restart_ |= enabled_entries.insert(e->NameForChoice(0)).second;
+      needs_restart_ |= enabled_entries.insert(e->NameForOption(0)).second;
     } else {
       // Find the currently enabled choice and disable it.
-      for (int i = 0; i < e->num_choices; ++i) {
-        std::string choice_name = e->NameForChoice(i);
+      for (int i = 0; i < e->num_options; ++i) {
+        std::string choice_name = e->NameForOption(i);
         if (enabled_entries.find(choice_name) != enabled_entries.end()) {
           needs_restart_ = true;
           enabled_entries.erase(choice_name);
           // Continue on just in case there's a bug and more than one
           // entry for this choice was enabled.
         }
       }
     }
   }
 
@@ skipping 50 matching lines @@
   std::set<std::string> no_entries;
   flags_storage->SetFlags(no_entries);
 }
 
 void FlagsState::Reset() {
   needs_restart_ = false;
   flags_switches_.clear();
   appended_switches_.clear();
 }
 
+void FlagsState::RegisterFeatureVariationParameters(
+    FlagsStorage* flags_storage) {
+  std::set<std::string> enabled_entries;
+  GetSanitizedEnabledFlagsForCurrentPlatform(flags_storage, &enabled_entries);
+
+  for (size_t i = 0; i < num_feature_entries_; ++i) {
+    const FeatureEntry& e = feature_entries_[i];
+    if (e.type == FeatureEntry::FEATURE_WITH_VARIATIONS_VALUE) {
+      for (int j = 0; j < e.num_options; ++j) {
+        const std::string& key = e.NameForOption(j);
+        const FeatureEntry::FeatureVariation* variation =
+            e.VariationForOption(j);
+        if (enabled_entries.count(key) && variation != nullptr) {
+          // If the option is selected by the user & has variation, register it.
+          std::map<std::string, std::string> params;
+          for (int i = 0; i < variation->num_params; ++i) {
+            params[variation->params[i].param_name] =
+                variation->params[i].param_value;
+          }
+
+          bool success = variations::AssociateVariationParams(
+              e.feature_trial, kTrialGroupAboutFlags, params);
+          if (success) {
+            // Successful association also means that no group is created and
+            // selected for the trial. Thus, create the trial to make it active
+            // and to select the group.
+            // This way, the parameters cannot get overwritten in later phases
+            // (such as from the server).
+            base::FieldTrial* trial = base::FieldTrialList::CreateFieldTrial(
+                e.feature_trial, kTrialGroupAboutFlags);
+            if (!trial) {
+              DLOG(WARNING) << "Could not create the trial " << e.feature_trial
+                            << " with group " << kTrialGroupAboutFlags;
+            }
+          }
+        }

[Alexei Svitkine (slow), 2016/06/08 18:54:35]

This is a lot of nesting. Can you make the refactor code that processes a given
option (i.e. the inner block) into a helper function so that its more readable?

[jkrcal, 2016/06/09 09:55:15]

Done. I moved it out one block deeper, I think it makes more sense so.
(the helper function is called only for the variations that are really
selected).

+      }
+    }
+  }
+}
+
 void FlagsState::GetFlagFeatureEntries(
     FlagsStorage* flags_storage,
     FlagAccess access,
     base::ListValue* supported_entries,
     base::ListValue* unsupported_entries,
     base::Callback<bool(const FeatureEntry&)> skip_feature_entry) {
   std::set<std::string> enabled_entries;
   GetSanitizedEnabledFlags(flags_storage, &enabled_entries);
 
   int current_platform = GetCurrentPlatform();
@@ skipping 21 matching lines @@
       case FeatureEntry::SINGLE_DISABLE_VALUE:
         data->SetBoolean(
             "enabled",
             (!is_default_value && entry.type == FeatureEntry::SINGLE_VALUE) ||
                 (is_default_value &&
                  entry.type == FeatureEntry::SINGLE_DISABLE_VALUE));
         break;
       case FeatureEntry::MULTI_VALUE:
       case FeatureEntry::ENABLE_DISABLE_VALUE:
       case FeatureEntry::FEATURE_VALUE:
-        data->Set("choices", CreateChoiceData(entry, enabled_entries));
+      case FeatureEntry::FEATURE_WITH_VARIATIONS_VALUE:
+        data->Set("options", CreateOptionsData(entry, enabled_entries));
         break;
     }
 
     bool supported = (entry.supported_platforms & current_platform) != 0;
 #if defined(OS_CHROMEOS)
     if (access == kOwnerAccessToFlags &&
         (entry.supported_platforms & kOsCrOSOwnerOnly) != 0) {
       supported = true;
     }
 #endif
@@ skipping 199 matching lines @@
   }
 
   std::set<std::string> new_enabled_entries =
       base::STLSetIntersection<std::set<std::string>>(platform_entries,
                                                       *result);
 
   result->swap(new_enabled_entries);
 }
 
 }  // namespace flags_ui