Adds EngineGeolocationFeature for Blimp Geolocation project.

blimp/engine/feature/geolocation/blimp_location_provider_unittest.cc

Index: blimp/engine/feature/geolocation/blimp_location_provider_unittest.cc
diff --git a/blimp/engine/feature/geolocation/blimp_location_provider_unittest.cc b/blimp/engine/feature/geolocation/blimp_location_provider_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..6b9afb04c713391a47de33fe4122981b05899bd7
--- /dev/null
+++ b/blimp/engine/feature/geolocation/blimp_location_provider_unittest.cc
@@ -0,0 +1,111 @@
+// 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())) {}

[Kevin M, 2016/07/19 16:01:42]

Oh - I see what's going on now.

Move the weak_factory_ out of the mock object and into
BlimpLocationProviderTest. Then delete the weak_factory_ object in your test.

[CJ, 2016/07/19 20:35:58]

Is this referencing testing to see if BlimpLocationProvider can handle a null
delegate?
I thought that weak_factory_ objects reside in the class they are making weak
pointers to?

[Kevin M, 2016/07/21 17:37:05]

That is generally the case for production objects, but in test code, all that
really matters is that the factory is deleted, not the object associated with
the factory. So, we can pull out the factory into the test code, and simply
delete it as necessary, so there's no need to add WeakPtr logic to the mock
class.

What's there is fine, though.

[CJ, 2016/07/21 22:04:45]

Is it more acceptable or beneficial to do it the other way though?

+
+  void SetUp() override {}
+
+  void OnLocationUpdate(const content::LocationProvider* provider,

[Kevin M, 2016/07/19 16:01:41]

I recommend making this a MOCK_METHOD2 and setting expectations for it.

[CJ, 2016/07/19 20:35:58]

Done.

+                        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();
+}
+
+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);
+  location_provider_->SetUpdateCallback(mock_callback_);
+}
+
+TEST_F(BlimpLocationProviderTest, SetUpdateCallbackHandlesNullDelegate) {
+  EXPECT_CALL(*delegate_, SetUpdateCallback(_)).Times(0);
+  delegate_.reset();
+  location_provider_->SetUpdateCallback(mock_callback_);
+}
+
+}  // namespace engine
+}  // namespace blimp