Makes use of EngineGeolocationFeature weak_ptr threadsafe.

blimp/engine/feature/geolocation/engine_geolocation_feature.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/engine_geolocation_feature.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "blimp/common/create_blimp_message.h"
 #include "blimp/common/proto/blimp_message.pb.h"
 #include "blimp/common/proto/geolocation.pb.h"
 #include "device/geolocation/geolocation_delegate.h"
 #include "device/geolocation/location_provider.h"
 #include "device/geolocation/geoposition.h"
 #include "net/base/net_errors.h"
 
 namespace blimp {
 namespace engine {
 namespace {
 
 class BlimpGeolocationDelegate : public device::GeolocationDelegate {
  public:
   explicit BlimpGeolocationDelegate(
       base::WeakPtr<BlimpLocationProvider::Delegate> feature_delegate) {
     feature_delegate_ = feature_delegate;
+    feature_task_runner_ = base::ThreadTaskRunnerHandle::Get();
   }
 
   bool UseNetworkLocationProviders() final { return false; }
 
   std::unique_ptr<device::LocationProvider> OverrideSystemLocationProvider()
       final {
-    return base::MakeUnique<BlimpLocationProvider>(feature_delegate_);
+    return base::MakeUnique<BlimpLocationProvider>(feature_delegate_,
+                                                   feature_task_runner_);
   }
 
  private:
   base::WeakPtr<BlimpLocationProvider::Delegate> feature_delegate_;
+  scoped_refptr<base::SingleThreadTaskRunner> feature_task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(BlimpGeolocationDelegate);
 };
 
 device::Geoposition::ErrorCode ConvertErrorCode(
     const GeolocationErrorMessage::ErrorCode& error_code) {
   switch (error_code) {
     case GeolocationErrorMessage::PERMISSION_DENIED:
       return device::Geoposition::ErrorCode::ERROR_CODE_PERMISSION_DENIED;
     case GeolocationErrorMessage::POSITION_UNAVAILABLE:
@@ skipping 64 matching lines @@
     case GeolocationMessage::TYPE_NOT_SET:
       result = net::ERR_UNEXPECTED;
   }
   if (!callback.is_null()) {
     callback.Run(result);
   }
 }
 
 void EngineGeolocationFeature::NotifyCallback(
     const device::Geoposition& position) {
-  callback_task_runner_->PostTask(
-      FROM_HERE, base::Bind(geoposition_received_callback_, position));
+  geoposition_received_callback_.Run(position);
 }
 
 void EngineGeolocationFeature::RequestAccuracy(
     GeolocationSetInterestLevelMessage::Level level) {
   GeolocationMessage* geolocation_message = nullptr;
   std::unique_ptr<BlimpMessage> blimp_message =
       CreateBlimpMessage(&geolocation_message);
 
   GeolocationSetInterestLevelMessage* geolocation_interest =
       geolocation_message->mutable_set_interest_level();
@@ skipping 10 matching lines @@
 
   geolocation_message->mutable_request_refresh();
 
   outgoing_message_processor_->ProcessMessage(std::move(blimp_message),
                                               net::CompletionCallback());
 }
 
 void EngineGeolocationFeature::SetUpdateCallback(
     const GeopositionReceivedCallback& callback) {
   geoposition_received_callback_ = callback;
-
-  // Set |callback_task_runner_| to run on the current thread.
-  callback_task_runner_ = base::ThreadTaskRunnerHandle::Get();
 }
 
 }  // namespace engine
 }  // namespace blimp