Allows to manually change the stored permanent country in Variations from the translate-internals d…

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 <stddef.h>
 #include <stdint.h>
 #include <utility>
 
@@ skipping 13 matching lines @@
 #include "components/network_time/network_time_tracker.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/pref_service.h"
 #include "components/variations/pref_names.h"
 #include "components/variations/proto/variations_seed.pb.h"
 #include "components/variations/variations_seed_processor.h"
 #include "components/variations/variations_seed_simulator.h"
 #include "components/variations/variations_switches.h"
 #include "components/variations/variations_url_constants.h"
-#include "components/version_info/version_info.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/base/network_change_notifier.h"
 #include "net/base/url_util.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_status_code.h"
 #include "net/http/http_util.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_request_status.h"
 #include "ui/base/device_form_factor.h"
@@ skipping 790 matching lines @@
     if (!is_pref_valid)
       local_state_->ClearPref(prefs::kVariationsPermanentConsistencyCountry);
     // If we've never received a country code from the server, use an empty
     // country so that it won't pass any filters that specifically include
     // countries, but so that it will pass any filters that specifically exclude
     // countries.
     return std::string();
   }
 
   // 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);
+  StorePermanentCountry(version, latest_country);
   return latest_country;
 }
 
+void VariationsService::StorePermanentCountry(const base::Version& version,
+                                              const std::string& country) {
+  base::ListValue new_list_value;
+  new_list_value.AppendString(version.GetString());
+  new_list_value.AppendString(country);
+  local_state_->Set(prefs::kVariationsPermanentConsistencyCountry,
+                    new_list_value);
+}
+
 std::string VariationsService::GetStoredPermanentCountry() {
   const base::ListValue* list_value =
       local_state_->GetList(prefs::kVariationsPermanentConsistencyCountry);
   std::string stored_country;
 
   if (list_value->GetSize() == 2) {
     list_value->GetString(1, &stored_country);
   }
 
   return stored_country;
 }
 
+bool VariationsService::OverrideStoredPermanentCountry(
+    const std::string& country_override) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  if (country_override.empty())
+    return false;
+
+  const base::ListValue* list_value =
+      local_state_->GetList(prefs::kVariationsPermanentConsistencyCountry);
+
+  std::string stored_country;
+  const bool got_stored_country =
+      list_value->GetSize() == 2 && list_value->GetString(1, &stored_country);
+
+  if (got_stored_country && stored_country == country_override)
+    return false;
+
+  base::Version version(version_info::GetVersionNumber());
+  StorePermanentCountry(version, country_override);
+  return true;
+}
+
 }  // namespace variations