Allow embedders to share code to override UI strings.

components/variations/service/variations_service_unittest.cc

 // Copyright (c) 2012 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/service/variations_service.h"
 
 #include <vector>
 
 #include "base/base64.h"
 #include "base/json/json_string_value_serializer.h"
@@ skipping 39 matching lines @@
   }
   version_info::Channel GetChannel() override {
     return version_info::Channel::UNKNOWN;
   }
   bool OverridesRestrictParameter(std::string* parameter) override {
     if (restrict_parameter_.empty())
       return false;
     *parameter = restrict_parameter_;
     return true;
   }
-  void OverrideUIString(uint32_t hash, const base::string16& string) override {}
   void OnInitialStartup() override {}
 
   void set_restrict_parameter(std::string value) {
     restrict_parameter_ = value;
   }
 
  private:
   std::string restrict_parameter_;
 
   DISALLOW_COPY_AND_ASSIGN(TestVariationsServiceClient);
 };
 
 // A test class used to validate expected functionality in VariationsService.
 class TestVariationsService : public VariationsService {
  public:
   TestVariationsService(
       scoped_ptr<web_resource::TestRequestAllowedNotifier> test_notifier,
       PrefService* local_state)
       : VariationsService(make_scoped_ptr(new TestVariationsServiceClient()),
                           test_notifier.Pass(),
                           local_state,
-                          NULL),
+                          NULL,
+                          UIStringOverrider()),
         intercepts_fetch_(true),
         fetch_attempted_(false),
         seed_stored_(false) {
     // Set this so StartRepeatedVariationsSeedFetch can be called in tests.
     SetCreateTrialsFromSeedCalledForTesting(true);
   }
 
   ~TestVariationsService() override {}
 
   void set_intercepts_fetch(bool value) {
@@ skipping 133 matching lines @@
   const std::string default_variations_url =
       VariationsService::GetDefaultVariationsServerURLForTesting();
 
   std::string value;
   scoped_ptr<TestVariationsServiceClient> client =
       make_scoped_ptr(new TestVariationsServiceClient());
   TestVariationsServiceClient* raw_client = client.get();
   VariationsService service(
       client.Pass(),
       make_scoped_ptr(new web_resource::TestRequestAllowedNotifier(&prefs)),
-      &prefs, NULL);
+      &prefs, NULL, UIStringOverrider());
   GURL url = service.GetVariationsServerURL(&prefs, std::string());
   EXPECT_TRUE(base::StartsWith(url.spec(), default_variations_url,
                                base::CompareCase::SENSITIVE));
   EXPECT_FALSE(net::GetValueForKeyInQuery(url, "restrict", &value));
 
   prefs.SetString(prefs::kVariationsRestrictParameter, "restricted");
   url = service.GetVariationsServerURL(&prefs, std::string());
   EXPECT_TRUE(base::StartsWith(url.spec(), default_variations_url,
                                base::CompareCase::SENSITIVE));
   EXPECT_TRUE(net::GetValueForKeyInQuery(url, "restrict", &value));
@@ skipping 96 matching lines @@
     net::HTTP_INTERNAL_SERVER_ERROR,
     net::HTTP_SERVICE_UNAVAILABLE,
   };
 
   TestingPrefServiceSimple prefs;
   VariationsService::RegisterPrefs(prefs.registry());
 
   VariationsService service(
       make_scoped_ptr(new TestVariationsServiceClient()),
       make_scoped_ptr(new web_resource::TestRequestAllowedNotifier(&prefs)),
-      &prefs, NULL);
+      &prefs, NULL, UIStringOverrider());
   service.variations_server_url_ =
       service.GetVariationsServerURL(&prefs, std::string());
   for (size_t i = 0; i < arraysize(non_ok_status_codes); ++i) {
     net::TestURLFetcherFactory factory;
     service.DoActualFetch();
     EXPECT_TRUE(prefs.FindPreference(prefs::kVariationsSeed)->IsDefaultValue());
 
     net::TestURLFetcher* fetcher = factory.GetFetcherByID(0);
     SimulateServerResponse(non_ok_status_codes[i], fetcher);
     service.OnURLFetchComplete(fetcher);
@@ skipping 27 matching lines @@
   EXPECT_TRUE(service.seed_stored());
   EXPECT_EQ("test", service.stored_country());
 }
 
 TEST_F(VariationsServiceTest, Observer) {
   TestingPrefServiceSimple prefs;
   VariationsService::RegisterPrefs(prefs.registry());
   VariationsService service(
       make_scoped_ptr(new TestVariationsServiceClient()),
       make_scoped_ptr(new web_resource::TestRequestAllowedNotifier(&prefs)),
-      &prefs, NULL);
+      &prefs, NULL, UIStringOverrider());
 
   struct {
     int normal_count;
     int best_effort_count;
     int critical_count;
     int expected_best_effort_notifications;
     int expected_crtical_notifications;
   } cases[] = {
       {0, 0, 0, 0, 0},
       {1, 0, 0, 0, 0},
@@ skipping 79 matching lines @@
       {"badversion,ca", "20.0.0.0", nullptr, "", "",
        VariationsService::LOAD_COUNTRY_INVALID_PREF_NO_SEED},
   };
 
   for (const auto& test : test_cases) {
     TestingPrefServiceSimple prefs;
     VariationsService::RegisterPrefs(prefs.registry());
     VariationsService service(
         make_scoped_ptr(new TestVariationsServiceClient()),
         make_scoped_ptr(new web_resource::TestRequestAllowedNotifier(&prefs)),
-        &prefs, NULL);
+        &prefs, NULL, UIStringOverrider());
 
     if (test.pref_value_before) {
       base::ListValue list_value;
       for (const std::string& component :
            base::SplitString(test.pref_value_before, ",", base::TRIM_WHITESPACE,
                              base::SPLIT_WANT_ALL)) {
         list_value.AppendString(component);
       }
       prefs.Set(prefs::kVariationsPermanentConsistencyCountry, list_value);
     }
@@ skipping 23 matching lines @@
         << test.pref_value_before << ", " << test.version << ", "
         << test.latest_country_code;
 
     histogram_tester.ExpectUniqueSample(
         "Variations.LoadPermanentConsistencyCountryResult",
         test.expected_result, 1);
   }
 }
 
 }  // namespace variations