blob: 5eb1af9d34ede9a699fdc386c768015e4d035216 [file] [log] [blame]
// Copyright 2014 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/geolocation_provider_impl.h"
#include <memory>
#include "base/bind.h"
#include "base/bind_helpers.h"
#include "base/location.h"
#include "base/macros.h"
#include "base/memory/ptr_util.h"
#include "base/memory/ref_counted.h"
#include "base/run_loop.h"
#include "base/single_thread_task_runner.h"
#include "base/strings/string16.h"
#include "base/time/time.h"
#include "device/geolocation/access_token_store.h"
#include "device/geolocation/mock_location_arbitrator.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
using testing::MakeMatcher;
using testing::Matcher;
using testing::MatcherInterface;
using testing::MatchResultListener;
namespace device {
class LocationProviderForTestArbitrator : public GeolocationProviderImpl {
public:
LocationProviderForTestArbitrator() : mock_arbitrator_(NULL) {}
~LocationProviderForTestArbitrator() override {}
// Only valid for use on the geolocation thread.
MockLocationArbitrator* mock_arbitrator() const { return mock_arbitrator_; }
protected:
// GeolocationProviderImpl implementation:
std::unique_ptr<LocationArbitrator> CreateArbitrator() override;
private:
// An alias to the arbitrator stored in the super class, where it is owned.
MockLocationArbitrator* mock_arbitrator_;
};
std::unique_ptr<LocationArbitrator>
LocationProviderForTestArbitrator::CreateArbitrator() {
DCHECK(mock_arbitrator_ == NULL);
mock_arbitrator_ = new MockLocationArbitrator;
return base::WrapUnique(mock_arbitrator_);
}
class GeolocationObserver {
public:
virtual ~GeolocationObserver() {}
virtual void OnLocationUpdate(const Geoposition& position) = 0;
};
class MockGeolocationObserver : public GeolocationObserver {
public:
MOCK_METHOD1(OnLocationUpdate, void(const Geoposition& position));
};
class AsyncMockGeolocationObserver : public MockGeolocationObserver {
public:
void OnLocationUpdate(const Geoposition& position) override {
MockGeolocationObserver::OnLocationUpdate(position);
base::MessageLoop::current()->QuitWhenIdle();
}
};
class MockGeolocationCallbackWrapper {
public:
MOCK_METHOD1(Callback, void(const Geoposition& position));
};
class GeopositionEqMatcher : public MatcherInterface<const Geoposition&> {
public:
explicit GeopositionEqMatcher(const Geoposition& expected)
: expected_(expected) {}
bool MatchAndExplain(const Geoposition& actual,
MatchResultListener* listener) const override {
return actual.latitude == expected_.latitude &&
actual.longitude == expected_.longitude &&
actual.altitude == expected_.altitude &&
actual.accuracy == expected_.accuracy &&
actual.altitude_accuracy == expected_.altitude_accuracy &&
actual.heading == expected_.heading &&
actual.speed == expected_.speed &&
actual.timestamp == expected_.timestamp &&
actual.error_code == expected_.error_code &&
actual.error_message == expected_.error_message;
}
void DescribeTo(::std::ostream* os) const override {
*os << "which matches the expected position";
}
void DescribeNegationTo(::std::ostream* os) const override {
*os << "which does not match the expected position";
}
private:
Geoposition expected_;
DISALLOW_COPY_AND_ASSIGN(GeopositionEqMatcher);
};
Matcher<const Geoposition&> GeopositionEq(const Geoposition& expected) {
return MakeMatcher(new GeopositionEqMatcher(expected));
}
class GeolocationProviderTest : public testing::Test {
protected:
GeolocationProviderTest()
: message_loop_(), provider_(new LocationProviderForTestArbitrator) {}
~GeolocationProviderTest() override {}
LocationProviderForTestArbitrator* provider() { return provider_.get(); }
// Called on test thread.
bool ProvidersStarted();
void SendMockLocation(const Geoposition& position);
private:
// Called on provider thread.
void GetProvidersStarted(bool* started);
base::MessageLoopForUI message_loop_;
std::unique_ptr<LocationProviderForTestArbitrator> provider_;
};
bool GeolocationProviderTest::ProvidersStarted() {
DCHECK(provider_->IsRunning());
DCHECK(base::MessageLoop::current() == &message_loop_);
bool started;
provider_->task_runner()->PostTaskAndReply(
FROM_HERE, base::Bind(&GeolocationProviderTest::GetProvidersStarted,
base::Unretained(this), &started),
base::MessageLoop::QuitWhenIdleClosure());
base::RunLoop().Run();
return started;
}
void GeolocationProviderTest::GetProvidersStarted(bool* started) {
DCHECK(provider_->task_runner()->BelongsToCurrentThread());
*started = provider_->mock_arbitrator()->providers_started();
}
void GeolocationProviderTest::SendMockLocation(const Geoposition& position) {
DCHECK(provider_->IsRunning());
DCHECK(base::MessageLoop::current() == &message_loop_);
provider_->task_runner()->PostTask(
FROM_HERE, base::Bind(&GeolocationProviderImpl::OnLocationUpdate,
base::Unretained(provider_.get()), position));
}
// Regression test for http://crbug.com/59377
TEST_F(GeolocationProviderTest, OnPermissionGrantedWithoutObservers) {
EXPECT_FALSE(provider()->user_did_opt_into_location_services_for_testing());
provider()->UserDidOptIntoLocationServices();
EXPECT_TRUE(provider()->user_did_opt_into_location_services_for_testing());
}
void DummyFunction(const Geoposition& position) {}
TEST_F(GeolocationProviderTest, StartStop) {
EXPECT_FALSE(provider()->IsRunning());
GeolocationProviderImpl::LocationUpdateCallback callback =
base::Bind(&DummyFunction);
std::unique_ptr<GeolocationProvider::Subscription> subscription =
provider()->AddLocationUpdateCallback(callback, false);
EXPECT_TRUE(provider()->IsRunning());
EXPECT_TRUE(ProvidersStarted());
subscription.reset();
EXPECT_FALSE(ProvidersStarted());
EXPECT_TRUE(provider()->IsRunning());
}
TEST_F(GeolocationProviderTest, StalePositionNotSent) {
Geoposition first_position;
first_position.latitude = 12;
first_position.longitude = 34;
first_position.accuracy = 56;
first_position.timestamp = base::Time::Now();
AsyncMockGeolocationObserver first_observer;
GeolocationProviderImpl::LocationUpdateCallback first_callback =
base::Bind(&MockGeolocationObserver::OnLocationUpdate,
base::Unretained(&first_observer));
EXPECT_CALL(first_observer, OnLocationUpdate(GeopositionEq(first_position)));
std::unique_ptr<GeolocationProvider::Subscription> subscription =
provider()->AddLocationUpdateCallback(first_callback, false);
SendMockLocation(first_position);
base::RunLoop().Run();
subscription.reset();
Geoposition second_position;
second_position.latitude = 13;
second_position.longitude = 34;
second_position.accuracy = 56;
second_position.timestamp = base::Time::Now();
AsyncMockGeolocationObserver second_observer;
// After adding a second observer, check that no unexpected position update
// is sent.
EXPECT_CALL(second_observer, OnLocationUpdate(testing::_)).Times(0);
GeolocationProviderImpl::LocationUpdateCallback second_callback =
base::Bind(&MockGeolocationObserver::OnLocationUpdate,
base::Unretained(&second_observer));
std::unique_ptr<GeolocationProvider::Subscription> subscription2 =
provider()->AddLocationUpdateCallback(second_callback, false);
base::RunLoop().RunUntilIdle();
// The second observer should receive the new position now.
EXPECT_CALL(second_observer,
OnLocationUpdate(GeopositionEq(second_position)));
SendMockLocation(second_position);
base::RunLoop().Run();
subscription2.reset();
EXPECT_FALSE(ProvidersStarted());
}
TEST_F(GeolocationProviderTest, OverrideLocationForTesting) {
Geoposition position;
position.error_code = Geoposition::ERROR_CODE_POSITION_UNAVAILABLE;
provider()->OverrideLocationForTesting(position);
// Adding an observer when the location is overridden should synchronously
// update the observer with our overridden position.
MockGeolocationObserver mock_observer;
EXPECT_CALL(mock_observer, OnLocationUpdate(GeopositionEq(position)));
GeolocationProviderImpl::LocationUpdateCallback callback =
base::Bind(&MockGeolocationObserver::OnLocationUpdate,
base::Unretained(&mock_observer));
std::unique_ptr<GeolocationProvider::Subscription> subscription =
provider()->AddLocationUpdateCallback(callback, false);
subscription.reset();
// Wait for the providers to be stopped now that all clients are gone.
EXPECT_FALSE(ProvidersStarted());
}
} // namespace device