Prevent NetworkLocationProvider from sending wifi data if started low accuracy

device/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 "device/geolocation/network_location_provider.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <string>
@@ skipping 317 matching lines @@
   // Test fixture members were SetUp correctly.
   EXPECT_EQ(&main_message_loop_, base::MessageLoop::current());
   std::unique_ptr<LocationProvider> provider(CreateProvider(true));
   EXPECT_TRUE(provider);
   provider.reset();
   SUCCEED();
 }
 
 TEST_F(GeolocationNetworkProviderTest, StartProvider) {
   std::unique_ptr<LocationProvider> provider(CreateProvider(true));
-  EXPECT_TRUE(provider->StartProvider(false));
+  EXPECT_TRUE(provider->StartProvider(true));
   net::TestURLFetcher* fetcher = get_url_fetcher_and_advance_id();
   ASSERT_TRUE(fetcher);
   CheckRequestIsValid(*fetcher, 0, 0, 0, std::string());
 }
 
 TEST_F(GeolocationNetworkProviderTest, StartProviderDefaultUrl) {
   test_server_url_ = LocationArbitrator::DefaultNetworkProviderURL();
   std::unique_ptr<LocationProvider> provider(CreateProvider(true));
-  EXPECT_TRUE(provider->StartProvider(false));
+  EXPECT_TRUE(provider->StartProvider(true));
   net::TestURLFetcher* fetcher = get_url_fetcher_and_advance_id();
   ASSERT_TRUE(fetcher);
   CheckRequestIsValid(*fetcher, 0, 0, 0, std::string());
 }
 
 TEST_F(GeolocationNetworkProviderTest, StartProviderLongRequest) {
   std::unique_ptr<LocationProvider> provider(CreateProvider(true));
-  EXPECT_TRUE(provider->StartProvider(false));
+  EXPECT_TRUE(provider->StartProvider(true));
   const int kFirstScanAps = 20;
   wifi_data_provider_->SetData(CreateReferenceWifiScanData(kFirstScanAps));
   base::RunLoop().RunUntilIdle();
   net::TestURLFetcher* fetcher = get_url_fetcher_and_advance_id();
   ASSERT_TRUE(fetcher);
   // 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, 0, 16, 4, std::string());
 }
 
 TEST_F(GeolocationNetworkProviderTest, MultipleWifiScansComplete) {
   std::unique_ptr<LocationProvider> provider(CreateProvider(true));
-  EXPECT_TRUE(provider->StartProvider(false));
+  EXPECT_TRUE(provider->StartProvider(true));
 
   net::TestURLFetcher* fetcher = get_url_fetcher_and_advance_id();
   ASSERT_TRUE(fetcher);
   EXPECT_TRUE(IsTestServerUrl(fetcher->GetOriginalURL()));
 
   // Complete the network request with bad position fix.
   const char* kNoFixNetworkResponse =
       "{"
       "  \"status\": \"ZERO_RESULTS\""
       "}";
@@ skipping 83 matching lines @@
   position = provider->GetPosition();
   EXPECT_EQ(51.0, position.latitude);
   EXPECT_EQ(-0.1, position.longitude);
   EXPECT_TRUE(position.Validate());
 }
 
 TEST_F(GeolocationNetworkProviderTest, NoRequestOnStartupUntilWifiData) {
   MessageLoopQuitListener listener;
   wifi_data_provider_->set_got_data(false);
   std::unique_ptr<LocationProvider> provider(CreateProvider(true));
-  EXPECT_TRUE(provider->StartProvider(false));
+  EXPECT_TRUE(provider->StartProvider(true));
 
   provider->SetUpdateCallback(base::Bind(
       &MessageLoopQuitListener::OnLocationUpdate, base::Unretained(&listener)));
 
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(get_url_fetcher_and_advance_id())
       << "Network request should not be created right away on startup when "
          "wifi data has not yet arrived";
 
   wifi_data_provider_->SetData(CreateReferenceWifiScanData(1));
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(get_url_fetcher_and_advance_id());
 }
 
 TEST_F(GeolocationNetworkProviderTest, NewDataReplacesExistingNetworkRequest) {
   // Send initial request with empty data
   std::unique_ptr<LocationProvider> provider(CreateProvider(true));
-  EXPECT_TRUE(provider->StartProvider(false));
+  EXPECT_TRUE(provider->StartProvider(true));
   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));
   base::RunLoop().RunUntilIdle();
   fetcher = get_url_fetcher_and_advance_id();
   EXPECT_TRUE(fetcher);
 }
 
 TEST_F(GeolocationNetworkProviderTest, NetworkRequestDeferredForPermission) {
   std::unique_ptr<LocationProvider> provider(CreateProvider(false));
-  EXPECT_TRUE(provider->StartProvider(false));
+  EXPECT_TRUE(provider->StartProvider(true));
   net::TestURLFetcher* fetcher = get_url_fetcher_and_advance_id();
   EXPECT_FALSE(fetcher);
   provider->OnPermissionGranted();
 
   fetcher = get_url_fetcher_and_advance_id();
   ASSERT_TRUE(fetcher);
 
   EXPECT_TRUE(IsTestServerUrl(fetcher->GetOriginalURL()));
 }
 
 TEST_F(GeolocationNetworkProviderTest,
        NetworkRequestWithWifiDataDeferredForPermission) {
   access_token_store_->access_token_map_[test_server_url_] =
       base::UTF8ToUTF16(REFERENCE_ACCESS_TOKEN);
   std::unique_ptr<LocationProvider> provider(CreateProvider(false));
-  EXPECT_TRUE(provider->StartProvider(false));
+  EXPECT_TRUE(provider->StartProvider(true));
   net::TestURLFetcher* fetcher = get_url_fetcher_and_advance_id();
   EXPECT_FALSE(fetcher);
 
   static const int kScanCount = 4;
   wifi_data_provider_->SetData(CreateReferenceWifiScanData(kScanCount));
   base::RunLoop().RunUntilIdle();
 
   fetcher = get_url_fetcher_and_advance_id();
   EXPECT_FALSE(fetcher);
 
@@ skipping 22 matching lines @@
       // 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)));
     }
   }
 }
 
+TEST_F(GeolocationNetworkProviderTest, RequestLowAccuracyPosition) {
+  std::unique_ptr<LocationProvider> provider(CreateProvider(true));
+  EXPECT_TRUE(provider->StartProvider(false));
+  net::TestURLFetcher* fetcher = get_url_fetcher_and_advance_id();
+  ASSERT_TRUE(fetcher);
+  EXPECT_TRUE(IsTestServerUrl(fetcher->GetOriginalURL()));
+  CheckRequestIsValid(*fetcher, 0, 0, 0, std::string());
+
+  // Send a reply with good position fix.
+  const char* kReferenceNetworkResponse =
+      "{"
+      "  \"accessToken\": \"" REFERENCE_ACCESS_TOKEN
+      "\","
+      "  \"accuracy\": 1200.4,"
+      "  \"location\": {"
+      "    \"lat\": 51.0,"
+      "    \"lng\": -0.1"
+      "  }"
+      "}";
+  fetcher->set_url(test_server_url_);
+  fetcher->set_status(net::URLRequestStatus());
+  fetcher->set_response_code(200);  // OK
+  fetcher->SetResponseString(kReferenceNetworkResponse);
+  fetcher->delegate()->OnURLFetchComplete(fetcher);
+
+  Geoposition position = provider->GetPosition();
+  EXPECT_EQ(51.0, position.latitude);
+  EXPECT_EQ(-0.1, position.longitude);
+  EXPECT_EQ(1200.4, position.accuracy);
+  EXPECT_FALSE(position.timestamp.is_null());
+  EXPECT_TRUE(position.Validate());
+
+  // Wifi scans should not affect the provider and no new requests should be
+  // made.
+  wifi_data_provider_->SetData(CreateReferenceWifiScanData(5 /* ap_count */));
+  base::RunLoop().RunUntilIdle();
+  EXPECT_FALSE(get_url_fetcher_and_advance_id());  // No new request created.
+}
+
 }  // namespace device