Allow embedders to share code to override UI strings.

components/variations/service/variations_service.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 "base/build_time.h"
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/sparse_histogram.h"
@@ skipping 185 matching lines @@
   headers->EnumerateHeader(NULL, name, &value);
   return value;
 }
 
 }  // namespace
 
 VariationsService::VariationsService(
     scoped_ptr<VariationsServiceClient> client,
     scoped_ptr<web_resource::ResourceRequestAllowedNotifier> notifier,
     PrefService* local_state,
-    metrics::MetricsStateManager* state_manager)
+    metrics::MetricsStateManager* state_manager,
+    const UIStringOverrider& ui_string_overrider)
     : client_(client.Pass()),
+      ui_string_overrider_(ui_string_overrider),
       local_state_(local_state),
       state_manager_(state_manager),
       policy_pref_service_(local_state),
       seed_store_(local_state),
       create_trials_from_seed_called_(false),
       initial_request_completed_(false),
       disable_deltas_for_next_request_(false),
       resource_request_allowed_notifier_(notifier.Pass()),
       request_count_(0),
       weak_ptr_factory_(this) {
@@ skipping 15 matching lines @@
   const base::Version current_version(version_info::GetVersionNumber());
   if (!current_version.IsValid())
     return false;
 
   variations::Study_Channel channel =
       GetChannelForVariations(client_->GetChannel());
   UMA_HISTOGRAM_SPARSE_SLOWLY("Variations.UserChannel", channel);
 
   const std::string latest_country =
       local_state_->GetString(prefs::kVariationsCountry);
-  // Note that passing |client_| via base::Unretained below is safe because
-  // the callback is executed synchronously.
+  // Note that passing |&ui_string_overrider_| via base::Unretained below is
+  // safe because the callback is executed synchronously.
   variations::VariationsSeedProcessor().CreateTrialsFromSeed(
       seed, client_->GetApplicationLocale(),
       GetReferenceDateForExpiryChecks(local_state_), current_version, channel,
       GetCurrentFormFactor(), GetHardwareClass(), latest_country,
       LoadPermanentConsistencyCountry(current_version, latest_country),
-      base::Bind(&VariationsServiceClient::OverrideUIString,
-                 base::Unretained(client_.get())));
+      base::Bind(&UIStringOverrider::OverrideUIString,
+                 base::Unretained(&ui_string_overrider_)));

[Alexei Svitkine (slow), 2015/09/24 21:51:23]

Can this pass a ref to the object instead of a callback?

[blundell, 2015/09/25 13:06:56]

//components/variations can't depend on //ui/base, as the latter introduces a
dependency on //net, which causes Cronet to choke. :(

[Alexei Svitkine (slow), 2015/09/25 14:45:56]

Gotcha. Maybe worth mentioning that in the comment above so someone doesn't try
to make the same mistake later.

[sdefresne, 2015/09/28 08:57:32]

Acknowledged and added a comment.

 
   const base::Time now = base::Time::Now();
 
   // Log the "freshness" of the seed that was just used. The freshness is the
   // time between the last successful seed download and now.
   const int64 last_fetch_time_internal =
       local_state_->GetInt64(prefs::kVariationsLastFetchTime);
   if (last_fetch_time_internal) {
     const base::TimeDelta delta =
         now - base::Time::FromInternalValue(last_fetch_time_internal);
@@ skipping 146 matching lines @@
   // it according to a value stored in the User Policy.
   registry->RegisterStringPref(prefs::kVariationsRestrictParameter,
                                std::string());
 }
 
 // static
 scoped_ptr<VariationsService> VariationsService::Create(
     scoped_ptr<VariationsServiceClient> client,
     PrefService* local_state,
     metrics::MetricsStateManager* state_manager,
-    const char* disable_network_switch) {
+    const char* disable_network_switch,
+    const UIStringOverrider& ui_string_overrider) {
   scoped_ptr<VariationsService> result;
 #if !defined(GOOGLE_CHROME_BUILD)
   // Unless the URL was provided, unsupported builds should return NULL to
   // indicate that the service should not be used.
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kVariationsServerURL)) {
     DVLOG(1) << "Not creating VariationsService in unofficial build without --"
              << switches::kVariationsServerURL << " specified.";
     return result.Pass();
   }
 #endif
   result.reset(new VariationsService(
       client.Pass(),
       make_scoped_ptr(new web_resource::ResourceRequestAllowedNotifier(
           local_state, disable_network_switch)),
-      local_state, state_manager));
+      local_state, state_manager, ui_string_overrider));
   return result.Pass();
 }
 
 // static
 scoped_ptr<VariationsService> VariationsService::CreateForTesting(
     scoped_ptr<VariationsServiceClient> client,
     PrefService* local_state) {
   return make_scoped_ptr(new VariationsService(
       client.Pass(),
       make_scoped_ptr(new web_resource::ResourceRequestAllowedNotifier(
           local_state, nullptr)),
-      local_state, nullptr));
+      local_state, nullptr, UIStringOverrider()));
 }
 
 void VariationsService::DoActualFetch() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!pending_seed_request_);
 
   pending_seed_request_ = net::URLFetcher::Create(0, variations_server_url_,
                                                   net::URLFetcher::GET, this);
   data_use_measurement::DataUseUserData::AttachToFetcher(
       pending_seed_request_.get(),
@@ skipping 298 matching lines @@
   // Otherwise, update the pref with the current Chrome version and country.
   base::ListValue new_list_value;
   new_list_value.AppendString(version.GetString());
   new_list_value.AppendString(latest_country);
   local_state_->Set(prefs::kVariationsPermanentConsistencyCountry,
                     new_list_value);
   return latest_country;
 }
 
 }  // namespace variations