Add a mechanism to force parameters of a group to a specific value.

components/variations/variations_associated_data.cc

 // Copyright 2013 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/variations/variations_associated_data.h"
 
 #include <map>
 #include <utility>
 #include <vector>
 
 #include "base/memory/singleton.h"
+#include "base/strings/string_split.h"
 
 namespace variations {
 
 namespace {
 
 // The internal singleton accessor for the map, used to keep it thread-safe.
 class GroupMapAccessor {
  public:
   typedef std::map<ActiveGroupId, VariationID, ActiveGroupIdCompare>
       GroupToIDMap;
@@ skipping 186 matching lines @@
 }
 
 bool AssociateVariationParams(
     const std::string& trial_name,
     const std::string& group_name,
     const std::map<std::string, std::string>& params) {
   return VariationsParamAssociator::GetInstance()->AssociateVariationParams(
       trial_name, group_name, params);
 }
 
+struct VarationsParams {
+  std::string GroupName;
+  std::map<std::string, std::string> Params;
+};
+
+bool AssociateParamsFromString(const std::string& varations_string) {
+  std::map <std::string, VarationsParams> data;
+  std::vector<std::string> tokens;
+  base::SplitString(varations_string, '/', &tokens);
+  if (tokens.size() % 2 == 0) {
+    // Build out parameters
+    for (int i = 0; i < tokens.size(); i += 2) {
+      std::vector<std::string> key;
+      base::SplitString(tokens[i], '.', &key);
+      DCHECK(key.size() == 3) << "Expecting format Trial.Group.Key";
+      if (key.size() == 3) {
+        const std::string& trial = key[0];
+        const std::string& group = key[1];
+        const std::string& param = key[2];
+        const std::string& value = tokens[i + 1];
+        const auto& iter = data.find(trial);
+        if (iter != data.end()) {
+          if (iter->second.GroupName == group) {
+            iter->second.Params[param] = value;
+          }
+        }
+        else {
+          VarationsParams vp;
+          vp.GroupName = group;
+          vp.Params[param] = value;
+          data[trial] = vp;
+        }
+      }
+    }
+    // Associate parameters
+    for (const auto& iter : data) {
+      const std::string& trial = iter.first;
+      const VarationsParams& params = iter.second;
+      AssociateVariationParams(trial, params.GroupName, params.Params);
+    }
+  } else {
+    DCHECK(false) << "Expecting pairs of values";
+    return false;
+  }
+  return true;
+}
+
 bool GetVariationParams(const std::string& trial_name,
                         std::map<std::string, std::string>* params) {
   return VariationsParamAssociator::GetInstance()->GetVariationParams(
       trial_name, params);
 }
 
 std::string GetVariationParamValue(const std::string& trial_name,
                                    const std::string& param_name) {
   std::map<std::string, std::string> params;
   if (GetVariationParams(trial_name, &params)) {
@@ skipping 12 matching lines @@
   GroupMapAccessor::GetInstance()->ClearAllMapsForTesting();
 }
 
 void ClearAllVariationParams() {
   VariationsParamAssociator::GetInstance()->ClearAllParamsForTesting();
 }
 
 }  // namespace testing
 
 }  // namespace variations