BASELINE: Update Chromium to 55.0.2883.105

And updates ninja to 1.7.2

Change-Id: I20d43c737f82764d857ada9a55586901b18b9243
Reviewed-by: Michael Brüning <michael.bruning@qt.io>

23 files changed, 198 insertions, 127 deletions

diff --git a/chromium/components/variations/BUILD.gn b/chromium/components/variations/BUILD.gn
index 32c71f2210f..f4e62354bf9 100644
--- a/chromium/components/variations/BUILD.gn
+++ b/chromium/components/variations/BUILD.gn
@@ -6,7 +6,7 @@ if (is_android) {
   import("//build/config/android/rules.gni")
 }
 
-source_set("variations") {
+static_library("variations") {
   sources = [
     "active_field_trials.cc",
     "active_field_trials.h",
@@ -82,7 +82,6 @@ source_set("variations") {
 }
 
 if (is_android) {
-  # GYP: //components/variations.gypi:variations_jni_headers
   generate_jni("jni") {
     sources = [
       "android/java/src/org/chromium/components/variations/VariationsAssociatedData.java",
diff --git a/chromium/components/variations/android/BUILD.gn b/chromium/components/variations/android/BUILD.gn
index 0bcadfddab0..e557e9ea27d 100644
--- a/chromium/components/variations/android/BUILD.gn
+++ b/chromium/components/variations/android/BUILD.gn
@@ -4,7 +4,6 @@
 
 import("//build/config/android/rules.gni")
 
-# GYP: //components/variations.gypi:variations_java
 android_library("variations_java") {
   deps = [
     "//base:base_java",
diff --git a/chromium/components/variations/android/variations_associated_data_android.cc b/chromium/components/variations/android/variations_associated_data_android.cc
index 42e5ae18875..1dd80969781 100644
--- a/chromium/components/variations/android/variations_associated_data_android.cc
+++ b/chromium/components/variations/android/variations_associated_data_android.cc
@@ -13,6 +13,8 @@
 
 using base::android::ConvertJavaStringToUTF8;
 using base::android::ConvertUTF8ToJavaString;
+using base::android::JavaParamRef;
+using base::android::ScopedJavaLocalRef;
 
 namespace variations {
 
diff --git a/chromium/components/variations/android/variations_seed_bridge.cc b/chromium/components/variations/android/variations_seed_bridge.cc
index 5c2788bb7cd..f5b73e9a2ec 100644
--- a/chromium/components/variations/android/variations_seed_bridge.cc
+++ b/chromium/components/variations/android/variations_seed_bridge.cc
@@ -43,10 +43,6 @@ ScopedJavaLocalRef<jbyteArray> StringToJavaByteArray(
 namespace variations {
 namespace android {
 
-bool RegisterVariationsSeedBridge(JNIEnv* env) {
-  return RegisterNativesImpl(env);
-}
-
 void GetVariationsFirstRunSeed(std::string* seed_data,
                                std::string* seed_signature,
                                std::string* seed_country,
@@ -93,10 +89,10 @@ void SetJavaFirstRunPrefsForTesting(const std::string& seed_data,
                                     bool is_gzip_compressed) {
   JNIEnv* env = AttachCurrentThread();
   Java_VariationsSeedBridge_setVariationsFirstRunSeed(
-      env, GetApplicationContext(), StringToJavaByteArray(env, seed_data).obj(),
-      ConvertUTF8ToJavaString(env, seed_signature).obj(),
-      ConvertUTF8ToJavaString(env, seed_country).obj(),
-      ConvertUTF8ToJavaString(env, response_date).obj(),
+      env, GetApplicationContext(), StringToJavaByteArray(env, seed_data),
+      ConvertUTF8ToJavaString(env, seed_signature),
+      ConvertUTF8ToJavaString(env, seed_country),
+      ConvertUTF8ToJavaString(env, response_date),
       static_cast<jboolean>(is_gzip_compressed));
 }
 
diff --git a/chromium/components/variations/android/variations_seed_bridge.h b/chromium/components/variations/android/variations_seed_bridge.h
index 85e633f7736..c83f6f39e67 100644
--- a/chromium/components/variations/android/variations_seed_bridge.h
+++ b/chromium/components/variations/android/variations_seed_bridge.h
@@ -11,8 +11,6 @@
 namespace variations {
 namespace android {
 
-bool RegisterVariationsSeedBridge(JNIEnv* env);
-
 // Return the first run seed data pulled from the Java side of application.
 void GetVariationsFirstRunSeed(std::string* seed_data,
                                std::string* seed_signature,
diff --git a/chromium/components/variations/entropy_provider_unittest.cc b/chromium/components/variations/entropy_provider_unittest.cc
index 3c679dd0bc1..cde08e0aed9 100644
--- a/chromium/components/variations/entropy_provider_unittest.cc
+++ b/chromium/components/variations/entropy_provider_unittest.cc
@@ -13,6 +13,7 @@
 
 #include "base/guid.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "components/variations/metrics_util.h"
@@ -189,7 +190,8 @@ TEST(EntropyProviderTest, UseOneTimeRandomizationSHA1) {
   // Note that depending on the one-time random initialization, they
   // _might_ actually give the same result, but we know that given
   // the particular client_id we use for unit tests they won't.
-  base::FieldTrialList field_trial_list(new SHA1EntropyProvider("client_id"));
+  base::FieldTrialList field_trial_list(
+      base::MakeUnique<SHA1EntropyProvider>("client_id"));
   const int kNoExpirationYear = base::FieldTrialList::kNoExpirationYear;
   scoped_refptr<base::FieldTrial> trials[] = {
       base::FieldTrialList::FactoryGetFieldTrial(
@@ -219,7 +221,7 @@ TEST(EntropyProviderTest, UseOneTimeRandomizationPermuted) {
   // _might_ actually give the same result, but we know that given
   // the particular client_id we use for unit tests they won't.
   base::FieldTrialList field_trial_list(
-      new PermutedEntropyProvider(1234, kMaxLowEntropySize));
+      base::MakeUnique<PermutedEntropyProvider>(1234, kMaxLowEntropySize));
   const int kNoExpirationYear = base::FieldTrialList::kNoExpirationYear;
   scoped_refptr<base::FieldTrial> trials[] = {
       base::FieldTrialList::FactoryGetFieldTrial(
@@ -245,7 +247,7 @@ TEST(EntropyProviderTest, UseOneTimeRandomizationWithCustomSeedPermuted) {
   // Ensures that two trials with different names but the same custom seed used
   // for one time randomization produce the same group assignments.
   base::FieldTrialList field_trial_list(
-      new PermutedEntropyProvider(1234, kMaxLowEntropySize));
+      base::MakeUnique<PermutedEntropyProvider>(1234, kMaxLowEntropySize));
   const int kNoExpirationYear = base::FieldTrialList::kNoExpirationYear;
   const uint32_t kCustomSeed = 9001;
   scoped_refptr<base::FieldTrial> trials[] = {
diff --git a/chromium/components/variations/net/BUILD.gn b/chromium/components/variations/net/BUILD.gn
index c037d46fec3..148bf79a12d 100644
--- a/chromium/components/variations/net/BUILD.gn
+++ b/chromium/components/variations/net/BUILD.gn
@@ -2,7 +2,7 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-source_set("net") {
+static_library("net") {
   sources = [
     "variations_http_headers.cc",
     "variations_http_headers.h",
diff --git a/chromium/components/variations/processed_study.cc b/chromium/components/variations/processed_study.cc
index 8bf91e3b3ff..8c1f8d0f8a1 100644
--- a/chromium/components/variations/processed_study.cc
+++ b/chromium/components/variations/processed_study.cc
@@ -27,13 +27,13 @@ bool ValidateStudyAndComputeTotalProbability(
     return false;
   }
   if (study.filter().has_min_version() &&
-      !Version::IsValidWildcardString(study.filter().min_version())) {
+      !base::Version::IsValidWildcardString(study.filter().min_version())) {
     DVLOG(1) << study.name() << " has invalid min version: "
              << study.filter().min_version();
     return false;
   }
   if (study.filter().has_max_version() &&
-      !Version::IsValidWildcardString(study.filter().max_version())) {
+      !base::Version::IsValidWildcardString(study.filter().max_version())) {
     DVLOG(1) << study.name() << " has invalid max version: "
              << study.filter().max_version();
     return false;
diff --git a/chromium/components/variations/service/BUILD.gn b/chromium/components/variations/service/BUILD.gn
index 099be5c2884..d2ea94f1029 100644
--- a/chromium/components/variations/service/BUILD.gn
+++ b/chromium/components/variations/service/BUILD.gn
@@ -2,7 +2,7 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-source_set("service") {
+static_library("service") {
   sources = [
     "ui_string_overrider.cc",
     "ui_string_overrider.h",
diff --git a/chromium/components/variations/service/variations_service.cc b/chromium/components/variations/service/variations_service.cc
index b583668618d..8f5d5df8efa 100644
--- a/chromium/components/variations/service/variations_service.cc
+++ b/chromium/components/variations/service/variations_service.cc
@@ -12,7 +12,7 @@
 #include "base/build_time.h"
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
-#include "base/metrics/histogram.h"
+#include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/strings/string_util.h"
 #include "base/sys_info.h"
@@ -502,8 +502,8 @@ std::unique_ptr<VariationsService> VariationsService::Create(
 #endif
   result.reset(new VariationsService(
       std::move(client),
-      base::WrapUnique(new web_resource::ResourceRequestAllowedNotifier(
-          local_state, disable_network_switch)),
+      base::MakeUnique<web_resource::ResourceRequestAllowedNotifier>(
+          local_state, disable_network_switch),
       local_state, state_manager, ui_string_overrider));
   return result;
 }
@@ -514,8 +514,8 @@ std::unique_ptr<VariationsService> VariationsService::CreateForTesting(
     PrefService* local_state) {
   return base::WrapUnique(new VariationsService(
       std::move(client),
-      base::WrapUnique(new web_resource::ResourceRequestAllowedNotifier(
-          local_state, nullptr)),
+      base::MakeUnique<web_resource::ResourceRequestAllowedNotifier>(
+          local_state, nullptr),
       local_state, nullptr, UIStringOverrider()));
 }
 
@@ -560,7 +560,7 @@ void VariationsService::DoActualFetch() {
   if (!last_request_started_time_.is_null())
     time_since_last_fetch = now - last_request_started_time_;
   UMA_HISTOGRAM_CUSTOM_COUNTS("Variations.TimeSinceLastFetchAttempt",
-                              time_since_last_fetch.InMinutes(), 0,
+                              time_since_last_fetch.InMinutes(), 1,
                               base::TimeDelta::FromDays(7).InMinutes(), 50);
   UMA_HISTOGRAM_COUNTS_100("Variations.RequestCount", request_count_);
   ++request_count_;
@@ -644,13 +644,15 @@ void VariationsService::OnURLFetchComplete(const net::URLFetcher* source) {
   // The fetcher will be deleted when the request is handled.
   std::unique_ptr<const net::URLFetcher> request(
       pending_seed_request_.release());
-  const net::URLRequestStatus& request_status = request->GetStatus();
-  if (request_status.status() != net::URLRequestStatus::SUCCESS) {
-    UMA_HISTOGRAM_SPARSE_SLOWLY("Variations.FailedRequestErrorCode",
-                                -request_status.error());
+  const net::URLRequestStatus& status = request->GetStatus();
+  const int response_code = request->GetResponseCode();
+  UMA_HISTOGRAM_SPARSE_SLOWLY(
+      "Variations.SeedFetchResponseOrErrorCode",
+      status.is_success() ? response_code : status.error());
+
+  if (status.status() != net::URLRequestStatus::SUCCESS) {
     DVLOG(1) << "Variations server request failed with error: "
-             << request_status.error() << ": "
-             << net::ErrorToString(request_status.error());
+             << status.error() << ": " << net::ErrorToString(status.error());
     // It's common for the very first fetch attempt to fail (e.g. the network
     // may not yet be available). In such a case, try again soon, rather than
     // waiting the full time interval.
@@ -659,11 +661,6 @@ void VariationsService::OnURLFetchComplete(const net::URLFetcher* source) {
     return;
   }
 
-  // Log the response code.
-  const int response_code = request->GetResponseCode();
-  UMA_HISTOGRAM_SPARSE_SLOWLY("Variations.SeedFetchResponseCode",
-                              response_code);
-
   const base::TimeDelta latency =
       base::TimeTicks::Now() - last_request_started_time_;
 
diff --git a/chromium/components/variations/service/variations_service_unittest.cc b/chromium/components/variations/service/variations_service_unittest.cc
index 6abfc8a8f5c..d6293876b09 100644
--- a/chromium/components/variations/service/variations_service_unittest.cc
+++ b/chromium/components/variations/service/variations_service_unittest.cc
@@ -272,17 +272,13 @@ TEST_F(VariationsServiceTest, CreateTrialsFromSeed) {
   TestingPrefServiceSimple prefs;
   VariationsService::RegisterPrefs(prefs.registry());
 
-  // Setup base::FeatureList.
-  base::FeatureList::ClearInstanceForTesting();
-  base::FeatureList::SetInstance(base::WrapUnique(new base::FeatureList()));
-
   // Create a local base::FieldTrialList, to hold the field trials created in
   // this test.
   base::FieldTrialList field_trial_list(nullptr);
 
   // Create a variations service.
   TestVariationsService service(
-      base::WrapUnique(new web_resource::TestRequestAllowedNotifier(&prefs)),
+      base::MakeUnique<web_resource::TestRequestAllowedNotifier>(&prefs),
       &prefs);
   service.SetCreateTrialsFromSeedCalledForTesting(false);
 
@@ -303,17 +299,13 @@ TEST_F(VariationsServiceTest, CreateTrialsFromSeedNoLastFetchTime) {
   TestingPrefServiceSimple prefs;
   VariationsService::RegisterPrefs(prefs.registry());
 
-  // Setup base::FeatureList.
-  base::FeatureList::ClearInstanceForTesting();
-  base::FeatureList::SetInstance(base::WrapUnique(new base::FeatureList()));
-
   // Create a local base::FieldTrialList, to hold the field trials created in
   // this test.
   base::FieldTrialList field_trial_list(nullptr);
 
   // Create a variations service
   TestVariationsService service(
-      base::WrapUnique(new web_resource::TestRequestAllowedNotifier(&prefs)),
+      base::MakeUnique<web_resource::TestRequestAllowedNotifier>(&prefs),
       &prefs);
   service.SetCreateTrialsFromSeedCalledForTesting(false);
 
@@ -334,17 +326,13 @@ TEST_F(VariationsServiceTest, CreateTrialsFromOutdatedSeed) {
   TestingPrefServiceSimple prefs;
   VariationsService::RegisterPrefs(prefs.registry());
 
-  // Setup base::FeatureList.
-  base::FeatureList::ClearInstanceForTesting();
-  base::FeatureList::SetInstance(base::WrapUnique(new base::FeatureList()));
-
   // Create a local base::FieldTrialList, to hold the field trials created in
   // this test.
   base::FieldTrialList field_trial_list(nullptr);
 
   // Create a variations service.
   TestVariationsService service(
-      base::WrapUnique(new web_resource::TestRequestAllowedNotifier(&prefs)),
+      base::MakeUnique<web_resource::TestRequestAllowedNotifier>(&prefs),
       &prefs);
   service.SetCreateTrialsFromSeedCalledForTesting(false);
 
@@ -368,11 +356,11 @@ TEST_F(VariationsServiceTest, GetVariationsServerURL) {
 
   std::string value;
   std::unique_ptr<TestVariationsServiceClient> client =
-      base::WrapUnique(new TestVariationsServiceClient());
+      base::MakeUnique<TestVariationsServiceClient>();
   TestVariationsServiceClient* raw_client = client.get();
   VariationsService service(
       std::move(client),
-      base::WrapUnique(new web_resource::TestRequestAllowedNotifier(&prefs)),
+      base::MakeUnique<web_resource::TestRequestAllowedNotifier>(&prefs),
       &prefs, NULL, UIStringOverrider());
   GURL url = service.GetVariationsServerURL(&prefs, std::string());
   EXPECT_TRUE(base::StartsWith(url.spec(), default_variations_url,
@@ -407,7 +395,7 @@ TEST_F(VariationsServiceTest, VariationsURLHasOSNameParam) {
   TestingPrefServiceSimple prefs;
   VariationsService::RegisterPrefs(prefs.registry());
   TestVariationsService service(
-      base::WrapUnique(new web_resource::TestRequestAllowedNotifier(&prefs)),
+      base::MakeUnique<web_resource::TestRequestAllowedNotifier>(&prefs),
       &prefs);
   const GURL url = service.GetVariationsServerURL(&prefs, std::string());
 
@@ -423,7 +411,7 @@ TEST_F(VariationsServiceTest, RequestsInitiallyNotAllowed) {
   // Pass ownership to TestVariationsService, but keep a weak pointer to
   // manipulate it for this test.
   std::unique_ptr<web_resource::TestRequestAllowedNotifier> test_notifier =
-      base::WrapUnique(new web_resource::TestRequestAllowedNotifier(&prefs));
+      base::MakeUnique<web_resource::TestRequestAllowedNotifier>(&prefs);
   web_resource::TestRequestAllowedNotifier* raw_notifier = test_notifier.get();
   TestVariationsService test_service(std::move(test_notifier), &prefs);
 
@@ -443,7 +431,7 @@ TEST_F(VariationsServiceTest, RequestsInitiallyAllowed) {
   // Pass ownership to TestVariationsService, but keep a weak pointer to
   // manipulate it for this test.
   std::unique_ptr<web_resource::TestRequestAllowedNotifier> test_notifier =
-      base::WrapUnique(new web_resource::TestRequestAllowedNotifier(&prefs));
+      base::MakeUnique<web_resource::TestRequestAllowedNotifier>(&prefs);
   web_resource::TestRequestAllowedNotifier* raw_notifier = test_notifier.get();
   TestVariationsService test_service(std::move(test_notifier), &prefs);
 
@@ -457,7 +445,7 @@ TEST_F(VariationsServiceTest, SeedStoredWhenOKStatus) {
   VariationsService::RegisterPrefs(prefs.registry());
 
   TestVariationsService service(
-      base::WrapUnique(new web_resource::TestRequestAllowedNotifier(&prefs)),
+      base::MakeUnique<web_resource::TestRequestAllowedNotifier>(&prefs),
       &prefs);
   service.set_intercepts_fetch(false);
 
@@ -486,7 +474,7 @@ TEST_F(VariationsServiceTest, SeedNotStoredWhenNonOKStatus) {
   VariationsService::RegisterPrefs(prefs.registry());
 
   TestVariationsService service(
-      base::WrapUnique(new web_resource::TestRequestAllowedNotifier(&prefs)),
+      base::MakeUnique<web_resource::TestRequestAllowedNotifier>(&prefs),
       &prefs);
   service.set_intercepts_fetch(false);
   for (size_t i = 0; i < arraysize(non_ok_status_codes); ++i) {
@@ -508,7 +496,7 @@ TEST_F(VariationsServiceTest, RequestGzipCompressedSeed) {
   net::TestURLFetcherFactory factory;
 
   TestVariationsService service(
-      base::WrapUnique(new web_resource::TestRequestAllowedNotifier(&prefs)),
+      base::MakeUnique<web_resource::TestRequestAllowedNotifier>(&prefs),
       &prefs);
   service.set_intercepts_fetch(false);
   service.DoActualFetch();
@@ -544,7 +532,7 @@ TEST_F(VariationsServiceTest, InstanceManipulations) {
 
   for (size_t i = 0; i < arraysize(cases); ++i) {
     TestVariationsService service(
-        base::WrapUnique(new web_resource::TestRequestAllowedNotifier(&prefs)),
+        base::MakeUnique<web_resource::TestRequestAllowedNotifier>(&prefs),
         &prefs);
     service.set_intercepts_fetch(false);
     service.DoActualFetch();
@@ -568,7 +556,7 @@ TEST_F(VariationsServiceTest, CountryHeader) {
   VariationsService::RegisterPrefs(prefs.registry());
 
   TestVariationsService service(
-      base::WrapUnique(new web_resource::TestRequestAllowedNotifier(&prefs)),
+      base::MakeUnique<web_resource::TestRequestAllowedNotifier>(&prefs),
       &prefs);
   service.set_intercepts_fetch(false);
 
@@ -591,8 +579,8 @@ TEST_F(VariationsServiceTest, Observer) {
   TestingPrefServiceSimple prefs;
   VariationsService::RegisterPrefs(prefs.registry());
   VariationsService service(
-      base::WrapUnique(new TestVariationsServiceClient()),
-      base::WrapUnique(new web_resource::TestRequestAllowedNotifier(&prefs)),
+      base::MakeUnique<TestVariationsServiceClient>(),
+      base::MakeUnique<web_resource::TestRequestAllowedNotifier>(&prefs),
       &prefs, NULL, UIStringOverrider());
 
   struct {
@@ -691,8 +679,8 @@ TEST_F(VariationsServiceTest, LoadPermanentConsistencyCountry) {
     TestingPrefServiceSimple prefs;
     VariationsService::RegisterPrefs(prefs.registry());
     VariationsService service(
-        base::WrapUnique(new TestVariationsServiceClient()),
-        base::WrapUnique(new web_resource::TestRequestAllowedNotifier(&prefs)),
+        base::MakeUnique<TestVariationsServiceClient>(),
+        base::MakeUnique<web_resource::TestRequestAllowedNotifier>(&prefs),
         &prefs, NULL, UIStringOverrider());
 
     if (test.pref_value_before) {
@@ -763,7 +751,7 @@ TEST_F(VariationsServiceTest, OverrideStoredPermanentCountry) {
     TestingPrefServiceSimple prefs;
     VariationsService::RegisterPrefs(prefs.registry());
     TestVariationsService service(
-        base::WrapUnique(new web_resource::TestRequestAllowedNotifier(&prefs)),
+        base::MakeUnique<web_resource::TestRequestAllowedNotifier>(&prefs),
         &prefs);
 
     if (!test.pref_value_before.empty()) {
diff --git a/chromium/components/variations/study_filtering.cc b/chromium/components/variations/study_filtering.cc
index f5b3f26f9c5..479b9e959ec 100644
--- a/chromium/components/variations/study_filtering.cc
+++ b/chromium/components/variations/study_filtering.cc
@@ -164,10 +164,10 @@ bool CheckStudyCountry(const Study_Filter& filter, const std::string& country) {
   // that this means this overrides the exclude_country in case that ever occurs
   // (which it shouldn't).
   if (filter.country_size() > 0)
-    return ContainsValue(filter.country(), country);
+    return base::ContainsValue(filter.country(), country);
 
   // Omit if matches any of the exclude entries.
-  return !ContainsValue(filter.exclude_country(), country);
+  return !base::ContainsValue(filter.exclude_country(), country);
 }
 
 bool IsStudyExpired(const Study& study, const base::Time& date_time) {
@@ -288,14 +288,14 @@ void FilterAndValidateStudies(const VariationsSeed& seed,
 
     if (internal::IsStudyExpired(study, reference_date)) {
       expired_studies.push_back(&study);
-    } else if (!ContainsKey(created_studies, study.name())) {
+    } else if (!base::ContainsKey(created_studies, study.name())) {
       ProcessedStudy::ValidateAndAppendStudy(&study, false, filtered_studies);
       created_studies.insert(study.name());
     }
   }
 
   for (size_t i = 0; i < expired_studies.size(); ++i) {
-    if (!ContainsKey(created_studies, expired_studies[i]->name())) {
+    if (!base::ContainsKey(created_studies, expired_studies[i]->name())) {
       ProcessedStudy::ValidateAndAppendStudy(expired_studies[i], true,
                                              filtered_studies);
     }
diff --git a/chromium/components/variations/study_filtering_unittest.cc b/chromium/components/variations/study_filtering_unittest.cc
index 0715432a583..0c9dfa06e35 100644
--- a/chromium/components/variations/study_filtering_unittest.cc
+++ b/chromium/components/variations/study_filtering_unittest.cc
@@ -280,8 +280,8 @@ TEST(VariationsStudyFilteringTest, CheckStudyVersion) {
 
   for (size_t i = 0; i < arraysize(min_test_cases); ++i) {
     filter.set_min_version(min_test_cases[i].min_version);
-    const bool result =
-        internal::CheckStudyVersion(filter, Version(min_test_cases[i].version));
+    const bool result = internal::CheckStudyVersion(
+        filter, base::Version(min_test_cases[i].version));
     EXPECT_EQ(min_test_cases[i].expected_result, result) <<
         "Min. version case " << i << " failed!";
   }
@@ -289,8 +289,8 @@ TEST(VariationsStudyFilteringTest, CheckStudyVersion) {
 
   for (size_t i = 0; i < arraysize(max_test_cases); ++i) {
     filter.set_max_version(max_test_cases[i].max_version);
-    const bool result =
-        internal::CheckStudyVersion(filter, Version(max_test_cases[i].version));
+    const bool result = internal::CheckStudyVersion(
+        filter, base::Version(max_test_cases[i].version));
     EXPECT_EQ(max_test_cases[i].expected_result, result) <<
         "Max version case " << i << " failed!";
   }
@@ -302,16 +302,14 @@ TEST(VariationsStudyFilteringTest, CheckStudyVersion) {
       filter.set_max_version(max_test_cases[j].max_version);
 
       if (!min_test_cases[i].expected_result) {
-        const bool result =
-            internal::CheckStudyVersion(
-                filter, Version(min_test_cases[i].version));
+        const bool result = internal::CheckStudyVersion(
+            filter, base::Version(min_test_cases[i].version));
         EXPECT_FALSE(result) << "Case " << i << "," << j << " failed!";
       }
 
       if (!max_test_cases[j].expected_result) {
-        const bool result =
-            internal::CheckStudyVersion(
-                filter, Version(max_test_cases[j].version));
+        const bool result = internal::CheckStudyVersion(
+            filter, base::Version(max_test_cases[j].version));
         EXPECT_FALSE(result) << "Case " << i << "," << j << " failed!";
       }
     }
diff --git a/chromium/components/variations/variations_associated_data.cc b/chromium/components/variations/variations_associated_data.cc
index 9aa51d379f3..d257d01999f 100644
--- a/chromium/components/variations/variations_associated_data.cc
+++ b/chromium/components/variations/variations_associated_data.cc
@@ -11,11 +11,15 @@
 #include "base/feature_list.h"
 #include "base/macros.h"
 #include "base/memory/singleton.h"
+#include "base/strings/string_split.h"
+#include "components/variations/variations_http_header_provider.h"
 
 namespace variations {
 
 namespace {
 
+const char kGroupTesting[] = "Testing";
+
 // The internal singleton accessor for the map, used to keep it thread-safe.
 class GroupMapAccessor {
  public:
@@ -124,7 +128,7 @@ class VariationsParamAssociator {
       return false;
 
     const VariationKey key(trial_name, group_name);
-    if (ContainsKey(variation_params_, key))
+    if (base::ContainsKey(variation_params_, key))
       return false;
 
     variation_params_[key] = params;
@@ -138,7 +142,7 @@ class VariationsParamAssociator {
     const std::string group_name =
         base::FieldTrialList::FindFullName(trial_name);
     const VariationKey key(trial_name, group_name);
-    if (!ContainsKey(variation_params_, key))
+    if (!base::ContainsKey(variation_params_, key))
       return false;
 
     *params = variation_params_[key];
@@ -252,6 +256,26 @@ std::string GetVariationParamValueByFeature(const base::Feature& feature,
 // They simply wrap existing functions in this file.
 namespace testing {
 
+VariationParamsManager::VariationParamsManager(
+    const std::string& trial_name,
+    const std::map<std::string, std::string>& params) {
+  SetVariationParams(trial_name, params);
+}
+
+VariationParamsManager::~VariationParamsManager() {
+  ClearAllVariationIDs();
+  ClearAllVariationParams();
+  field_trial_list_.reset();
+}
+
+void VariationParamsManager::SetVariationParams(
+    const std::string& trial_name,
+    const std::map<std::string, std::string>& params) {
+  field_trial_list_.reset(new base::FieldTrialList(nullptr));
+  variations::AssociateVariationParams(trial_name, kGroupTesting, params);
+  base::FieldTrialList::CreateFieldTrial(trial_name, kGroupTesting);
+}
+
 void ClearAllVariationIDs() {
   GroupMapAccessor::GetInstance()->ClearAllMapsForTesting();
 }
diff --git a/chromium/components/variations/variations_associated_data.h b/chromium/components/variations/variations_associated_data.h
index 3eb9567cc3a..a4156c293d6 100644
--- a/chromium/components/variations/variations_associated_data.h
+++ b/chromium/components/variations/variations_associated_data.h
@@ -6,7 +6,9 @@
 #define COMPONENTS_VARIATIONS_VARIATIONS_ASSOCIATED_DATA_H_
 
 #include <map>
+#include <memory>
 #include <string>
+#include <vector>
 
 #include "base/metrics/field_trial.h"
 #include "components/variations/active_field_trials.h"
@@ -48,6 +50,7 @@ struct Feature;
 namespace variations {
 
 typedef int VariationID;
+class VariationsHttpHeaderProvider;
 
 const VariationID EMPTY_ID = 0;
 
@@ -153,17 +156,42 @@ std::string GetVariationParamValue(const std::string& trial_name,
 // variation associated with the specified |feature|. A feature is associated
 // with at most one variation, through the variation's associated field trial,
 // and selected group. See base/feature_list.h for more information on
-// features. If the feature is not enabled, or if there's no associated
-// variation params, returns false and does not modify |params|. Calling this
-// function will result in the associated field trial being marked as active if
-// found (i.e. group() will be called on it), if it wasn't already. Currently,
-// this information is only available from the browser process. Thread safe.
+// features. If the feature is not enabled, or the specified parameter does not
+// exist, returns an empty string.Calling this function will result in the
+// associated field trial being marked as active if found (i.e. group() will be
+// called on it), if it wasn't already. Currently, this information is only
+// available from the browser process. Thread safe.
 std::string GetVariationParamValueByFeature(const base::Feature& feature,
                                             const std::string& param_name);
 
 // Expose some functions for testing.
 namespace testing {
 
+// Use this class as a member in your test class to set variation params for
+// your tests. You can directly set the parameters in the constructor (if they
+// are used by other members upon construction). You can change them later
+// arbitrarily many times using the SetVariationParams function. Internally, it
+// creates a FieldTrialList as a member. It works well for multiple tests of a
+// given test class, as it clears the parameters when this class is destructed.
+// Note that it clears all parameters (not just those registered here).
+class VariationParamsManager {
+ public:
+  VariationParamsManager(const std::string& trial_name,
+                         const std::map<std::string, std::string>& params);
+  ~VariationParamsManager();
+
+  // Associates |params| with the given |trial_name|. It creates a new group,
+  // used only for testing. Between two calls of this function,
+  // ClearAllVariationParams() has to be called.
+  void SetVariationParams(const std::string& trial_name,
+                          const std::map<std::string, std::string>& params);
+
+ private:
+  std::unique_ptr<base::FieldTrialList> field_trial_list_;
+
+  DISALLOW_COPY_AND_ASSIGN(VariationParamsManager);
+};
+
 // Clears all of the mapped associations.
 void ClearAllVariationIDs();
 
diff --git a/chromium/components/variations/variations_associated_data_unittest.cc b/chromium/components/variations/variations_associated_data_unittest.cc
index 05cdecea048..5bdd1d8481a 100644
--- a/chromium/components/variations/variations_associated_data_unittest.cc
+++ b/chromium/components/variations/variations_associated_data_unittest.cc
@@ -7,6 +7,7 @@
 #include "base/feature_list.h"
 #include "base/macros.h"
 #include "base/metrics/field_trial.h"
+#include "base/test/scoped_feature_list.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace variations {
@@ -34,16 +35,6 @@ scoped_refptr<base::FieldTrial> CreateFieldTrial(
       base::FieldTrial::SESSION_RANDOMIZED, default_group_number);
 }
 
-void CreateFeatureWithTrial(const base::Feature& feature,
-                            base::FeatureList::OverrideState override_state,
-                            base::FieldTrial* trial) {
-  base::FeatureList::ClearInstanceForTesting();
-  std::unique_ptr<base::FeatureList> feature_list(new base::FeatureList);
-  feature_list->RegisterFieldTrialOverride(feature.name, override_state,
-                                           trial);
-  base::FeatureList::SetInstance(std::move(feature_list));
-}
-
 }  // namespace
 
 class VariationsAssociatedDataTest : public ::testing::Test {
@@ -58,8 +49,18 @@ class VariationsAssociatedDataTest : public ::testing::Test {
     testing::ClearAllVariationParams();
   }
 
+  void CreateFeatureWithTrial(const base::Feature& feature,
+                              base::FeatureList::OverrideState override_state,
+                              base::FieldTrial* trial) {
+    std::unique_ptr<base::FeatureList> feature_list(new base::FeatureList);
+    feature_list->RegisterFieldTrialOverride(feature.name, override_state,
+                                             trial);
+    scoped_feature_list_.InitWithFeatureList(std::move(feature_list));
+  }
+
  private:
   base::FieldTrialList field_trial_list_;
+  base::test::ScopedFeatureList scoped_feature_list_;
 
   DISALLOW_COPY_AND_ASSIGN(VariationsAssociatedDataTest);
 };
diff --git a/chromium/components/variations/variations_http_header_provider.cc b/chromium/components/variations/variations_http_header_provider.cc
index d77a4bf8e3d..5af7151403c 100644
--- a/chromium/components/variations/variations_http_header_provider.cc
+++ b/chromium/components/variations/variations_http_header_provider.cc
@@ -56,12 +56,32 @@ std::string VariationsHttpHeaderProvider::GetVariationsString() {
   return ids_string;
 }
 
+bool VariationsHttpHeaderProvider::ForceVariationIds(
+    const std::string& command_line_variation_ids,
+    std::vector<std::string>* variation_ids) {
+  if (!command_line_variation_ids.empty()) {
+    // Combine |variation_ids| with |command_line_variation_ids|.
+    std::vector<std::string> variation_ids_flags =
+        base::SplitString(command_line_variation_ids, ",",
+                          base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
+    variation_ids->insert(variation_ids->end(), variation_ids_flags.begin(),
+                          variation_ids_flags.end());
+  }
+
+  if (!variation_ids->empty()) {
+    // Create default variation ids which will always be included in the
+    // X-Client-Data request header.
+    return SetDefaultVariationIds(*variation_ids);
+  }
+  return true;
+}
+
+
 bool VariationsHttpHeaderProvider::SetDefaultVariationIds(
-    const std::string& variation_ids) {
+    const std::vector<std::string>& variation_ids) {
   default_variation_ids_set_.clear();
   default_trigger_id_set_.clear();
-  for (const base::StringPiece& entry : base::SplitStringPiece(
-           variation_ids, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
+  for (const std::string& entry : variation_ids) {
     if (entry.empty()) {
       default_variation_ids_set_.clear();
       default_trigger_id_set_.clear();
@@ -70,7 +90,7 @@ bool VariationsHttpHeaderProvider::SetDefaultVariationIds(
     bool trigger_id =
         base::StartsWith(entry, "t", base::CompareCase::SENSITIVE);
     // Remove the "t" prefix if it's there.
-    base::StringPiece trimmed_entry = trigger_id ? entry.substr(1) : entry;
+    std::string trimmed_entry = trigger_id ? entry.substr(1) : entry;
 
     int variation_id = 0;
     if (!base::StringToInt(trimmed_entry, &variation_id)) {
@@ -166,7 +186,7 @@ void VariationsHttpHeaderProvider::InitVariationIDsCacheIfNeeded() {
 
   UMA_HISTOGRAM_CUSTOM_COUNTS(
       "Variations.HeaderConstructionTime",
-      (base::TimeTicks::Now() - before_time).InMicroseconds(), 0,
+      (base::TimeTicks::Now() - before_time).InMicroseconds(), 1,
       base::TimeDelta::FromSeconds(1).InMicroseconds(), 50);
 
   variation_ids_cache_initialized_ = true;
diff --git a/chromium/components/variations/variations_http_header_provider.h b/chromium/components/variations/variations_http_header_provider.h
index b92daca3a54..349fea9951c 100644
--- a/chromium/components/variations/variations_http_header_provider.h
+++ b/chromium/components/variations/variations_http_header_provider.h
@@ -41,12 +41,19 @@ class VariationsHttpHeaderProvider : public base::FieldTrialList::Observer,
   // a leading and trailing space, e.g. " 123 234 345 ".
   std::string GetVariationsString();
 
+  // Forces the list of |variation_ids| (which will be modified by adding the
+  // comma-separated |command_line_variation_ids|). This is a wrapper function
+  // around SetDefaultVariationIds.
+  bool ForceVariationIds(
+      const std::string& command_line_variation_ids,
+      std::vector<std::string>* variation_ids);
+
   // Sets *additional* variation ids and trigger variation ids to be encoded in
-  // the X-Client-Data request header.  This is intended for development use to
-  // force a server side experiment id.  |variation_ids| should be a
-  // comma-separated string of numeric experiment ids.  If an id is prefixed
-  // with "t" it will be treated as a trigger experiment id.
-  bool SetDefaultVariationIds(const std::string& variation_ids);
+  // the X-Client-Data request header. This is intended for development use to
+  // force a server side experiment id. |variation_ids| should be a list of
+  // strings of numeric experiment ids. If an id is prefixed with "t" it will
+  // be treated as a trigger experiment id.
+  bool SetDefaultVariationIds(const std::vector<std::string>& variation_ids);
 
   // Resets any cached state for tests.
   void ResetForTesting();
diff --git a/chromium/components/variations/variations_http_header_provider_unittest.cc b/chromium/components/variations/variations_http_header_provider_unittest.cc
index 90552c84476..a1b9d3da8fc 100644
--- a/chromium/components/variations/variations_http_header_provider_unittest.cc
+++ b/chromium/components/variations/variations_http_header_provider_unittest.cc
@@ -65,7 +65,7 @@ TEST_F(VariationsHttpHeaderProviderTest, SetDefaultVariationIds_Valid) {
   VariationsHttpHeaderProvider provider;
 
   // Valid experiment ids.
-  EXPECT_TRUE(provider.SetDefaultVariationIds("12,456,t789"));
+  EXPECT_TRUE(provider.SetDefaultVariationIds({"12", "456", "t789"}));
   provider.InitVariationIDsCacheIfNeeded();
   std::string variations = provider.GetClientDataHeader();
   EXPECT_FALSE(variations.empty());
@@ -83,12 +83,14 @@ TEST_F(VariationsHttpHeaderProviderTest, SetDefaultVariationIds_Invalid) {
   VariationsHttpHeaderProvider provider;
 
   // Invalid experiment ids.
-  EXPECT_FALSE(provider.SetDefaultVariationIds("abcd12,456"));
+  EXPECT_FALSE(provider.SetDefaultVariationIds(
+      std::vector<std::string>{"abcd12", "456"}));
   provider.InitVariationIDsCacheIfNeeded();
   EXPECT_TRUE(provider.GetClientDataHeader().empty());
 
   // Invalid trigger experiment id
-  EXPECT_FALSE(provider.SetDefaultVariationIds("12,tabc456"));
+  EXPECT_FALSE(provider.SetDefaultVariationIds(
+      std::vector<std::string>{"12", "tabc456"}));
   provider.InitVariationIDsCacheIfNeeded();
   EXPECT_TRUE(provider.GetClientDataHeader().empty());
 }
@@ -131,7 +133,10 @@ TEST_F(VariationsHttpHeaderProviderTest, GetVariationsString) {
   CreateTrialAndAssociateId("t2", "g2", GOOGLE_WEB_PROPERTIES, 124);
 
   VariationsHttpHeaderProvider provider;
-  provider.SetDefaultVariationIds("100,200");
+  std::vector<std::string> ids;
+  ids.push_back("100");
+  ids.push_back("200");
+  provider.SetDefaultVariationIds(ids);
   EXPECT_EQ(" 100 123 124 200 ", provider.GetVariationsString());
 }
 
diff --git a/chromium/components/variations/variations_request_scheduler.cc b/chromium/components/variations/variations_request_scheduler.cc
index 08d39d10ce2..dfc39d9c138 100644
--- a/chromium/components/variations/variations_request_scheduler.cc
+++ b/chromium/components/variations/variations_request_scheduler.cc
@@ -47,7 +47,7 @@ void VariationsRequestScheduler::OnAppEnterForeground() {
 base::TimeDelta VariationsRequestScheduler::GetFetchPeriod() const {
   // The fetch interval can be overridden by a variation param.
   std::string period_min_str =
-      variations::GetVariationParamValue("VarationsServiceControl",
+      variations::GetVariationParamValue("VariationsServiceControl",
                                          "fetch_period_min");
   size_t period_min;
   if (base::StringToSizeT(period_min_str, &period_min))
diff --git a/chromium/components/variations/variations_seed_processor_unittest.cc b/chromium/components/variations/variations_seed_processor_unittest.cc
index 1ab8a497a38..7703eed3b1a 100644
--- a/chromium/components/variations/variations_seed_processor_unittest.cc
+++ b/chromium/components/variations/variations_seed_processor_unittest.cc
@@ -17,10 +17,12 @@
 #include "base/feature_list.h"
 #include "base/format_macros.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/mock_entropy_provider.h"
+#include "base/test/scoped_feature_list.h"
 #include "components/variations/processed_study.h"
 #include "components/variations/study_filtering.h"
 #include "components/variations/variations_associated_data.h"
@@ -117,8 +119,6 @@ class VariationsSeedProcessorTest : public ::testing::Test {
     // process singletons.
     testing::ClearAllVariationIDs();
     testing::ClearAllVariationParams();
-
-    base::FeatureList::ClearInstanceForTesting();
   }
 
   bool CreateTrialFromStudy(const Study& study) {
@@ -621,7 +621,6 @@ TEST_F(VariationsSeedProcessorTest, FeatureEnabledOrDisableByTrial) {
     SCOPED_TRACE(base::StringPrintf("Test[%" PRIuS "]", i));
 
     base::FieldTrialList field_trial_list(nullptr);
-    base::FeatureList::ClearInstanceForTesting();
     std::unique_ptr<base::FeatureList> feature_list(new base::FeatureList);
 
     Study study;
@@ -638,7 +637,8 @@ TEST_F(VariationsSeedProcessorTest, FeatureEnabledOrDisableByTrial) {
       association->add_disable_feature(test_case.disable_feature);
 
     EXPECT_TRUE(CreateTrialFromStudyWithFeatureList(study, feature_list.get()));
-    base::FeatureList::SetInstance(std::move(feature_list));
+    base::test::ScopedFeatureList scoped_feature_list;
+    scoped_feature_list.InitWithFeatureList(std::move(feature_list));
 
     // |kUnrelatedFeature| should not be affected.
     EXPECT_FALSE(base::FeatureList::IsEnabled(kUnrelatedFeature));
@@ -744,7 +744,6 @@ TEST_F(VariationsSeedProcessorTest, FeatureAssociationAndForcing) {
         test_case.disable_features_command_line, static_cast<int>(group)));
 
     base::FieldTrialList field_trial_list(nullptr);
-    base::FeatureList::ClearInstanceForTesting();
     std::unique_ptr<base::FeatureList> feature_list(new base::FeatureList);
     feature_list->InitializeFromCommandLine(
         test_case.enable_features_command_line,
@@ -773,7 +772,8 @@ TEST_F(VariationsSeedProcessorTest, FeatureAssociationAndForcing) {
         ->set_forcing_feature_off(test_case.feature.name);
 
     EXPECT_TRUE(CreateTrialFromStudyWithFeatureList(study, feature_list.get()));
-    base::FeatureList::SetInstance(std::move(feature_list));
+    base::test::ScopedFeatureList scoped_feature_list;
+    scoped_feature_list.InitWithFeatureList(std::move(feature_list));
 
     // Trial should not be activated initially, but later might get activated
     // depending on the expected values.
@@ -814,7 +814,6 @@ TEST_F(VariationsSeedProcessorTest, FeaturesInExpiredStudies) {
         base::StringPrintf("Test[%" PRIuS "]: %s", i, test_case.feature.name));
 
     base::FieldTrialList field_trial_list(nullptr);
-    base::FeatureList::ClearInstanceForTesting();
     std::unique_ptr<base::FeatureList> feature_list(new base::FeatureList);
     feature_list->InitializeFromCommandLine(std::string(), std::string());
 
@@ -837,7 +836,8 @@ TEST_F(VariationsSeedProcessorTest, FeaturesInExpiredStudies) {
     }
 
     EXPECT_TRUE(CreateTrialFromStudyWithFeatureList(study, feature_list.get()));
-    base::FeatureList::SetInstance(std::move(feature_list));
+    base::test::ScopedFeatureList scoped_feature_list;
+    scoped_feature_list.InitWithFeatureList(std::move(feature_list));
 
     // Tthe feature should not be enabled, because the study is expired.
     EXPECT_EQ(test_case.expected_feature_enabled,
@@ -868,11 +868,8 @@ TEST_F(VariationsSeedProcessorTest, LowEntropyStudyTest) {
 
   // An entorpy value of 0.1 will cause the AA group to be chosen, since AA is
   // the only non-default group, and has a probability percent above 0.1.
-  base::MockEntropyProvider* mock_high_entropy_provider =
-      new base::MockEntropyProvider(0.1);
-
-  // The field trial list takes ownership of the provider.
-  base::FieldTrialList field_trial_list(mock_high_entropy_provider);
+  base::FieldTrialList field_trial_list(
+      base::MakeUnique<base::MockEntropyProvider>(0.1));
 
   // Use a stack instance, since nothing takes ownership of this provider.
   // This entropy value will cause the default group to be chosen since it's a
diff --git a/chromium/components/variations/variations_seed_store.cc b/chromium/components/variations/variations_seed_store.cc
index 65b1efd1b5c..8067651b435 100644
--- a/chromium/components/variations/variations_seed_store.cc
+++ b/chromium/components/variations/variations_seed_store.cc
@@ -112,7 +112,10 @@ base::Time TruncateToUTCDay(const base::Time& time) {
   exploded.second = 0;
   exploded.millisecond = 0;
 
-  return base::Time::FromUTCExploded(exploded);
+  base::Time out_time;
+  bool conversion_success = base::Time::FromUTCExploded(exploded, &out_time);
+  DCHECK(conversion_success);
+  return out_time;
 }
 
 VariationsSeedDateChangeState GetSeedDateChangeState(
diff --git a/chromium/components/variations/variations_url_constants.cc b/chromium/components/variations/variations_url_constants.cc
index dce446a641b..f530ff5cc93 100644
--- a/chromium/components/variations/variations_url_constants.cc
+++ b/chromium/components/variations/variations_url_constants.cc
@@ -4,10 +4,17 @@
 
 #include "components/variations/variations_url_constants.h"
 
+#include "build/build_config.h"
+
 namespace variations {
 
 // Default server of Variations seed info.
+#if defined(OS_ANDROID)
+const char kDefaultServerUrl[] =
+    "https://clientservices.googleapis.com/chrome-variations/seed";
+#else
 const char kDefaultServerUrl[] =
     "https://clients4.google.com/chrome-variations/seed";
+#endif
 
 }  // namespace variations