content/browser/geolocation/network_location_provider_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/json/json_reader.h"
   6 #include "base/json/json_writer.h"
   7 #include "base/memory/scoped_ptr.h"
   8 #include "base/strings/string_number_conversions.h"
   9 #include "base/strings/string_util.h"
  10 #include "base/strings/stringprintf.h"
  11 #include "base/strings/utf_string_conversions.h"
  12 #include "base/values.h"
  13 #include "content/browser/geolocation/fake_access_token_store.h"
  14 #include "content/browser/geolocation/location_arbitrator_impl.h"
  15 #include "content/browser/geolocation/network_location_provider.h"
  16 #include "content/browser/geolocation/wifi_data_provider.h"
  17 #include "net/url_request/test_url_fetcher_factory.h"
  18 #include "net/url_request/url_request_status.h"
  19 #include "testing/gtest/include/gtest/gtest.h"
  20
  21 namespace content {
  22
  23 // Constants used in multiple tests.
  24 const char kTestServerUrl[] = "https://www.geolocation.test/service";
  25 const char kAccessTokenString[] = "accessToken";
  26
  27 // Using #define so we can easily paste this into various other strings.
  28 #define REFERENCE_ACCESS_TOKEN "2:k7j3G6LaL6u_lafw:4iXOeOpTh1glSXe"
  29
  30 // Stops the specified (nested) message loop when the listener is called back.
  31 class MessageLoopQuitListener {
  32  public:
  33   MessageLoopQuitListener()
  34       : client_message_loop_(base::MessageLoop::current()),
  35         updated_provider_(NULL) {
  36     CHECK(client_message_loop_);
  37   }
  38
  39   void OnLocationUpdate(const LocationProvider* provider,
  40                         const Geoposition& position) {
  41     EXPECT_EQ(client_message_loop_, base::MessageLoop::current());
  42     updated_provider_ = provider;
  43     client_message_loop_->Quit();
  44   }
  45
  46   base::MessageLoop* client_message_loop_;
  47   const LocationProvider* updated_provider_;
  48 };
  49
  50 // A mock implementation of WifiDataProvider for testing. Adapted from
  51 // http://gears.googlecode.com/svn/trunk/gears/geolocation/geolocation_test.cc
  52 class MockWifiDataProvider : public WifiDataProvider {
  53  public:
  54   // Factory method for use with WifiDataProvider::SetFactoryForTesting.
  55   static WifiDataProvider* GetInstance() {
  56     CHECK(instance_);
  57     return instance_;
  58   }
  59
  60   static MockWifiDataProvider* CreateInstance() {
  61     CHECK(!instance_);
  62     instance_ = new MockWifiDataProvider;
  63     return instance_;
  64   }
  65
  66   MockWifiDataProvider() : start_calls_(0), stop_calls_(0), got_data_(true) {}
  67
  68   // WifiDataProvider implementation.
  69   virtual void StartDataProvider() OVERRIDE {
  70     ++start_calls_;
  71   }
  72
  73   virtual void StopDataProvider() OVERRIDE {
  74     ++stop_calls_;
  75   }
  76
  77   virtual bool GetData(WifiData* data_out) OVERRIDE {
  78     CHECK(data_out);
  79     *data_out = data_;
  80     return got_data_;
  81   }
  82
  83   void SetData(const WifiData& new_data) {
  84     got_data_ = true;
  85     const bool differs = data_.DiffersSignificantly(new_data);
  86     data_ = new_data;
  87     if (differs)
  88       this->RunCallbacks();
  89   }
  90
  91   void set_got_data(bool got_data) { got_data_ = got_data; }
  92   int start_calls_;
  93   int stop_calls_;
  94
  95  private:
  96   virtual ~MockWifiDataProvider() {
  97     CHECK(this == instance_);
  98     instance_ = NULL;
  99   }
 100
 101   static MockWifiDataProvider* instance_;
 102
 103   WifiData data_;
 104   bool got_data_;
 105
 106   DISALLOW_COPY_AND_ASSIGN(MockWifiDataProvider);
 107 };
 108
 109 MockWifiDataProvider* MockWifiDataProvider::instance_ = NULL;
 110
 111 // Main test fixture
 112 class GeolocationNetworkProviderTest : public testing::Test {
 113  public:
 114   virtual void SetUp() {
 115     test_server_url_ = GURL(kTestServerUrl);
 116     access_token_store_ = new FakeAccessTokenStore;
 117     wifi_data_provider_ = MockWifiDataProvider::CreateInstance();
 118   }
 119
 120   virtual void TearDown() { WifiDataProviderManager::ResetFactoryForTesting(); }
 121
 122   LocationProvider* CreateProvider(bool set_permission_granted) {
 123     LocationProvider* provider = NewNetworkLocationProvider(
 124         access_token_store_.get(),
 125         NULL,  // No URLContextGetter needed, as using test urlfecther factory.
 126         test_server_url_,
 127         access_token_store_->access_token_set_[test_server_url_]);
 128     if (set_permission_granted)
 129       provider->OnPermissionGranted();
 130     return provider;
 131   }
 132
 133  protected:
 134   GeolocationNetworkProviderTest() {
 135     // TODO(joth): Really these should be in SetUp, not here, but they take no
 136     // effect on Mac OS Release builds if done there. I kid not. Figure out why.
 137     WifiDataProviderManager::SetFactoryForTesting(
 138         MockWifiDataProvider::GetInstance);
 139   }
 140
 141   // Returns the current url fetcher (if any) and advances the id ready for the
 142   // next test step.
 143   net::TestURLFetcher* get_url_fetcher_and_advance_id() {
 144     net::TestURLFetcher* fetcher = url_fetcher_factory_.GetFetcherByID(
 145             NetworkLocationRequest::url_fetcher_id_for_tests);
 146     if (fetcher)
 147       ++NetworkLocationRequest::url_fetcher_id_for_tests;
 148     return fetcher;
 149   }
 150
 151   static int IndexToChannel(int index) { return index + 4; }
 152
 153   // Creates wifi data containing the specified number of access points, with
 154   // some differentiating charactistics in each.
 155   static WifiData CreateReferenceWifiScanData(int ap_count) {
 156     WifiData data;
 157     for (int i = 0; i < ap_count; ++i) {
 158       AccessPointData ap;
 159       ap.mac_address =
 160           base::ASCIIToUTF16(base::StringPrintf("%02d-34-56-78-54-32", i));
 161       ap.radio_signal_strength = ap_count - i;
 162       ap.channel = IndexToChannel(i);
 163       ap.signal_to_noise = i + 42;
 164       ap.ssid = base::ASCIIToUTF16("Some nice+network|name\\");
 165       data.access_point_data.insert(ap);
 166     }
 167     return data;
 168   }
 169
 170   static void CreateReferenceWifiScanDataJson(
 171       int ap_count, int start_index, base::ListValue* wifi_access_point_list) {
 172     std::vector<std::string> wifi_data;
 173     for (int i = 0; i < ap_count; ++i) {
 174       base::DictionaryValue* ap = new base::DictionaryValue();
 175       ap->SetString("macAddress", base::StringPrintf("%02d-34-56-78-54-32", i));
 176       ap->SetInteger("signalStrength", start_index + ap_count - i);
 177       ap->SetInteger("age", 0);
 178       ap->SetInteger("channel", IndexToChannel(i));
 179       ap->SetInteger("signalToNoiseRatio", i + 42);
 180       wifi_access_point_list->Append(ap);
 181     }
 182   }
 183
 184   static Geoposition CreateReferencePosition(int id) {
 185     Geoposition pos;
 186     pos.latitude = id;
 187     pos.longitude = -(id + 1);
 188     pos.altitude = 2 * id;
 189     pos.timestamp = base::Time::Now();
 190     return pos;
 191   }
 192
 193   static std::string PrettyJson(const base::Value& value) {
 194     std::string pretty;
 195     base::JSONWriter::WriteWithOptions(
 196         &value, base::JSONWriter::OPTIONS_PRETTY_PRINT, &pretty);
 197     return pretty;
 198   }
 199
 200   static testing::AssertionResult JsonGetList(
 201       const std::string& field,
 202       const base::DictionaryValue& dict,
 203       const base::ListValue** output_list) {
 204     if (!dict.GetList(field, output_list))
 205       return testing::AssertionFailure() << "Dictionary " << PrettyJson(dict)
 206                                          << " is missing list field " << field;
 207     return testing::AssertionSuccess();
 208   }
 209
 210   static testing::AssertionResult JsonFieldEquals(
 211       const std::string& field,
 212       const base::DictionaryValue& expected,
 213       const base::DictionaryValue& actual) {
 214     const base::Value* expected_value;
 215     const base::Value* actual_value;
 216     if (!expected.Get(field, &expected_value))
 217       return testing::AssertionFailure()
 218           << "Expected dictionary " << PrettyJson(expected)
 219           << " is missing field " << field;
 220     if (!expected.Get(field, &actual_value))
 221       return testing::AssertionFailure()
 222           << "Actual dictionary " << PrettyJson(actual)
 223           << " is missing field " << field;
 224     if (!expected_value->Equals(actual_value))
 225       return testing::AssertionFailure()
 226           << "Field " << field << " mismatch: " << PrettyJson(*expected_value)
 227           << " != " << PrettyJson(*actual_value);
 228     return testing::AssertionSuccess();
 229   }
 230
 231   static GURL UrlWithoutQuery(const GURL& url) {
 232     url::Replacements<char> replacements;
 233     replacements.ClearQuery();
 234     return url.ReplaceComponents(replacements);
 235   }
 236
 237   testing::AssertionResult IsTestServerUrl(const GURL& request_url) {
 238     const GURL a(UrlWithoutQuery(test_server_url_));
 239     const GURL b(UrlWithoutQuery(request_url));
 240     if (a == b)
 241       return testing::AssertionSuccess();
 242     return testing::AssertionFailure() << a << " != " << b;
 243   }
 244
 245   void CheckRequestIsValid(const net::TestURLFetcher& request,
 246                            int expected_routers,
 247                            int expected_wifi_aps,
 248                            int wifi_start_index,
 249                            const std::string& expected_access_token) {
 250     const GURL& request_url = request.GetOriginalURL();
 251
 252     EXPECT_TRUE(IsTestServerUrl(request_url));
 253
 254     // Check to see that the api key is being appended for the default
 255     // network provider url.
 256     bool is_default_url = UrlWithoutQuery(request_url) ==
 257         UrlWithoutQuery(LocationArbitratorImpl::DefaultNetworkProviderURL());
 258     EXPECT_EQ(is_default_url, !request_url.query().empty());
 259
 260     const std::string& upload_data = request.upload_data();
 261     ASSERT_FALSE(upload_data.empty());
 262     std::string json_parse_error_msg;
 263     scoped_ptr<base::Value> parsed_json(
 264         base::JSONReader::ReadAndReturnError(
 265             upload_data,
 266             base::JSON_PARSE_RFC,
 267             NULL,
 268             &json_parse_error_msg));
 269     EXPECT_TRUE(json_parse_error_msg.empty());
 270     ASSERT_TRUE(parsed_json.get() != NULL);
 271
 272     const base::DictionaryValue* request_json;
 273     ASSERT_TRUE(parsed_json->GetAsDictionary(&request_json));
 274
 275     if (!is_default_url) {
 276       if (expected_access_token.empty())
 277         ASSERT_FALSE(request_json->HasKey(kAccessTokenString));
 278       else {
 279         std::string access_token;
 280         EXPECT_TRUE(request_json->GetString(kAccessTokenString, &access_token));
 281         EXPECT_EQ(expected_access_token, access_token);
 282       }
 283     }
 284
 285     if (expected_wifi_aps) {
 286       base::ListValue expected_wifi_aps_json;
 287       CreateReferenceWifiScanDataJson(
 288           expected_wifi_aps,
 289           wifi_start_index,
 290           &expected_wifi_aps_json);
 291       EXPECT_EQ(size_t(expected_wifi_aps), expected_wifi_aps_json.GetSize());
 292
 293       const base::ListValue* wifi_aps_json;
 294       ASSERT_TRUE(JsonGetList("wifiAccessPoints", *request_json,
 295                               &wifi_aps_json));
 296       for (size_t i = 0; i < expected_wifi_aps_json.GetSize(); ++i ) {
 297         const base::DictionaryValue* expected_json;
 298         ASSERT_TRUE(expected_wifi_aps_json.GetDictionary(i, &expected_json));
 299         const base::DictionaryValue* actual_json;
 300         ASSERT_TRUE(wifi_aps_json->GetDictionary(i, &actual_json));
 301         ASSERT_TRUE(JsonFieldEquals("macAddress", *expected_json,
 302                                     *actual_json));
 303         ASSERT_TRUE(JsonFieldEquals("signalStrength", *expected_json,
 304                                     *actual_json));
 305         ASSERT_TRUE(JsonFieldEquals("channel", *expected_json, *actual_json));
 306         ASSERT_TRUE(JsonFieldEquals("signalToNoiseRatio", *expected_json,
 307                                     *actual_json));
 308       }
 309     } else {
 310       ASSERT_FALSE(request_json->HasKey("wifiAccessPoints"));
 311     }
 312     EXPECT_TRUE(request_url.is_valid());
 313   }
 314
 315   GURL test_server_url_;
 316   base::MessageLoop main_message_loop_;
 317   scoped_refptr<FakeAccessTokenStore> access_token_store_;
 318   net::TestURLFetcherFactory url_fetcher_factory_;
 319   scoped_refptr<MockWifiDataProvider> wifi_data_provider_;
 320 };
 321
 322 TEST_F(GeolocationNetworkProviderTest, CreateDestroy) {
 323   // Test fixture members were SetUp correctly.
 324   EXPECT_EQ(&main_message_loop_, base::MessageLoop::current());
 325   scoped_ptr<LocationProvider> provider(CreateProvider(true));
 326   EXPECT_TRUE(NULL != provider.get());
 327   provider.reset();
 328   SUCCEED();
 329 }
 330
 331 TEST_F(GeolocationNetworkProviderTest, StartProvider) {
 332   scoped_ptr<LocationProvider> provider(CreateProvider(true));
 333   EXPECT_TRUE(provider->StartProvider(false));
 334   net::TestURLFetcher* fetcher = get_url_fetcher_and_advance_id();
 335   ASSERT_TRUE(fetcher != NULL);
 336   CheckRequestIsValid(*fetcher, 0, 0, 0, std::string());
 337 }
 338
 339 TEST_F(GeolocationNetworkProviderTest, StartProviderDefaultUrl) {
 340   test_server_url_ = LocationArbitratorImpl::DefaultNetworkProviderURL();
 341   scoped_ptr<LocationProvider> provider(CreateProvider(true));
 342   EXPECT_TRUE(provider->StartProvider(false));
 343   net::TestURLFetcher* fetcher = get_url_fetcher_and_advance_id();
 344   ASSERT_TRUE(fetcher != NULL);
 345   CheckRequestIsValid(*fetcher, 0, 0, 0, std::string());
 346 }
 347
 348 TEST_F(GeolocationNetworkProviderTest, StartProviderLongRequest) {
 349   scoped_ptr<LocationProvider> provider(CreateProvider(true));
 350   EXPECT_TRUE(provider->StartProvider(false));
 351   const int kFirstScanAps = 20;
 352   wifi_data_provider_->SetData(CreateReferenceWifiScanData(kFirstScanAps));
 353   main_message_loop_.RunUntilIdle();
 354   net::TestURLFetcher* fetcher = get_url_fetcher_and_advance_id();
 355   ASSERT_TRUE(fetcher != NULL);
 356   // The request url should have been shortened to less than 2048 characters
 357   // in length by not including access points with the lowest signal strength
 358   // in the request.
 359   EXPECT_LT(fetcher->GetOriginalURL().spec().size(), size_t(2048));
 360   CheckRequestIsValid(*fetcher, 0, 16, 4, std::string());
 361 }
 362
 363 TEST_F(GeolocationNetworkProviderTest, MultipleWifiScansComplete) {
 364   scoped_ptr<LocationProvider> provider(CreateProvider(true));
 365   EXPECT_TRUE(provider->StartProvider(false));
 366
 367   net::TestURLFetcher* fetcher = get_url_fetcher_and_advance_id();
 368   ASSERT_TRUE(fetcher != NULL);
 369   EXPECT_TRUE(IsTestServerUrl(fetcher->GetOriginalURL()));
 370
 371   // Complete the network request with bad position fix.
 372   const char* kNoFixNetworkResponse =
 373       "{"
 374       "  \"status\": \"ZERO_RESULTS\""
 375       "}";
 376   fetcher->set_url(test_server_url_);
 377   fetcher->set_status(net::URLRequestStatus());
 378   fetcher->set_response_code(200);  // OK
 379   fetcher->SetResponseString(kNoFixNetworkResponse);
 380   fetcher->delegate()->OnURLFetchComplete(fetcher);
 381
 382   Geoposition position;
 383   provider->GetPosition(&position);
 384   EXPECT_FALSE(position.Validate());
 385
 386   // Now wifi data arrives -- SetData will notify listeners.
 387   const int kFirstScanAps = 6;
 388   wifi_data_provider_->SetData(CreateReferenceWifiScanData(kFirstScanAps));
 389   main_message_loop_.RunUntilIdle();
 390   fetcher = get_url_fetcher_and_advance_id();
 391   ASSERT_TRUE(fetcher != NULL);
 392   // The request should have the wifi data.
 393   CheckRequestIsValid(*fetcher, 0, kFirstScanAps, 0, std::string());
 394
 395   // Send a reply with good position fix.
 396   const char* kReferenceNetworkResponse =
 397       "{"
 398       "  \"accessToken\": \"" REFERENCE_ACCESS_TOKEN "\","
 399       "  \"accuracy\": 1200.4,"
 400       "  \"location\": {"
 401       "    \"lat\": 51.0,"
 402       "    \"lng\": -0.1"
 403       "  }"
 404       "}";
 405   fetcher->set_url(test_server_url_);
 406   fetcher->set_status(net::URLRequestStatus());
 407   fetcher->set_response_code(200);  // OK
 408   fetcher->SetResponseString(kReferenceNetworkResponse);
 409   fetcher->delegate()->OnURLFetchComplete(fetcher);
 410
 411   provider->GetPosition(&position);
 412   EXPECT_EQ(51.0, position.latitude);
 413   EXPECT_EQ(-0.1, position.longitude);
 414   EXPECT_EQ(1200.4, position.accuracy);
 415   EXPECT_FALSE(position.timestamp.is_null());
 416   EXPECT_TRUE(position.Validate());
 417
 418   // Token should be in the store.
 419   EXPECT_EQ(base::UTF8ToUTF16(REFERENCE_ACCESS_TOKEN),
 420             access_token_store_->access_token_set_[test_server_url_]);
 421
 422   // Wifi updated again, with one less AP. This is 'close enough' to the
 423   // previous scan, so no new request made.
 424   const int kSecondScanAps = kFirstScanAps - 1;
 425   wifi_data_provider_->SetData(CreateReferenceWifiScanData(kSecondScanAps));
 426   main_message_loop_.RunUntilIdle();
 427   fetcher = get_url_fetcher_and_advance_id();
 428   EXPECT_FALSE(fetcher);
 429
 430   provider->GetPosition(&position);
 431   EXPECT_EQ(51.0, position.latitude);
 432   EXPECT_EQ(-0.1, position.longitude);
 433   EXPECT_TRUE(position.Validate());
 434
 435   // Now a third scan with more than twice the original amount -> new request.
 436   const int kThirdScanAps = kFirstScanAps * 2 + 1;
 437   wifi_data_provider_->SetData(CreateReferenceWifiScanData(kThirdScanAps));
 438   main_message_loop_.RunUntilIdle();
 439   fetcher = get_url_fetcher_and_advance_id();
 440   EXPECT_TRUE(fetcher);
 441   CheckRequestIsValid(*fetcher, 0, kThirdScanAps, 0, REFERENCE_ACCESS_TOKEN);
 442   // ...reply with a network error.
 443
 444   fetcher->set_url(test_server_url_);
 445   fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::FAILED, -1));
 446   fetcher->set_response_code(200);  // should be ignored
 447   fetcher->SetResponseString(std::string());
 448   fetcher->delegate()->OnURLFetchComplete(fetcher);
 449
 450   // Error means we now no longer have a fix.
 451   provider->GetPosition(&position);
 452   EXPECT_FALSE(position.Validate());
 453
 454   // Wifi scan returns to original set: should be serviced from cache.
 455   wifi_data_provider_->SetData(CreateReferenceWifiScanData(kFirstScanAps));
 456   main_message_loop_.RunUntilIdle();
 457   EXPECT_FALSE(get_url_fetcher_and_advance_id());  // No new request created.
 458
 459   provider->GetPosition(&position);
 460   EXPECT_EQ(51.0, position.latitude);
 461   EXPECT_EQ(-0.1, position.longitude);
 462   EXPECT_TRUE(position.Validate());
 463 }
 464
 465 TEST_F(GeolocationNetworkProviderTest, NoRequestOnStartupUntilWifiData) {
 466   MessageLoopQuitListener listener;
 467   wifi_data_provider_->set_got_data(false);
 468   scoped_ptr<LocationProvider> provider(CreateProvider(true));
 469   EXPECT_TRUE(provider->StartProvider(false));
 470
 471   provider->SetUpdateCallback(base::Bind(
 472       &MessageLoopQuitListener::OnLocationUpdate, base::Unretained(&listener)));
 473
 474   main_message_loop_.RunUntilIdle();
 475   EXPECT_FALSE(get_url_fetcher_and_advance_id())
 476       << "Network request should not be created right away on startup when "
 477          "wifi data has not yet arrived";
 478
 479   wifi_data_provider_->SetData(CreateReferenceWifiScanData(1));
 480   main_message_loop_.RunUntilIdle();
 481   EXPECT_TRUE(get_url_fetcher_and_advance_id());
 482 }
 483
 484 TEST_F(GeolocationNetworkProviderTest, NewDataReplacesExistingNetworkRequest) {
 485   // Send initial request with empty data
 486   scoped_ptr<LocationProvider> provider(CreateProvider(true));
 487   EXPECT_TRUE(provider->StartProvider(false));
 488   net::TestURLFetcher* fetcher = get_url_fetcher_and_advance_id();
 489   EXPECT_TRUE(fetcher);
 490
 491   // Now wifi data arrives; new request should be sent.
 492   wifi_data_provider_->SetData(CreateReferenceWifiScanData(4));
 493   main_message_loop_.RunUntilIdle();
 494   fetcher = get_url_fetcher_and_advance_id();
 495   EXPECT_TRUE(fetcher);
 496 }
 497
 498 TEST_F(GeolocationNetworkProviderTest, NetworkRequestDeferredForPermission) {
 499   scoped_ptr<LocationProvider> provider(CreateProvider(false));
 500   EXPECT_TRUE(provider->StartProvider(false));
 501   net::TestURLFetcher* fetcher = get_url_fetcher_and_advance_id();
 502   EXPECT_FALSE(fetcher);
 503   provider->OnPermissionGranted();
 504
 505   fetcher = get_url_fetcher_and_advance_id();
 506   ASSERT_TRUE(fetcher != NULL);
 507
 508   EXPECT_TRUE(IsTestServerUrl(fetcher->GetOriginalURL()));
 509 }
 510
 511 TEST_F(GeolocationNetworkProviderTest,
 512        NetworkRequestWithWifiDataDeferredForPermission) {
 513   access_token_store_->access_token_set_[test_server_url_] =
 514       base::UTF8ToUTF16(REFERENCE_ACCESS_TOKEN);
 515   scoped_ptr<LocationProvider> provider(CreateProvider(false));
 516   EXPECT_TRUE(provider->StartProvider(false));
 517   net::TestURLFetcher* fetcher = get_url_fetcher_and_advance_id();
 518   EXPECT_FALSE(fetcher);
 519
 520   static const int kScanCount = 4;
 521   wifi_data_provider_->SetData(CreateReferenceWifiScanData(kScanCount));
 522   main_message_loop_.RunUntilIdle();
 523
 524   fetcher = get_url_fetcher_and_advance_id();
 525   EXPECT_FALSE(fetcher);
 526
 527   provider->OnPermissionGranted();
 528
 529   fetcher = get_url_fetcher_and_advance_id();
 530   ASSERT_TRUE(fetcher != NULL);
 531
 532   CheckRequestIsValid(*fetcher, 0, kScanCount, 0, REFERENCE_ACCESS_TOKEN);
 533 }
 534
 535 TEST_F(GeolocationNetworkProviderTest, NetworkPositionCache) {
 536   NetworkLocationProvider::PositionCache cache;
 537
 538   const int kCacheSize = NetworkLocationProvider::PositionCache::kMaximumSize;
 539   for (int i = 1; i < kCacheSize * 2 + 1; ++i) {
 540     Geoposition pos = CreateReferencePosition(i);
 541     bool ret = cache.CachePosition(CreateReferenceWifiScanData(i), pos);
 542     EXPECT_TRUE(ret)  << i;
 543     const Geoposition* item =
 544         cache.FindPosition(CreateReferenceWifiScanData(i));
 545     ASSERT_TRUE(item) << i;
 546     EXPECT_EQ(pos.latitude, item->latitude)  << i;
 547     EXPECT_EQ(pos.longitude, item->longitude)  << i;
 548     if (i <= kCacheSize) {
 549       // Nothing should have spilled yet; check oldest item is still there.
 550       EXPECT_TRUE(cache.FindPosition(CreateReferenceWifiScanData(1)));
 551     } else {
 552       const int evicted = i - kCacheSize;
 553       EXPECT_FALSE(cache.FindPosition(CreateReferenceWifiScanData(evicted)));
 554       EXPECT_TRUE(cache.FindPosition(CreateReferenceWifiScanData(evicted + 1)));
 555     }
 556   }
 557 }
 558
 559 }  // namespace content