Makes use of EngineGeolocationFeature weak_ptr threadsafe.

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
index 8258c99db45c7f4f78fb8607a00186b15d8bcbd7..8502b596bf6ec1cf0cf85accb54c478174188cb5 100644
--- a/blimp/engine/feature/geolocation/blimp_location_provider_unittest.cc
+++ b/blimp/engine/feature/geolocation/blimp_location_provider_unittest.cc
@@ -9,12 +9,14 @@
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
+#include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
+#include "base/threading/thread_task_runner_handle.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::_;
-using testing::SaveArg;
 
 namespace blimp {
 namespace engine {
@@ -25,16 +27,23 @@ class BlimpLocationProviderTest : public testing::Test {
       : mock_callback_(base::Bind(&BlimpLocationProviderTest::OnLocationUpdate,
                                   base::Unretained(this))),
         delegate_(base::WrapUnique(new MockBlimpLocationProviderDelegate)),
-        location_provider_(new BlimpLocationProvider(delegate_->GetWeakPtr())) {
-  }
+        location_provider_(base::MakeUnique<BlimpLocationProvider>(
+            delegate_->GetWeakPtr(),
+            base::ThreadTaskRunnerHandle::Get())) {}
 
   void SetUp() override {}
 
+  void TearDown() override {
+    location_provider_.reset();
+    base::RunLoop().RunUntilIdle();
+  }
+
   MOCK_METHOD2(OnLocationUpdate,
                void(const device::LocationProvider* provider,
                     const device::Geoposition& geoposition));
 
  protected:
+  const base::MessageLoop loop_;
   device::LocationProvider::LocationProviderUpdateCallback mock_callback_;
   std::unique_ptr<MockBlimpLocationProviderDelegate> delegate_;
   std::unique_ptr<BlimpLocationProvider> location_provider_;
@@ -61,14 +70,6 @@ TEST_F(BlimpLocationProviderTest, StartProviderRunsCorrectly) {
   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_,
@@ -82,17 +83,6 @@ TEST_F(BlimpLocationProviderTest, StopProviderRunsCorrectly) {
   location_provider_->StopProvider();
 }
 
-TEST_F(BlimpLocationProviderTest, StopProviderHandlesNullDelegate) {
-  EXPECT_CALL(
-      *delegate_,
-      RequestAccuracy(GeolocationSetInterestLevelMessage::HIGH_ACCURACY))
-      .Times(1);
-
-  location_provider_->StartProvider(true);
-  delegate_.reset();
-  location_provider_->StopProvider();
-}
-
 TEST_F(BlimpLocationProviderTest, LocationProviderDeleted) {
   EXPECT_CALL(
       *delegate_,
@@ -108,32 +98,22 @@ TEST_F(BlimpLocationProviderTest, LocationProviderDeleted) {
 
 TEST_F(BlimpLocationProviderTest, OnPermissionGranted) {
   EXPECT_CALL(*delegate_, OnPermissionGranted()).Times(1);
+  EXPECT_CALL(
+      *delegate_,
+      RequestAccuracy(GeolocationSetInterestLevelMessage::HIGH_ACCURACY))
+      .Times(1);
+  EXPECT_CALL(*delegate_,
+              RequestAccuracy(GeolocationSetInterestLevelMessage::NO_INTEREST))
+      .Times(1);
 
   location_provider_->StartProvider(true);
   location_provider_->OnPermissionGranted();
 }
 
-TEST_F(BlimpLocationProviderTest, OnPermissionGrantedHandlesNullDelegate) {

[Wez, 2016/09/13 20:19:07]

We still want these tests, don't we, even if we are using PostTask internally?

[CJ, 2016/09/13 23:34:03]

Done.

-  EXPECT_CALL(*delegate_, OnPermissionGranted()).Times(0);
-
-  location_provider_->StartProvider(true);
-  delegate_.reset();
-  location_provider_->OnPermissionGranted();
-}
-
 TEST_F(BlimpLocationProviderTest, SetUpdateCallbackPropagatesCallback) {
   base::Callback<void(const device::Geoposition&)> callback;
-  EXPECT_CALL(*delegate_, SetUpdateCallback(_)).WillOnce(SaveArg<0>(&callback));
-  EXPECT_CALL(*this, OnLocationUpdate(location_provider_.get(), _)).Times(1);
-
-  location_provider_->SetUpdateCallback(mock_callback_);
-  callback.Run(device::Geoposition());
-}
-
-TEST_F(BlimpLocationProviderTest, SetUpdateCallbackHandlesNullDelegate) {
-  EXPECT_CALL(*delegate_, SetUpdateCallback(_)).Times(0);
+  EXPECT_CALL(*delegate_, SetUpdateCallback(_));
 
-  delegate_.reset();
   location_provider_->SetUpdateCallback(mock_callback_);
 }