Turn VariationsService::GetVariationsServerURL into instance method

chrome/browser/metrics/variations/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 "chrome/browser/metrics/variations/variations_service.h"
 
 #include <vector>
 
 #include "base/base64.h"
 #include "base/json/json_string_value_serializer.h"
@@ skipping 25 matching lines @@
 #include "chrome/browser/chromeos/settings/stub_cros_settings_provider.h"
 #endif
 
 namespace chrome_variations {
 
 namespace {
 
 // A test class used to validate expected functionality in VariationsService.
 class TestVariationsService : public VariationsService {
  public:
-  TestVariationsService(web_resource::TestRequestAllowedNotifier* test_notifier,
-                        PrefService* local_state)
+  TestVariationsService(
+      scoped_ptr<web_resource::TestRequestAllowedNotifier> test_notifier,
+      PrefService* local_state)
       : VariationsService(make_scoped_ptr(new ChromeVariationsServiceClient()),
-                          test_notifier,
+                          test_notifier.Pass(),
                           local_state,
                           NULL),
         intercepts_fetch_(true),
         fetch_attempted_(false),
         seed_stored_(false) {
     // Set this so StartRepeatedVariationsSeedFetch can be called in tests.
     SetCreateTrialsFromSeedCalledForTesting(true);
   }
 
   ~TestVariationsService() override {}
@@ skipping 197 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(VariationsServiceTest);
 };
 
 TEST_F(VariationsServiceTest, GetVariationsServerURL) {
   TestVariationsPrefsStore prefs_store;
   PrefService* prefs = prefs_store.prefs();
   const std::string default_variations_url =
       VariationsService::GetDefaultVariationsServerURLForTesting();
 
   std::string value;
-  GURL url = VariationsService::GetVariationsServerURL(prefs, std::string());
+  TestVariationsService service(
+      make_scoped_ptr(new web_resource::TestRequestAllowedNotifier(prefs)),
+      prefs);
+  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_store.SetVariationsRestrictParameterPolicyValue("restricted");
-  url = VariationsService::GetVariationsServerURL(prefs, std::string());
+  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));
   EXPECT_EQ("restricted", value);
 
   // The override value should take precedence over what's in prefs.
-  url = VariationsService::GetVariationsServerURL(prefs, "override");
+  url = service.GetVariationsServerURL(prefs, "override");
   EXPECT_TRUE(base::StartsWith(url.spec(), default_variations_url,
                                base::CompareCase::SENSITIVE));
   EXPECT_TRUE(net::GetValueForKeyInQuery(url, "restrict", &value));
   EXPECT_EQ("override", value);
 }
 
 TEST_F(VariationsServiceTest, VariationsURLHasOSNameParam) {
   TestingPrefServiceSimple prefs;
   VariationsService::RegisterPrefs(prefs.registry());
-  const GURL url =
-      VariationsService::GetVariationsServerURL(&prefs, std::string());
+  TestVariationsService service(
+      make_scoped_ptr(new web_resource::TestRequestAllowedNotifier(&prefs)),
+      &prefs);
+  const GURL url = service.GetVariationsServerURL(&prefs, std::string());
 
   std::string value;
   EXPECT_TRUE(net::GetValueForKeyInQuery(url, "osname", &value));
   EXPECT_FALSE(value.empty());
 }
 
 TEST_F(VariationsServiceTest, RequestsInitiallyNotAllowed) {
   TestingPrefServiceSimple prefs;
   VariationsService::RegisterPrefs(prefs.registry());
 
   // Pass ownership to TestVariationsService, but keep a weak pointer to
   // manipulate it for this test.
-  web_resource::TestRequestAllowedNotifier* test_notifier =
-      new web_resource::TestRequestAllowedNotifier(&prefs);
-  TestVariationsService test_service(test_notifier, &prefs);
+  scoped_ptr<web_resource::TestRequestAllowedNotifier> test_notifier =
+      make_scoped_ptr(new web_resource::TestRequestAllowedNotifier(&prefs));
+  web_resource::TestRequestAllowedNotifier* raw_notifier = test_notifier.get();
+  TestVariationsService test_service(test_notifier.Pass(), &prefs);
 
   // Force the notifier to initially disallow requests.
-  test_notifier->SetRequestsAllowedOverride(false);
+  raw_notifier->SetRequestsAllowedOverride(false);
   test_service.StartRepeatedVariationsSeedFetch();
   EXPECT_FALSE(test_service.fetch_attempted());
 
-  test_notifier->NotifyObserver();
+  raw_notifier->NotifyObserver();
   EXPECT_TRUE(test_service.fetch_attempted());
 }
 
 TEST_F(VariationsServiceTest, RequestsInitiallyAllowed) {
   TestingPrefServiceSimple prefs;
   VariationsService::RegisterPrefs(prefs.registry());
 
   // Pass ownership to TestVariationsService, but keep a weak pointer to
   // manipulate it for this test.
-  web_resource::TestRequestAllowedNotifier* test_notifier =
-      new web_resource::TestRequestAllowedNotifier(&prefs);
-  TestVariationsService test_service(test_notifier, &prefs);
+  scoped_ptr<web_resource::TestRequestAllowedNotifier> test_notifier =
+      make_scoped_ptr(new web_resource::TestRequestAllowedNotifier(&prefs));
+  web_resource::TestRequestAllowedNotifier* raw_notifier = test_notifier.get();
+  TestVariationsService test_service(test_notifier.Pass(), &prefs);
 
-  test_notifier->SetRequestsAllowedOverride(true);
+  raw_notifier->SetRequestsAllowedOverride(true);
   test_service.StartRepeatedVariationsSeedFetch();
   EXPECT_TRUE(test_service.fetch_attempted());
 }
 
 TEST_F(VariationsServiceTest, SeedStoredWhenOKStatus) {
   TestingPrefServiceSimple prefs;
   VariationsService::RegisterPrefs(prefs.registry());
 
   TestVariationsService service(
-      new web_resource::TestRequestAllowedNotifier(&prefs), &prefs);
+      make_scoped_ptr(new web_resource::TestRequestAllowedNotifier(&prefs)),
+      &prefs);
   service.variations_server_url_ =
-      VariationsService::GetVariationsServerURL(&prefs, std::string());
+      service.GetVariationsServerURL(&prefs, std::string());
   service.set_intercepts_fetch(false);
 
   net::TestURLFetcherFactory factory;
   service.DoActualFetch();
 
   net::TestURLFetcher* fetcher = factory.GetFetcherByID(0);
   SimulateServerResponse(net::HTTP_OK, fetcher);
   fetcher->SetResponseString(SerializeSeed(CreateTestSeed()));
 
   EXPECT_FALSE(service.seed_stored());
   service.OnURLFetchComplete(fetcher);
   EXPECT_TRUE(service.seed_stored());
 }
 
 TEST_F(VariationsServiceTest, SeedNotStoredWhenNonOKStatus) {
   const int non_ok_status_codes[] = {
     net::HTTP_NO_CONTENT,
     net::HTTP_NOT_MODIFIED,
     net::HTTP_NOT_FOUND,
     net::HTTP_INTERNAL_SERVER_ERROR,
     net::HTTP_SERVICE_UNAVAILABLE,
   };
 
   TestingPrefServiceSimple prefs;
   VariationsService::RegisterPrefs(prefs.registry());
 
   VariationsService service(
       make_scoped_ptr(new ChromeVariationsServiceClient()),
-      new web_resource::TestRequestAllowedNotifier(&prefs), &prefs, NULL);
+      make_scoped_ptr(new web_resource::TestRequestAllowedNotifier(&prefs)),
+      &prefs, NULL);
   service.variations_server_url_ =
-      VariationsService::GetVariationsServerURL(&prefs, std::string());
+      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);
 
     EXPECT_TRUE(prefs.FindPreference(prefs::kVariationsSeed)->IsDefaultValue());
   }
 }
 
 TEST_F(VariationsServiceTest, CountryHeader) {
   TestingPrefServiceSimple prefs;
   VariationsService::RegisterPrefs(prefs.registry());
 
   TestVariationsService service(
-      new web_resource::TestRequestAllowedNotifier(&prefs), &prefs);
+      make_scoped_ptr(new web_resource::TestRequestAllowedNotifier(&prefs)),
+      &prefs);
   service.variations_server_url_ =
-      VariationsService::GetVariationsServerURL(&prefs, std::string());
+      service.GetVariationsServerURL(&prefs, std::string());
   service.set_intercepts_fetch(false);
 
   net::TestURLFetcherFactory factory;
   service.DoActualFetch();
 
   net::TestURLFetcher* fetcher = factory.GetFetcherByID(0);
   scoped_refptr<net::HttpResponseHeaders> headers =
       SimulateServerResponse(net::HTTP_OK, fetcher);
   headers->AddHeader("X-Country: test");
   fetcher->SetResponseString(SerializeSeed(CreateTestSeed()));
 
   EXPECT_FALSE(service.seed_stored());
   service.OnURLFetchComplete(fetcher);
   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 ChromeVariationsServiceClient()),
-      new web_resource::TestRequestAllowedNotifier(&prefs), &prefs, NULL);
+      make_scoped_ptr(new web_resource::TestRequestAllowedNotifier(&prefs)),
+      &prefs, NULL);
 
   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 78 matching lines @@
        VariationsService::LOAD_COUNTRY_INVALID_PREF_HAS_SEED},
       {"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 ChromeVariationsServiceClient()),
-        new web_resource::TestRequestAllowedNotifier(&prefs), &prefs, NULL);
+        make_scoped_ptr(new web_resource::TestRequestAllowedNotifier(&prefs)),
+        &prefs, NULL);
 
     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 chrome_variations