Adds EngineGeolocationFeature for Blimp Geolocation project.

blimp/engine/feature/geolocation/blimp_location_provider_unittest.cc

+// Copyright 2016 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 "blimp/engine/feature/geolocation/blimp_location_provider.h"
+
+#include "base/bind.h"
+#include "base/memory/ptr_util.h"
+#include "blimp/engine/feature/geolocation/mock_blimp_location_provider_delegate.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using testing::_;
+
+namespace blimp {
+namespace engine {
+
+class BlimpLocationProviderTest : public testing::Test {
+ public:
+  BlimpLocationProviderTest()
+      : mock_callback_(base::Bind(&BlimpLocationProviderTest::OnLocationUpdate,
+                                  base::Unretained(this))),
+        delegate_(base::WrapUnique(new MockBlimpLocationProviderDelegate)),
+        location_provider_(
+            new BlimpLocationProvider(delegate_->weak_factory_.GetWeakPtr())) {}
+
+  void SetUp() override {}
+
+  void OnLocationUpdate(const content::LocationProvider* provider,
+                        const content::Geoposition& geoposition) {}
+
+ protected:
+  content::LocationProvider::LocationProviderUpdateCallback mock_callback_;
+  std::unique_ptr<MockBlimpLocationProviderDelegate> delegate_;
+  std::unique_ptr<BlimpLocationProvider> location_provider_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(BlimpLocationProviderTest);
+};
+
+TEST_F(BlimpLocationProviderTest, StartProviderRunsCorrectly) {
+  EXPECT_CALL(
+      *delegate_,
+      RequestAccuracy(GeolocationSetInterestLevelMessage::HIGH_ACCURACY))
+      .Times(1);
+  EXPECT_CALL(*delegate_,
+              RequestAccuracy(GeolocationSetInterestLevelMessage::LOW_ACCURACY))
+      .Times(1);
+
+  EXPECT_TRUE(location_provider_->StartProvider(true));
+  EXPECT_TRUE(location_provider_->StartProvider(false));
+}
+
+TEST_F(BlimpLocationProviderTest, StartProviderHandlesNullDelegate) {
+  EXPECT_CALL(*delegate_, RequestAccuracy(_)).Times(0);
+  delegate_.reset();
+  EXPECT_FALSE(location_provider_->StartProvider(true));
+  EXPECT_FALSE(location_provider_->StartProvider(false));
+}
+
+TEST_F(BlimpLocationProviderTest, StopProviderRunsCorrectly) {
+  EXPECT_CALL(*delegate_,
+              RequestAccuracy(GeolocationSetInterestLevelMessage::NO_INTEREST))
+      .Times(1);
+
+  location_provider_->StopProvider();

[Wez, 2016/07/18 23:55:21]

nit: Add a test case for if the caller deletes the location provider without
stopping it first?

[CJ, 2016/07/19 20:04:17]

Done.

+}
+
+TEST_F(BlimpLocationProviderTest, StopProviderHandlesNullDelegate) {
+  EXPECT_CALL(*delegate_, RequestAccuracy(_)).Times(0);
+  delegate_.reset();
+  location_provider_->StopProvider();
+}
+
+TEST_F(BlimpLocationProviderTest, RequestRefreshRunsCorrectly) {
+  EXPECT_CALL(*delegate_, RequestRefresh()).Times(1);
+
+  location_provider_->RequestRefresh();
+}
+
+TEST_F(BlimpLocationProviderTest, RequestRefreshHandlesNullDelegate) {
+  EXPECT_CALL(*delegate_, RequestRefresh()).Times(0);
+  delegate_.reset();
+  location_provider_->RequestRefresh();
+}
+
+TEST_F(BlimpLocationProviderTest, OnPermissionGrantedCallsRefresh) {
+  EXPECT_CALL(*delegate_, RequestRefresh()).Times(1);
+
+  location_provider_->OnPermissionGranted();
+}
+
+TEST_F(BlimpLocationProviderTest, OnPermissionGrantedHandlesNullDelegate) {
+  EXPECT_CALL(*delegate_, RequestRefresh()).Times(0);
+  delegate_.reset();
+  location_provider_->OnPermissionGranted();
+}
+
+TEST_F(BlimpLocationProviderTest, SetUpdateCallbackPropagatesCallback) {
+  EXPECT_CALL(*delegate_, SetUpdateCallback(_)).Times(1);

[Wez, 2016/07/18 23:55:21]

I'd suggest having this test actually store the callback (you can find examples
of gmock SaveArg something-or-other) so that you can verify that it gets
correctly passed-through to the delegate.

Testing that it's correctly-passed is a little tricky since it'll be a different
callback, since the interfaces differ, but you can just call the callback that
the delegate receives, and verify that the mock gets called with the right
values, say.

[CJ, 2016/07/19 20:04:17]

Done.

+  location_provider_->SetUpdateCallback(mock_callback_);
+}
+
+TEST_F(BlimpLocationProviderTest, SetUpdateCallbackHandlesNullDelegate) {

[Wez, 2016/07/18 23:55:21]

These test-cases look great. :)  You could reasonably have had a single
NullDelegate test and made all the calls in that one place, I think, but this is
also fine.

[CJ, 2016/07/19 20:04:17]

Acknowledged.

+  EXPECT_CALL(*delegate_, SetUpdateCallback(_)).Times(0);
+  delegate_.reset();
+  location_provider_->SetUpdateCallback(mock_callback_);
+}
+
+}  // namespace engine
+}  // namespace blimp