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();

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

Do we need to store this as a field? Can we just get the handle in
OverrideSystemLocationProvider?

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

I don't believe so, since OverrideSystemLocationProvider is called on the
Geolocation Thread, not the Blimp thread. We want the Blimp thread in this case.

   }
 
   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 94 matching lines @@
   std::unique_ptr<BlimpMessage> blimp_message =
       CreateBlimpMessage(&geolocation_message);
 
   geolocation_message->mutable_request_refresh();
 
   outgoing_message_processor_->ProcessMessage(std::move(blimp_message),
                                               net::CompletionCallback());
 }
 
 void EngineGeolocationFeature::SetUpdateCallback(
+    scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
     const GeopositionReceivedCallback& callback) {
   geoposition_received_callback_ = callback;
-
   // Set |callback_task_runner_| to run on the current thread.

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

This doesn't make sense?

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

Done.

-  callback_task_runner_ = base::ThreadTaskRunnerHandle::Get();
+  callback_task_runner_ = caller_task_runner;
 }
 
 }  // namespace engine
 }  // namespace blimp