Make the Geoposition helper class public

content/browser/geolocation/location_arbitrator_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/memory/scoped_ptr.h"
 #include "content/browser/geolocation/arbitrator_dependency_factory.h"
 #include "content/browser/geolocation/fake_access_token_store.h"
 #include "content/browser/geolocation/geolocation_observer.h"
 #include "content/browser/geolocation/location_arbitrator.h"
 #include "content/browser/geolocation/location_provider.h"
 #include "content/browser/geolocation/mock_location_provider.h"
-#include "content/common/geoposition.h"
+#include "content/public/common/geoposition.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using content::AccessTokenStore;
 using content::FakeAccessTokenStore;
+using content::Geoposition;
 using ::testing::NiceMock;
 
 namespace {
 
 class MockLocationObserver : public GeolocationObserver {
  public:
   void InvalidateLastPosition() {
     last_position_.latitude = 100;
     last_position_.error_code = Geoposition::ERROR_CODE_NONE;
-    ASSERT_FALSE(last_position_.IsInitialized());
+    ASSERT_FALSE(last_position_.Validate());
   }
   // Delegate
   virtual void OnLocationUpdate(const Geoposition& position) {
     last_position_ = position;
   }
 
   Geoposition last_position_;
 };
 
 double g_fake_time_now_secs = 1;
 
 base::Time GetTimeNowForTest() {
   return base::Time::FromDoubleT(g_fake_time_now_secs);
 }
 
 void AdvanceTimeNow(const base::TimeDelta& delta) {
   g_fake_time_now_secs += delta.InSecondsF();
 }
 
 void SetPositionFix(MockLocationProvider* provider,
                     double latitude,
                     double longitude,
                     double accuracy) {
   Geoposition position;
   position.error_code = Geoposition::ERROR_CODE_NONE;
   position.latitude = latitude;
   position.longitude = longitude;
   position.accuracy = accuracy;
   position.timestamp = GetTimeNowForTest();
-  ASSERT_TRUE(position.IsInitialized());
-  ASSERT_TRUE(position.IsValidFix());
+  ASSERT_TRUE(position.Validate());
   provider->HandlePositionChanged(position);
 }
 
 void SetReferencePosition(MockLocationProvider* provider) {
   SetPositionFix(provider, 51.0, -0.1, 400);
 }
 
 class MockDependencyFactory : public GeolocationArbitratorDependencyFactory {
  public:
   explicit MockDependencyFactory(AccessTokenStore* access_token_store)
@@ skipping 50 matching lines @@
   // testing::Test
   virtual void TearDown() {
     GeolocationArbitrator::SetDependencyFactoryForTest(NULL);
     dependency_factory_ = NULL;
   }
 
   void CheckLastPositionInfo(double latitude,
                              double longitude,
                              double accuracy) {
     Geoposition geoposition = observer_->last_position_;
-    EXPECT_TRUE(geoposition.IsValidFix());
+    EXPECT_TRUE(geoposition.Validate());
     EXPECT_DOUBLE_EQ(latitude, geoposition.latitude);
     EXPECT_DOUBLE_EQ(longitude, geoposition.longitude);
     EXPECT_DOUBLE_EQ(accuracy, geoposition.accuracy);
   }
 
   base::TimeDelta SwitchOnFreshnessCliff() {
     // Add 1, to ensure it meets any greater-than test.
     return base::TimeDelta::FromMilliseconds(
         GeolocationArbitrator::kFixStaleTimeoutMilliseconds + 1);
   }
@@ skipping 40 matching lines @@
 
   EXPECT_TRUE(access_token_store_->access_token_set_.empty());
   EXPECT_TRUE(access_token_store_->access_token_set_.empty());
 
   access_token_store_->NotifyDelegateTokensLoaded();
   ASSERT_TRUE(cell());
   EXPECT_TRUE(gps());
   EXPECT_TRUE(cell()->has_listeners());
   EXPECT_EQ(MockLocationProvider::LOW_ACCURACY, cell()->state_);
   EXPECT_EQ(MockLocationProvider::LOW_ACCURACY, gps()->state_);
-  EXPECT_FALSE(observer_->last_position_.IsInitialized());
+  EXPECT_FALSE(observer_->last_position_.Validate());
+  EXPECT_EQ(content::Geoposition::ERROR_CODE_NONE,
+            observer_->last_position_.error_code);
 
   SetReferencePosition(cell());
 
-  EXPECT_TRUE(observer_->last_position_.IsInitialized());
+  EXPECT_TRUE(observer_->last_position_.Validate() ||
+              observer_->last_position_.error_code !=
+                  content::Geoposition::ERROR_CODE_NONE);
   EXPECT_EQ(cell()->position_.latitude,
             observer_->last_position_.latitude);
 
   EXPECT_FALSE(cell()->is_permission_granted_);
   EXPECT_FALSE(arbitrator_->HasPermissionBeenGranted());
   arbitrator_->OnPermissionGranted();
   EXPECT_TRUE(arbitrator_->HasPermissionBeenGranted());
   EXPECT_TRUE(cell()->is_permission_granted_);
 }
 
@@ skipping 14 matching lines @@
 
 TEST_F(GeolocationLocationArbitratorTest, Arbitration) {
   arbitrator_->StartProviders(GeolocationObserverOptions(false));
   access_token_store_->NotifyDelegateTokensLoaded();
   ASSERT_TRUE(cell());
   ASSERT_TRUE(gps());
 
   SetPositionFix(cell(), 1, 2, 150);
 
   // First position available
-  EXPECT_TRUE(observer_->last_position_.IsValidFix());
+  EXPECT_TRUE(observer_->last_position_.Validate());
   CheckLastPositionInfo(1, 2, 150);
 
   SetPositionFix(gps(), 3, 4, 50);
 
   // More accurate fix available
   CheckLastPositionInfo(3, 4, 50);
 
   SetPositionFix(cell(), 5, 6, 150);
 
   // New fix is available but it's less accurate, older fix should be kept.
@@ skipping 47 matching lines @@
   CheckLastPositionInfo(3.5657104, 139.690341, 300);
 
   // 2 minutes later
   AdvanceTimeNow(base::TimeDelta::FromMinutes(2));
   // Arrive in station. Cell moves but GPS is stale. Switch to fresher cell.
   SetPositionFix(cell(), 3.5658700, 139.069979, 1000);
   CheckLastPositionInfo(3.5658700, 139.069979, 1000);
 }
 
 }  // namespace