Add support for variations controlled overriding UI strings to the variations service.

components/variations/variations_seed_processor_unittest.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_seed_processor.h"
 
 #include <vector>
 
+#include "base/bind.h"
 #include "base/command_line.h"
 #include "base/strings/string_split.h"
+#include "base/strings/utf_string_conversions.h"
 #include "components/variations/processed_study.h"
 #include "components/variations/variations_associated_data.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace chrome_variations {
 
 namespace {
 
 // Converts |time| to Study proto format.
 int64 TimeToProtoTime(const base::Time& time) {
@@ skipping 46 matching lines @@
 bool IsFieldTrialActive(const std::string& trial_name) {
   base::FieldTrial::ActiveGroups active_groups;
   base::FieldTrialList::GetActiveFieldTrialGroups(&active_groups);
   for (size_t i = 0; i < active_groups.size(); ++i) {
     if (active_groups[i].trial_name == trial_name)
       return true;
   }
   return false;
 }
 
+class TestOverrideStringCallback {
+ public:
+  typedef std::map<uint32_t, base::string16> OverrideMap;
+
+  TestOverrideStringCallback() :
+      callback_(base::Bind(
+          &TestOverrideStringCallback::override, base::Unretained(this))) {
+  }
+
+  const VariationsSeedProcessor::UIStringOverrideCallback& callback() const {
+    return callback_;
+  }
+
+  const OverrideMap& overrides() const { return overrides_; }
+
+ private:
+  void override(uint32_t hash, const base::string16& string) {

[Alexei Svitkine (slow), 2014/07/03 17:54:41]

Nit: I don't think this should use hacker_style. Instead, make it a proper
method.

[jwd, 2014/07/07 15:52:21]

Done.

+    overrides_[hash] = string;
+  }
+
+  VariationsSeedProcessor::UIStringOverrideCallback callback_;
+  OverrideMap overrides_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestOverrideStringCallback);
+};
+
 }  // namespace
 
 class VariationsSeedProcessorTest : public ::testing::Test {
  public:
   VariationsSeedProcessorTest() {
   }
 
   virtual ~VariationsSeedProcessorTest() {
     // Ensure that the maps are cleared between tests, since they are stored as
     // process singletons.
     testing::ClearAllVariationIDs();
     testing::ClearAllVariationParams();
   }
 
   bool CreateTrialFromStudy(const Study* study) {
     ProcessedStudy processed_study;
     if (processed_study.Init(study, false)) {
-      VariationsSeedProcessor().CreateTrialFromStudy(processed_study);
+      VariationsSeedProcessor().CreateTrialFromStudy(
+          processed_study, override_callback_.callback());
       return true;
     }
     return false;
   }
 
+ protected:
+  TestOverrideStringCallback override_callback_;
+
  private:
   DISALLOW_COPY_AND_ASSIGN(VariationsSeedProcessorTest);
 };
 
 TEST_F(VariationsSeedProcessorTest, AllowForceGroupAndVariationId) {
   CommandLine::ForCurrentProcess()->AppendSwitch(kForcingFlag1);
 
   base::FieldTrialList field_trial_list(NULL);
 
   Study study = CreateStudyWithFlagGroups(100, 0, 0);
@@ skipping 79 matching lines @@
 
   const base::Version version("20.0.0.0");
 
   // Check that adding [expired, non-expired] activates the non-expired one.
   ASSERT_EQ(std::string(), base::FieldTrialList::FindFullName(kTrialName));
   {
     base::FieldTrialList field_trial_list(NULL);
     study1->set_expiry_date(TimeToProtoTime(year_ago));
     seed_processor.CreateTrialsFromSeed(seed, "en-CA", base::Time::Now(),
                                         version, Study_Channel_STABLE,
-                                        Study_FormFactor_DESKTOP, "");
+                                        Study_FormFactor_DESKTOP, "",
+                                        override_callback_.callback());
     EXPECT_EQ(kGroup1Name, base::FieldTrialList::FindFullName(kTrialName));
   }
 
   // Check that adding [non-expired, expired] activates the non-expired one.
   ASSERT_EQ(std::string(), base::FieldTrialList::FindFullName(kTrialName));
   {
     base::FieldTrialList field_trial_list(NULL);
     study1->clear_expiry_date();
     study2->set_expiry_date(TimeToProtoTime(year_ago));
     seed_processor.CreateTrialsFromSeed(seed, "en-CA", base::Time::Now(),
                                         version, Study_Channel_STABLE,
-                                        Study_FormFactor_DESKTOP, "");
+                                        Study_FormFactor_DESKTOP, "",
+                                        override_callback_.callback());
     EXPECT_EQ(kGroup1Name, base::FieldTrialList::FindFullName(kTrialName));
   }
 }
 
+TEST_F(VariationsSeedProcessorTest, OverrideUIStrings) {
+  base::FieldTrialList field_trial_list(NULL);
+
+  Study study;
+  study.set_name("Study1");
+  study.set_default_experiment_name("B");
+  study.set_activation_type(Study_ActivationType_ACTIVATION_AUTO);
+
+  Study_Experiment* experiment1 = AddExperiment("A", 0, &study);
+  Study_Experiment_OverrideUIString* override =
+      experiment1->add_override_ui_string();
+
+  override->set_name_hash(1234);
+  override->set_value("test");
+
+  Study_Experiment* experiment2 = AddExperiment("B", 1, &study);
+
+  EXPECT_TRUE(CreateTrialFromStudy(&study));
+
+  const TestOverrideStringCallback::OverrideMap& overrides =
+      override_callback_.overrides();
+
+  EXPECT_TRUE(overrides.empty());
+
+  study.set_name("Study2");
+  experiment1->set_probability_weight(1);
+  experiment2->set_probability_weight(0);
+
+  EXPECT_TRUE(CreateTrialFromStudy(&study));
+
+  EXPECT_EQ(1u, overrides.size());
+  TestOverrideStringCallback::OverrideMap::const_iterator it =
+      overrides.find(1234);
+  EXPECT_NE(overrides.end(), it);
+  EXPECT_EQ(base::ASCIIToUTF16("test"), it->second);
+}
+
+TEST_F(VariationsSeedProcessorTest, OverrideUIStringsWithForcingFlag) {
+  Study study = CreateStudyWithFlagGroups(100, 0, 0);
+  ASSERT_EQ(kForcingFlag1, study.experiment(1).forcing_flag());
+
+  study.set_activation_type(Study_ActivationType_ACTIVATION_AUTO);
+  Study_Experiment_OverrideUIString* override =
+      study.mutable_experiment(1)->add_override_ui_string();
+  override->set_name_hash(1234);
+  override->set_value("test");
+
+  CommandLine::ForCurrentProcess()->AppendSwitch(kForcingFlag1);
+  base::FieldTrialList field_trial_list(NULL);
+  EXPECT_TRUE(CreateTrialFromStudy(&study));
+  EXPECT_EQ(kFlagGroup1Name, base::FieldTrialList::FindFullName(study.name()));
+
+  const TestOverrideStringCallback::OverrideMap& overrides =
+      override_callback_.overrides();
+  EXPECT_EQ(1u, overrides.size());
+  TestOverrideStringCallback::OverrideMap::const_iterator it =
+      overrides.find(1234);
+  EXPECT_NE(overrides.end(), it);
+  EXPECT_EQ(base::ASCIIToUTF16("test"), it->second);
+}
+
 TEST_F(VariationsSeedProcessorTest, ValidateStudy) {
   Study study;
   study.set_default_experiment_name("def");
   AddExperiment("abc", 100, &study);
   Study_Experiment* default_group = AddExperiment("def", 200, &study);
 
   ProcessedStudy processed_study;
   EXPECT_TRUE(processed_study.Init(&study, false));
   EXPECT_EQ(300, processed_study.total_probability());
 
@@ skipping 90 matching lines @@
   study3->set_name("C");
   study3->set_default_experiment_name("Default");
   AddExperiment("CC", 100, study3);
   AddExperiment("Default", 0, study3);
   study3->set_activation_type(Study_ActivationType_ACTIVATION_EXPLICIT);
 
   VariationsSeedProcessor seed_processor;
   seed_processor.CreateTrialsFromSeed(seed, "en-CA", base::Time::Now(),
                                       base::Version("20.0.0.0"),
                                       Study_Channel_STABLE,
-                                      Study_FormFactor_DESKTOP, "");
+                                      Study_FormFactor_DESKTOP, "",
+                                      override_callback_.callback());
 
   // Non-specified and ACTIVATION_EXPLICIT should not start active, but
   // ACTIVATION_AUTO should.
   EXPECT_FALSE(IsFieldTrialActive("A"));
   EXPECT_TRUE(IsFieldTrialActive("B"));
   EXPECT_FALSE(IsFieldTrialActive("C"));
 
   EXPECT_EQ("AA", base::FieldTrialList::FindFullName("A"));
   EXPECT_EQ("BB", base::FieldTrialList::FindFullName("B"));
   EXPECT_EQ("CC", base::FieldTrialList::FindFullName("C"));
@@ skipping 13 matching lines @@
   study.set_activation_type(Study_ActivationType_ACTIVATION_AUTO);
 
   EXPECT_TRUE(CreateTrialFromStudy(&study));
   EXPECT_TRUE(IsFieldTrialActive(kFlagStudyName));
 
   EXPECT_EQ(kFlagGroup1Name,
             base::FieldTrialList::FindFullName(kFlagStudyName));
 }
 
 }  // namespace chrome_variations