Revert of 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 246 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;
-  TestVariationsService service(
-      new web_resource::TestRequestAllowedNotifier(prefs), prefs);
-  GURL url = service.GetVariationsServerURL(prefs, std::string());
+  GURL url = VariationsService::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 = service.GetVariationsServerURL(prefs, std::string());
+  url = VariationsService::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 = service.GetVariationsServerURL(prefs, "override");
+  url = VariationsService::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());
-  TestVariationsService service(
-      new web_resource::TestRequestAllowedNotifier(&prefs), &prefs);
-  const GURL url = service.GetVariationsServerURL(&prefs, std::string());
+  const GURL url =
+      VariationsService::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());
 
@@ skipping 27 matching lines @@
   EXPECT_TRUE(test_service.fetch_attempted());
 }
 
 TEST_F(VariationsServiceTest, SeedStoredWhenOKStatus) {
   TestingPrefServiceSimple prefs;
   VariationsService::RegisterPrefs(prefs.registry());
 
   TestVariationsService service(
       new web_resource::TestRequestAllowedNotifier(&prefs), &prefs);
   service.variations_server_url_ =
-      service.GetVariationsServerURL(&prefs, std::string());
+      VariationsService::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());
@@ skipping 10 matching lines @@
     net::HTTP_SERVICE_UNAVAILABLE,
   };
 
   TestingPrefServiceSimple prefs;
   VariationsService::RegisterPrefs(prefs.registry());
 
   VariationsService service(
       make_scoped_ptr(new ChromeVariationsServiceClient()),
       new web_resource::TestRequestAllowedNotifier(&prefs), &prefs, NULL);
   service.variations_server_url_ =
-      service.GetVariationsServerURL(&prefs, std::string());
+      VariationsService::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);
   service.variations_server_url_ =
-      service.GetVariationsServerURL(&prefs, std::string());
+      VariationsService::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()));
@@ skipping 145 matching lines @@
         << test.pref_value_before << ", " << test.version << ", "
         << test.latest_country_code;
 
     histogram_tester.ExpectUniqueSample(
         "Variations.LoadPermanentConsistencyCountryResult",
         test.expected_result, 1);
   }
 }
 
 }  // namespace chrome_variations