content/browser/geolocation/geolocation_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/bind.h"
   6 #include "base/bind_helpers.h"
   7 #include "base/memory/ref_counted.h"
   8 #include "base/memory/scoped_ptr.h"
   9 #include "base/message_loop/message_loop.h"
  10 #include "base/strings/string16.h"
  11 #include "base/time/time.h"
  12 #include "content/browser/geolocation/geolocation_provider_impl.h"
  13 #include "content/browser/geolocation/mock_location_arbitrator.h"
  14 #include "content/public/browser/access_token_store.h"
  15 #include "content/public/browser/browser_thread.h"
  16 #include "content/public/test/test_browser_thread.h"
  17 #include "testing/gmock/include/gmock/gmock.h"
  18 #include "testing/gtest/include/gtest/gtest.h"
  19
  20 using testing::MakeMatcher;
  21 using testing::Matcher;
  22 using testing::MatcherInterface;
  23 using testing::MatchResultListener;
  24
  25 namespace content {
  26
  27 class LocationProviderForTestArbitrator : public GeolocationProviderImpl {
  28  public:
  29   LocationProviderForTestArbitrator() : mock_arbitrator_(NULL) {}
  30   virtual ~LocationProviderForTestArbitrator() {}
  31
  32   // Only valid for use on the geolocation thread.
  33   MockLocationArbitrator* mock_arbitrator() const {
  34     return mock_arbitrator_;
  35   }
  36
  37  protected:
  38   // GeolocationProviderImpl implementation:
  39   virtual LocationArbitrator* CreateArbitrator() OVERRIDE;
  40
  41  private:
  42   MockLocationArbitrator* mock_arbitrator_;
  43 };
  44
  45 LocationArbitrator* LocationProviderForTestArbitrator::CreateArbitrator() {
  46   DCHECK(mock_arbitrator_ == NULL);
  47   mock_arbitrator_ = new MockLocationArbitrator;
  48   return mock_arbitrator_;
  49 }
  50
  51 class GeolocationObserver {
  52  public:
  53   virtual ~GeolocationObserver() {}
  54   virtual void OnLocationUpdate(const Geoposition& position) = 0;
  55 };
  56
  57 class MockGeolocationObserver : public GeolocationObserver {
  58  public:
  59   MOCK_METHOD1(OnLocationUpdate, void(const Geoposition& position));
  60 };
  61
  62 class AsyncMockGeolocationObserver : public MockGeolocationObserver {
  63  public:
  64   virtual void OnLocationUpdate(const Geoposition& position) OVERRIDE {
  65     MockGeolocationObserver::OnLocationUpdate(position);
  66     base::MessageLoop::current()->Quit();
  67   }
  68 };
  69
  70 class MockGeolocationCallbackWrapper {
  71  public:
  72   MOCK_METHOD1(Callback, void(const Geoposition& position));
  73 };
  74
  75 class GeopositionEqMatcher
  76     : public MatcherInterface<const Geoposition&> {
  77  public:
  78   explicit GeopositionEqMatcher(const Geoposition& expected)
  79       : expected_(expected) {}
  80
  81   virtual bool MatchAndExplain(const Geoposition& actual,
  82                                MatchResultListener* listener) const OVERRIDE {
  83     return actual.latitude == expected_.latitude &&
  84            actual.longitude == expected_.longitude &&
  85            actual.altitude == expected_.altitude &&
  86            actual.accuracy == expected_.accuracy &&
  87            actual.altitude_accuracy == expected_.altitude_accuracy &&
  88            actual.heading == expected_.heading &&
  89            actual.speed == expected_.speed &&
  90            actual.timestamp == expected_.timestamp &&
  91            actual.error_code == expected_.error_code &&
  92            actual.error_message == expected_.error_message;
  93   }
  94
  95   virtual void DescribeTo(::std::ostream* os) const OVERRIDE {
  96     *os << "which matches the expected position";
  97   }
  98
  99   virtual void DescribeNegationTo(::std::ostream* os) const OVERRIDE {
 100     *os << "which does not match the expected position";
 101   }
 102
 103  private:
 104   Geoposition expected_;
 105
 106   DISALLOW_COPY_AND_ASSIGN(GeopositionEqMatcher);
 107 };
 108
 109 Matcher<const Geoposition&> GeopositionEq(const Geoposition& expected) {
 110   return MakeMatcher(new GeopositionEqMatcher(expected));
 111 }
 112
 113 class GeolocationProviderTest : public testing::Test {
 114  protected:
 115   GeolocationProviderTest()
 116       : message_loop_(),
 117         io_thread_(BrowserThread::IO, &message_loop_),
 118         provider_(new LocationProviderForTestArbitrator) {
 119   }
 120
 121   virtual ~GeolocationProviderTest() {}
 122
 123   LocationProviderForTestArbitrator* provider() { return provider_.get(); }
 124
 125   // Called on test thread.
 126   bool ProvidersStarted();
 127   void SendMockLocation(const Geoposition& position);
 128
 129  private:
 130   // Called on provider thread.
 131   void GetProvidersStarted(bool* started);
 132
 133   base::MessageLoop message_loop_;
 134   TestBrowserThread io_thread_;
 135   scoped_ptr<LocationProviderForTestArbitrator> provider_;
 136 };
 137
 138
 139 bool GeolocationProviderTest::ProvidersStarted() {
 140   DCHECK(provider_->IsRunning());
 141   DCHECK(base::MessageLoop::current() == &message_loop_);
 142   bool started;
 143   provider_->message_loop_proxy()->PostTaskAndReply(
 144       FROM_HERE,
 145       base::Bind(&GeolocationProviderTest::GetProvidersStarted,
 146                  base::Unretained(this),
 147                  &started),
 148       base::MessageLoop::QuitClosure());
 149   message_loop_.Run();
 150   return started;
 151 }
 152
 153 void GeolocationProviderTest::GetProvidersStarted(bool* started) {
 154   DCHECK(base::MessageLoop::current() == provider_->message_loop());
 155   *started = provider_->mock_arbitrator()->providers_started();
 156 }
 157
 158 void GeolocationProviderTest::SendMockLocation(const Geoposition& position) {
 159   DCHECK(provider_->IsRunning());
 160   DCHECK(base::MessageLoop::current() == &message_loop_);
 161   provider_->message_loop()
 162       ->PostTask(FROM_HERE,
 163                  base::Bind(&GeolocationProviderImpl::OnLocationUpdate,
 164                             base::Unretained(provider_.get()),
 165                             position));
 166 }
 167
 168 // Regression test for http://crbug.com/59377
 169 TEST_F(GeolocationProviderTest, OnPermissionGrantedWithoutObservers) {
 170   EXPECT_FALSE(provider()->LocationServicesOptedIn());
 171   provider()->UserDidOptIntoLocationServices();
 172   EXPECT_TRUE(provider()->LocationServicesOptedIn());
 173 }
 174
 175 TEST_F(GeolocationProviderTest, StartStop) {
 176   EXPECT_FALSE(provider()->IsRunning());
 177   GeolocationProviderImpl::LocationUpdateCallback null_callback;
 178   provider()->AddLocationUpdateCallback(null_callback, false);
 179   EXPECT_TRUE(provider()->IsRunning());
 180   EXPECT_TRUE(ProvidersStarted());
 181
 182   provider()->RemoveLocationUpdateCallback(null_callback);
 183   EXPECT_FALSE(ProvidersStarted());
 184   EXPECT_TRUE(provider()->IsRunning());
 185 }
 186
 187 TEST_F(GeolocationProviderTest, StalePositionNotSent) {
 188   Geoposition first_position;
 189   first_position.latitude = 12;
 190   first_position.longitude = 34;
 191   first_position.accuracy = 56;
 192   first_position.timestamp = base::Time::Now();
 193
 194   AsyncMockGeolocationObserver first_observer;
 195   GeolocationProviderImpl::LocationUpdateCallback first_callback = base::Bind(
 196       &MockGeolocationObserver::OnLocationUpdate,
 197       base::Unretained(&first_observer));
 198   EXPECT_CALL(first_observer, OnLocationUpdate(GeopositionEq(first_position)));
 199   provider()->AddLocationUpdateCallback(first_callback, false);
 200   SendMockLocation(first_position);
 201   base::MessageLoop::current()->Run();
 202
 203   provider()->RemoveLocationUpdateCallback(first_callback);
 204
 205   Geoposition second_position;
 206   second_position.latitude = 13;
 207   second_position.longitude = 34;
 208   second_position.accuracy = 56;
 209   second_position.timestamp = base::Time::Now();
 210
 211   AsyncMockGeolocationObserver second_observer;
 212
 213   // After adding a second observer, check that no unexpected position update
 214   // is sent.
 215   EXPECT_CALL(second_observer, OnLocationUpdate(testing::_)).Times(0);
 216   GeolocationProviderImpl::LocationUpdateCallback second_callback = base::Bind(
 217       &MockGeolocationObserver::OnLocationUpdate,
 218       base::Unretained(&second_observer));
 219   provider()->AddLocationUpdateCallback(second_callback, false);
 220   base::MessageLoop::current()->RunUntilIdle();
 221
 222   // The second observer should receive the new position now.
 223   EXPECT_CALL(second_observer,
 224               OnLocationUpdate(GeopositionEq(second_position)));
 225   SendMockLocation(second_position);
 226   base::MessageLoop::current()->Run();
 227
 228   provider()->RemoveLocationUpdateCallback(second_callback);
 229   EXPECT_FALSE(ProvidersStarted());
 230 }
 231
 232 TEST_F(GeolocationProviderTest, OverrideLocationForTesting) {
 233   Geoposition position;
 234   position.error_code = Geoposition::ERROR_CODE_POSITION_UNAVAILABLE;
 235   provider()->OverrideLocationForTesting(position);
 236   // Adding an observer when the location is overridden should synchronously
 237   // update the observer with our overridden position.
 238   MockGeolocationObserver mock_observer;
 239   EXPECT_CALL(mock_observer, OnLocationUpdate(GeopositionEq(position)));
 240   GeolocationProviderImpl::LocationUpdateCallback callback = base::Bind(
 241       &MockGeolocationObserver::OnLocationUpdate,
 242       base::Unretained(&mock_observer));
 243   provider()->AddLocationUpdateCallback(callback, false);
 244   provider()->RemoveLocationUpdateCallback(callback);
 245   // Wait for the providers to be stopped now that all clients are gone.
 246   EXPECT_FALSE(ProvidersStarted());
 247 }
 248
 249 }  // namespace content