Make the Geoposition helper class public

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/test/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";
 const char kTestJson[] = "?browser=chromium&sensor=true";
 const char kTestBrowser[] = "browser=chromium";
 const char kTestSensor[] = "sensor=true";
 // Using #define so we can easily paste this into various other strings.
 #define REFERENCE_ACCESS_TOKEN "2:k7j3G6LaL6u_lafw:4iXOeOpTh1glSXe"
@@ skipping 337 matching lines @@
       "  \"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());
+  EXPECT_FALSE(position.Validate());
 
   // 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->GetOriginalURL().spec(), 0, kFirstScanAps, 0, "");
@@ skipping 12 matching lines @@
   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);
   EXPECT_EQ(51.0, position.latitude);
   EXPECT_EQ(-0.1, position.longitude);
   EXPECT_EQ(1200.4, position.accuracy);
-  EXPECT_TRUE(position.is_valid_timestamp());
-  EXPECT_TRUE(position.IsValidFix());
+  EXPECT_FALSE(position.timestamp.is_null());
+  EXPECT_TRUE(position.Validate());
 
   // Token should be in the store.
   EXPECT_EQ(UTF8ToUTF16(REFERENCE_ACCESS_TOKEN),
             access_token_store_->access_token_set_[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));
   main_message_loop_.RunAllPending();
   fetcher = get_url_fetcher_and_advance_id();
   EXPECT_FALSE(fetcher);
 
   provider->GetPosition(&position);
   EXPECT_EQ(51.0, position.latitude);
   EXPECT_EQ(-0.1, position.longitude);
-  EXPECT_TRUE(position.IsValidFix());
+  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));
   main_message_loop_.RunAllPending();
   fetcher = get_url_fetcher_and_advance_id();
   EXPECT_TRUE(fetcher);
   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);
 
   // Error means we now no longer have a fix.
   provider->GetPosition(&position);
-  EXPECT_FALSE(position.is_valid_latlong());
-  EXPECT_FALSE(position.IsValidFix());
+  EXPECT_FALSE(position.Validate());
 
   // Wifi scan returns to original set: should be serviced from cache.
   wifi_data_provider_->SetData(CreateReferenceWifiScanData(kFirstScanAps));
   main_message_loop_.RunAllPending();
   EXPECT_FALSE(get_url_fetcher_and_advance_id());  // No new request created.
 
   provider->GetPosition(&position);
   EXPECT_EQ(51.0, position.latitude);
   EXPECT_EQ(-0.1, position.longitude);
-  EXPECT_TRUE(position.IsValidFix());
+  EXPECT_TRUE(position.Validate());
 }
 
 TEST_F(GeolocationNetworkProviderTest, NoRequestOnStartupUntilWifiData) {
   MessageLoopQuitListener listener;
   wifi_data_provider_->set_got_data(false);
   scoped_ptr<LocationProviderBase> provider(CreateProvider(true));
   EXPECT_TRUE(provider->StartProvider(false));
   provider->RegisterListener(&listener);
 
   main_message_loop_.RunAllPending();
@@ skipping 77 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