Add other variations (with ids) for NTPSnippets to 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 <memory>
 #include <utility>
 
 #include "base/callback.h"
@@ skipping 418 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::RegisterAllFeatureVariationParameters(
+std::vector<std::string> FlagsState::RegisterAllFeatureVariationParameters(
     FlagsStorage* flags_storage,
     base::FeatureList* feature_list) {
   std::set<std::string> enabled_entries;
   GetSanitizedEnabledFlagsForCurrentPlatform(flags_storage, &enabled_entries);
+  std::vector<std::string> variation_ids;
 
   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 FeatureEntry::FeatureVariation* variation =
             e.VariationForOption(j);
         if (e.StateForOption(j) == FeatureEntry::FeatureState::ENABLED &&
             enabled_entries.count(e.NameForOption(j))) {
           // If the option is selected by the user & has variation, register it.
           base::FieldTrial* field_trial = RegisterFeatureVariationParameters(
               e.feature_trial_name, variation);
 
           if (!field_trial)
             continue;
           feature_list->RegisterFieldTrialOverride(
               e.feature->name,
               base::FeatureList::OverrideState::OVERRIDE_ENABLE_FEATURE,
               field_trial);
+
+          if (variation && variation->variation_id)
+            variation_ids.push_back(variation->variation_id);
         }
       }
     }
   }
+  return variation_ids;
 }
 
 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);
@@ skipping 244 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