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"
+
+// #include "net/base/escape.h"

[danduong, 2015/04/29 01:09:12]

Any suggestions on where this code should live? We have a restriction on
components/variations that prevent including net.

[Alexei Svitkine (slow), 2015/04/29 15:34:24]

Couple options.

One is we can put this code in chrome/

It can still call AssociateVariationParams() in the component.

Another would be to use a different escaping mechanism - since it doesn't
necessarily need the URL escaping scheme (in fact might be preferable not to use
it - not sure if the % signs in URL escaping play well with some of the shells -
i.e. on Windows %s are used for environment variable expansion).

 
 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);
 }
 
+bool AssociateParamsFromString(const std::string& varations_string) {
+  // Format: Trial1.Group1:k1/v1/k2/v2,Trial2.Group2:k1/v1/k2/v2
+  std::vector<std::string> experiment_groups;
+  base::SplitString(varations_string, ',', &experiment_groups);
+  for (auto& experiment_group : experiment_groups) {
+    std::vector<std::string> experiment;
+    base::SplitString(experiment_group, ':', &experiment);
+    if (experiment.size() == 2) {
+      std::vector<std::string> group_parts;
+      base::SplitString(experiment[0], '.', &group_parts);
+      if (group_parts.size() == 2) {
+        std::vector<std::string> key_values;
+        base::SplitString(experiment[1], '/', &key_values);
+        if (key_values.size() % 2 == 0) {
+          std::map <std::string, std::string> params;
+          for (int i = 0; i < key_values.size(); i += 2) {
+            std::string key = net::UnescapeURLComponent(key_values[i],
+                net::UnescapeRule::URL_SPECIAL_CHARS);
+            std::string value = net::UnescapeURLComponent(key_values[i + 1],
+                net::UnescapeRule::URL_SPECIAL_CHARS);
+            params[key] = value;
+          }
+          std::string trial = net::UnescapeURLComponent(group_parts[0],
+              net::UnescapeRule::URL_SPECIAL_CHARS);
+          std::string group = net::UnescapeURLComponent(group_parts[1],
+              net::UnescapeRule::URL_SPECIAL_CHARS);
+          AssociateVariationParams(trial, group, params);
+        }
+      }
+    }
+  }
+  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