Move test_url_fetcher_factory.* from content/ to net/url_request

content/browser/geolocation/network_location_provider_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 "base/json/json_reader.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "content/browser/geolocation/fake_access_token_store.h"
 #include "content/browser/geolocation/network_location_provider.h"
-#include "content/public/test/test_url_fetcher_factory.h"
+#include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_request_status.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using content::FakeAccessTokenStore;
 using content::Geoposition;
 
 namespace {
 
 // Constants used in multiple tests.
 const char kTestServerUrl[] = "https://www.geolocation.test/service";
@@ skipping 126 matching lines @@
  protected:
   GeolocationNetworkProviderTest() : test_server_url_(kTestServerUrl) {
     // TODO(joth): Really these should be in SetUp, not here, but they take no
     // effect on Mac OS Release builds if done there. I kid not. Figure out why.
     WifiDataProvider::SetFactory(
         MockDeviceDataProviderImpl<WifiData>::GetInstance);
   }
 
   // Returns the current url fetcher (if any) and advances the id ready for the
   // next test step.
-  TestURLFetcher* get_url_fetcher_and_advance_id() {
-    TestURLFetcher* fetcher = url_fetcher_factory_.GetFetcherByID(
+  net::TestURLFetcher* get_url_fetcher_and_advance_id() {
+    net::TestURLFetcher* fetcher = url_fetcher_factory_.GetFetcherByID(
             NetworkLocationRequest::url_fetcher_id_for_tests);
     if (fetcher)
       ++NetworkLocationRequest::url_fetcher_id_for_tests;
     return fetcher;
   }
 
   static int IndexToChannel(int index) { return index + 4; }
 
   // Creates wifi data containing the specified number of access points, with
   // some differentiating charactistics in each.
@@ skipping 87 matching lines @@
       // SSID.
       EXPECT_EQ(expected_wifi_tokens[5], actual_wifi_tokens[5]);
       EXPECT_EQ(expected_wifi_tokens[6], actual_wifi_tokens[6]);
     }
     EXPECT_TRUE(GURL(request_url).is_valid());
   }
 
   const GURL test_server_url_;
   MessageLoop main_message_loop_;
   scoped_refptr<FakeAccessTokenStore> access_token_store_;
-  TestURLFetcherFactory url_fetcher_factory_;
+  net::TestURLFetcherFactory url_fetcher_factory_;
   scoped_refptr<MockDeviceDataProviderImpl<WifiData> > wifi_data_provider_;
 };
 
 
 TEST_F(GeolocationNetworkProviderTest, CreateDestroy) {
   // Test fixture members were SetUp correctly.
   EXPECT_EQ(&main_message_loop_, MessageLoop::current());
   scoped_ptr<LocationProviderBase> provider(CreateProvider(true));
   EXPECT_TRUE(NULL != provider.get());
   provider.reset();
   SUCCEED();
 }
 
 TEST_F(GeolocationNetworkProviderTest, StartProvider) {
   scoped_ptr<LocationProviderBase> provider(CreateProvider(true));
   EXPECT_TRUE(provider->StartProvider(false));
-  TestURLFetcher* fetcher = get_url_fetcher_and_advance_id();
+  net::TestURLFetcher* fetcher = get_url_fetcher_and_advance_id();
   ASSERT_TRUE(fetcher != NULL);
 
   EXPECT_EQ(test_server_url_.spec() + kTestJson,
             fetcher->GetOriginalURL().spec());
 
   CheckRequestIsValid(fetcher->GetOriginalURL().spec(), 0, 0, 0, "");
 }
 
 TEST_F(GeolocationNetworkProviderTest, StartProviderLongRequest) {
   scoped_ptr<LocationProviderBase> provider(CreateProvider(true));
   EXPECT_TRUE(provider->StartProvider(false));
   const int kFirstScanAps = 20;
   wifi_data_provider_->SetData(CreateReferenceWifiScanData(kFirstScanAps));
   main_message_loop_.RunAllPending();
-  TestURLFetcher* fetcher = get_url_fetcher_and_advance_id();
+  net::TestURLFetcher* fetcher = get_url_fetcher_and_advance_id();
   ASSERT_TRUE(fetcher != NULL);
   // The request url should have been shortened to less than 2048 characters
   // in length by not including access points with the lowest signal strength
   // in the request.
   EXPECT_LT(fetcher->GetOriginalURL().spec().size(), size_t(2048));
   CheckRequestIsValid(fetcher->GetOriginalURL().spec(), 0, 16, 4, "");
 }
 
 TEST_F(GeolocationNetworkProviderTest, MultiRegistrations) {
   // TODO(joth): Strictly belongs in a base-class unit test file.
   MessageLoopQuitListener listener;
   scoped_ptr<LocationProviderBase> provider(CreateProvider(true));
   EXPECT_FALSE(provider->has_listeners());
   provider->RegisterListener(&listener);
   EXPECT_TRUE(provider->has_listeners());
   provider->RegisterListener(&listener);
   EXPECT_TRUE(provider->has_listeners());
 
   provider->UnregisterListener(&listener);
   EXPECT_TRUE(provider->has_listeners());
   provider->UnregisterListener(&listener);
   EXPECT_FALSE(provider->has_listeners());
 }
 
 TEST_F(GeolocationNetworkProviderTest, MultipleWifiScansComplete) {
   scoped_ptr<LocationProviderBase> provider(CreateProvider(true));
   EXPECT_TRUE(provider->StartProvider(false));
 
-  TestURLFetcher* fetcher = get_url_fetcher_and_advance_id();
+  net::TestURLFetcher* fetcher = get_url_fetcher_and_advance_id();
   ASSERT_TRUE(fetcher != NULL);
   EXPECT_EQ(test_server_url_.spec() + kTestJson,
             fetcher->GetOriginalURL().spec());
 
   // Complete the network request with bad position fix.
   const char* kNoFixNetworkResponse =
       "{"
       "  \"status\": \"ZERO_RESULTS\""
       "}";
   fetcher->set_url(test_server_url_);
@@ skipping 103 matching lines @@
 
   wifi_data_provider_->SetData(CreateReferenceWifiScanData(1));
   main_message_loop_.RunAllPending();
   EXPECT_TRUE(get_url_fetcher_and_advance_id());
 }
 
 TEST_F(GeolocationNetworkProviderTest, NewDataReplacesExistingNetworkRequest) {
   // Send initial request with empty device data
   scoped_ptr<LocationProviderBase> provider(CreateProvider(true));
   EXPECT_TRUE(provider->StartProvider(false));
-  TestURLFetcher* fetcher = get_url_fetcher_and_advance_id();
+  net::TestURLFetcher* fetcher = get_url_fetcher_and_advance_id();
   EXPECT_TRUE(fetcher);
 
   // Now wifi data arrives; new request should be sent.
   wifi_data_provider_->SetData(CreateReferenceWifiScanData(4));
   main_message_loop_.RunAllPending();
   fetcher = get_url_fetcher_and_advance_id();
   EXPECT_TRUE(fetcher);
 }
 
 TEST_F(GeolocationNetworkProviderTest, NetworkRequestDeferredForPermission) {
   scoped_ptr<LocationProviderBase> provider(CreateProvider(false));
   EXPECT_TRUE(provider->StartProvider(false));
-  TestURLFetcher* fetcher = get_url_fetcher_and_advance_id();
+  net::TestURLFetcher* fetcher = get_url_fetcher_and_advance_id();
   EXPECT_FALSE(fetcher);
   provider->OnPermissionGranted();
 
   fetcher = get_url_fetcher_and_advance_id();
   ASSERT_TRUE(fetcher != NULL);
 
   EXPECT_EQ(test_server_url_.spec() + kTestJson,
             fetcher->GetOriginalURL().spec());
 }
 
 TEST_F(GeolocationNetworkProviderTest,
        NetworkRequestWithWifiDataDeferredForPermission) {
   access_token_store_->access_token_set_[test_server_url_] =
       UTF8ToUTF16(REFERENCE_ACCESS_TOKEN);
   scoped_ptr<LocationProviderBase> provider(CreateProvider(false));
   EXPECT_TRUE(provider->StartProvider(false));
-  TestURLFetcher* fetcher = get_url_fetcher_and_advance_id();
+  net::TestURLFetcher* fetcher = get_url_fetcher_and_advance_id();
   EXPECT_FALSE(fetcher);
 
   static const int kScanCount = 4;
   wifi_data_provider_->SetData(CreateReferenceWifiScanData(kScanCount));
   main_message_loop_.RunAllPending();
 
   fetcher = get_url_fetcher_and_advance_id();
   EXPECT_FALSE(fetcher);
 
   provider->OnPermissionGranted();
@@ skipping 23 matching lines @@
       EXPECT_TRUE(cache.FindPosition(CreateReferenceWifiScanData(1)));
     } else {
       const int evicted = i - kCacheSize;
       EXPECT_FALSE(cache.FindPosition(CreateReferenceWifiScanData(evicted)));
       EXPECT_TRUE(cache.FindPosition(CreateReferenceWifiScanData(evicted + 1)));
     }
   }
 }
 
 }  // namespace