Gets rid of the LocationArbitrator interface, in preference for LocationProvider.

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>
 #include <utility>
+#include <vector>
 
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/macros.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
@@ skipping 249 matching lines @@
     std::unique_ptr<base::Value> parsed_json =
         base::JSONReader::ReadAndReturnError(upload_data, base::JSON_PARSE_RFC,
                                              nullptr, &json_parse_error_msg);
     EXPECT_TRUE(json_parse_error_msg.empty());
     ASSERT_TRUE(parsed_json);
 
     const base::DictionaryValue* request_json;
     ASSERT_TRUE(parsed_json->GetAsDictionary(&request_json));
 
     if (!is_default_url) {
-      if (expected_access_token.empty())
+      if (expected_access_token.empty()) {
         ASSERT_FALSE(request_json->HasKey(kAccessTokenString));
-      else {
+      } else {
         std::string access_token;
         EXPECT_TRUE(request_json->GetString(kAccessTokenString, &access_token));
         EXPECT_EQ(expected_access_token, access_token);
       }
     }
 
     if (expected_wifi_aps) {
       base::ListValue expected_wifi_aps_json;
       CreateReferenceWifiScanDataJson(expected_wifi_aps, wifi_start_index,
                                       &expected_wifi_aps_json);
@@ skipping 81 matching lines @@
   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);
+  Geoposition position = provider->GetPosition();
   EXPECT_FALSE(position.Validate());
 
   // Now wifi data arrives -- SetData will notify listeners.
   const int kFirstScanAps = 6;
   wifi_data_provider_->SetData(CreateReferenceWifiScanData(kFirstScanAps));
   base::RunLoop().RunUntilIdle();
   fetcher = get_url_fetcher_and_advance_id();
   ASSERT_TRUE(fetcher);
   // The request should have the wifi data.
   CheckRequestIsValid(*fetcher, 0, kFirstScanAps, 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);
 
-  provider->GetPosition(&position);
+  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());
 
   // Token should be in the store.
   EXPECT_EQ(base::UTF8ToUTF16(REFERENCE_ACCESS_TOKEN),
             access_token_store_->access_token_map_[test_server_url_]);
 
   // Wifi updated again, with one less AP. This is 'close enough' to the
   // previous scan, so no new request made.
   const int kSecondScanAps = kFirstScanAps - 1;
   wifi_data_provider_->SetData(CreateReferenceWifiScanData(kSecondScanAps));
   base::RunLoop().RunUntilIdle();
   fetcher = get_url_fetcher_and_advance_id();
   EXPECT_FALSE(fetcher);
 
-  provider->GetPosition(&position);
+  position = provider->GetPosition();
   EXPECT_EQ(51.0, position.latitude);
   EXPECT_EQ(-0.1, position.longitude);
   EXPECT_TRUE(position.Validate());
 
   // 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));
   base::RunLoop().RunUntilIdle();
   fetcher = get_url_fetcher_and_advance_id();
   EXPECT_TRUE(fetcher);
   CheckRequestIsValid(*fetcher, 0, kThirdScanAps, 0, REFERENCE_ACCESS_TOKEN);
   // ...reply with a network error.
 
   fetcher->set_url(test_server_url_);
   fetcher->set_status(net::URLRequestStatus::FromError(net::ERR_FAILED));
   fetcher->set_response_code(200);  // should be ignored
   fetcher->SetResponseString(std::string());
   fetcher->delegate()->OnURLFetchComplete(fetcher);
 
   // Error means we now no longer have a fix.
-  provider->GetPosition(&position);
+  position = provider->GetPosition();
   EXPECT_FALSE(position.Validate());
 
   // Wifi scan returns to original set: should be serviced from cache.
   wifi_data_provider_->SetData(CreateReferenceWifiScanData(kFirstScanAps));
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(get_url_fetcher_and_advance_id());  // No new request created.
 
-  provider->GetPosition(&position);
+  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));
@@ skipping 80 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 device