Makes use of EngineGeolocationFeature weak_ptr threadsafe.

blimp/engine/feature/geolocation/blimp_location_provider.cc

 // Copyright (c) 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/bind_helpers.h"
 #include "base/memory/weak_ptr.h"
+#include "base/task_runner.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "device/geolocation/geoposition.h"
 
 namespace blimp {
 namespace engine {
 
 BlimpLocationProvider::BlimpLocationProvider(
-    base::WeakPtr<BlimpLocationProvider::Delegate> delegate)
-    : delegate_(delegate), is_started_(false) {}
+    base::WeakPtr<BlimpLocationProvider::Delegate> delegate,
+    scoped_refptr<base::SingleThreadTaskRunner> delegate_task_runner)
+    : delegate_(delegate),
+      delegate_task_runner_(delegate_task_runner),
+      is_started_(false) {}
 
 BlimpLocationProvider::~BlimpLocationProvider() {
   if (is_started_) {
     StopProvider();
   }
 }
 
 bool BlimpLocationProvider::StartProvider(bool high_accuracy) {
-  if (delegate_) {
-    if (high_accuracy) {
-      delegate_->RequestAccuracy(
-          GeolocationSetInterestLevelMessage::HIGH_ACCURACY);
-    } else {
-      delegate_->RequestAccuracy(
-          GeolocationSetInterestLevelMessage::LOW_ACCURACY);
-    }
-    is_started_ = true;
+  is_started_ = true;
+  if (high_accuracy) {
+    delegate_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&BlimpLocationProvider::Delegate::RequestAccuracy, delegate_,
+                   GeolocationSetInterestLevelMessage::HIGH_ACCURACY));
+  } else {
+    delegate_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&BlimpLocationProvider::Delegate::RequestAccuracy, delegate_,
+                   GeolocationSetInterestLevelMessage::LOW_ACCURACY));
   }
   return is_started_;
 }
 
 void BlimpLocationProvider::StopProvider() {
   DCHECK(is_started_);
-  if (delegate_) {
-    delegate_->RequestAccuracy(GeolocationSetInterestLevelMessage::NO_INTEREST);
-    is_started_ = false;
-  }
+  delegate_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&BlimpLocationProvider::Delegate::RequestAccuracy, delegate_,
+                 GeolocationSetInterestLevelMessage::NO_INTEREST));
+  is_started_ = false;
 }
 
 const device::Geoposition& BlimpLocationProvider::GetPosition() {
   return cached_position_;
 }
 
 void BlimpLocationProvider::OnPermissionGranted() {
   DCHECK(is_started_);
-  if (delegate_) {
-    delegate_->OnPermissionGranted();
-  }
+  delegate_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&BlimpLocationProvider::Delegate::OnPermissionGranted,
+                 delegate_));
 }
 
 void BlimpLocationProvider::SetUpdateCallback(
     const LocationProviderUpdateCallback& callback) {
-  if (delegate_) {
-    delegate_->SetUpdateCallback(base::Bind(callback, base::Unretained(this)));
-  }
+  delegate_task_runner_->PostTask(

[Kevin M, 2016/09/09 17:07:04]

You can actually bind a callback which manages its own threadhopping!

base::Bind(&base::TaskRunner::PostTask base::ThreadTaskRunnerHandle::Get(),
FROM_HERE, callback);

Now you don't need to pass in a task runner to the delegate. Shiny.

[CJ, 2016/09/09 19:52:41]

Done.

+      FROM_HERE, base::Bind(&BlimpLocationProvider::Delegate::SetUpdateCallback,
+                            delegate_, base::ThreadTaskRunnerHandle::Get(),
+                            base::Bind(callback, base::Unretained(this))));
 }
 
 }  // namespace engine
 }  // namespace blimp