Create a content::UrlFetcher interface that lives in content/public/common and convert users to i...

content/browser/geolocation/network_location_provider_unittest.cc

 // Copyright (c) 2011 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"
@@ skipping 268 matching lines @@
   SUCCEED();
 }
 
 TEST_F(GeolocationNetworkProviderTest, StartProvider) {
   scoped_ptr<LocationProviderBase> provider(CreateProvider(true));
   EXPECT_TRUE(provider->StartProvider(false));
   TestURLFetcher* fetcher = get_url_fetcher_and_advance_id();
   ASSERT_TRUE(fetcher != NULL);
 
   EXPECT_EQ(test_server_url_.spec() + kTestJson,
-            fetcher->original_url().spec());
+            fetcher->GetOriginalUrl().spec());
 
-  CheckRequestIsValid(fetcher->original_url().spec(), 0, 0, 0, "");
+  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();
   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->original_url().spec().size(), size_t(2048));
-  CheckRequestIsValid(fetcher->original_url().spec(), 0, 16, 4, "");
+  EXPECT_LT(fetcher->GetOriginalUrl().spec().size(), size_t(2048));
+  CheckRequestIsValid(fetcher->GetOriginalUrl().spec(), 0, 16, 4, "");
 }
 
 TEST_F(GeolocationNetworkProviderTest, MultipleStartProvider) {
   scoped_ptr<LocationProviderBase> provider_1(CreateProvider(true));
   scoped_ptr<LocationProviderBase> provider_2(CreateProvider(true));
   ASSERT_TRUE(radio_data_provider_);
   ASSERT_TRUE(wifi_data_provider_);
   EXPECT_EQ(0, radio_data_provider_->start_calls_);
   EXPECT_EQ(0, wifi_data_provider_->start_calls_);
   EXPECT_EQ(0, radio_data_provider_->stop_calls_);
@@ skipping 34 matching lines @@
   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();
   ASSERT_TRUE(fetcher != NULL);
   EXPECT_EQ(test_server_url_.spec() + kTestJson,
-            fetcher->original_url().spec());
+            fetcher->GetOriginalUrl().spec());
 
   // Complete the network request with bad position fix.
   const char* kNoFixNetworkResponse =
       "{"
       "  \"status\": \"ZERO_RESULTS\""
       "}";
   fetcher->set_url(test_server_url_);
   fetcher->set_status(net::URLRequestStatus());
   fetcher->set_response_code(200);  // OK
   fetcher->SetResponseString(kNoFixNetworkResponse);
   fetcher->delegate()->OnURLFetchComplete(fetcher);
 
   Geoposition position;
   provider->GetPosition(&position);
   EXPECT_FALSE(position.IsValidFix());
 
   // Now wifi data arrives -- SetData will notify listeners.
   const int kFirstScanAps = 6;
   wifi_data_provider_->SetData(CreateReferenceWifiScanData(kFirstScanAps));
   main_message_loop_.RunAllPending();
   fetcher = get_url_fetcher_and_advance_id();
   ASSERT_TRUE(fetcher != NULL);
   // The request should have the wifi data.
-  CheckRequestIsValid(fetcher->original_url().spec(), 0, kFirstScanAps, 0, "");
+  CheckRequestIsValid(
+      fetcher->GetOriginalUrl().spec(), 0, kFirstScanAps, 0, "");
 
   // Send a reply with good position fix.
   const char* kReferenceNetworkResponse =
       "{"
       "  \"status\": \"OK\","
       "  \"access_token\": \"" REFERENCE_ACCESS_TOKEN "\","
       "  \"accuracy\": 1200.4,"
       "  \"location\": {"
       "    \"lat\": 51.0,"
       "    \"lng\": -0.1"
@@ skipping 28 matching lines @@
   EXPECT_EQ(51.0, position.latitude);
   EXPECT_EQ(-0.1, position.longitude);
   EXPECT_TRUE(position.IsValidFix());
 
   // Now a third scan with more than twice the original amount -> new request.
   const int kThirdScanAps = kFirstScanAps * 2 + 1;
   wifi_data_provider_->SetData(CreateReferenceWifiScanData(kThirdScanAps));
   main_message_loop_.RunAllPending();
   fetcher = get_url_fetcher_and_advance_id();
   EXPECT_TRUE(fetcher);
-  CheckRequestIsValid(fetcher->original_url().spec(), 0,
+  CheckRequestIsValid(fetcher->GetOriginalUrl().spec(), 0,
                       kThirdScanAps, 0,
                       REFERENCE_ACCESS_TOKEN);
   // ...reply with a network error.
 
   fetcher->set_url(test_server_url_);
   fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::FAILED, -1));
   fetcher->set_response_code(200);  // should be ignored
   fetcher->SetResponseString("");
   fetcher->delegate()->OnURLFetchComplete(fetcher);
 
@@ skipping 48 matching lines @@
   scoped_ptr<LocationProviderBase> provider(CreateProvider(false));
   EXPECT_TRUE(provider->StartProvider(false));
   TestURLFetcher* fetcher = get_url_fetcher_and_advance_id();
   EXPECT_FALSE(fetcher);
   provider->OnPermissionGranted(GURL(kTestHostUrl));
 
   fetcher = get_url_fetcher_and_advance_id();
   ASSERT_TRUE(fetcher != NULL);
 
   EXPECT_EQ(test_server_url_.spec() + kTestJson,
-            fetcher->original_url().spec());
+            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();
   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(GURL(kTestHostUrl));
 
   fetcher = get_url_fetcher_and_advance_id();
   ASSERT_TRUE(fetcher != NULL);
 
-  CheckRequestIsValid(fetcher->original_url().spec(), 0,
+  CheckRequestIsValid(fetcher->GetOriginalUrl().spec(), 0,
                       kScanCount, 0, REFERENCE_ACCESS_TOKEN);
 }
 
 TEST_F(GeolocationNetworkProviderTest, NetworkPositionCache) {
   NetworkLocationProvider::PositionCache cache;
 
   const int kCacheSize = NetworkLocationProvider::PositionCache::kMaximumSize;
   for (int i = 1; i < kCacheSize * 2 + 1; ++i) {
     Geoposition pos = CreateReferencePosition(i);
     bool ret = cache.CachePosition(CreateReferenceWifiScanData(i), pos);
     EXPECT_TRUE(ret)  << i;
     const Geoposition* item =
         cache.FindPosition(CreateReferenceWifiScanData(i));
     ASSERT_TRUE(item) << i;
     EXPECT_EQ(pos.latitude, item->latitude)  << i;
     EXPECT_EQ(pos.longitude, item->longitude)  << i;
     if (i <= kCacheSize) {
       // Nothing should have spilled yet; check oldest item is still there.
       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