Hooks together Geolocation Feature in the Client and Engine.

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;
   }
 
   bool UseNetworkLocationProviders() final { return false; }
 
   std::unique_ptr<device::LocationProvider> OverrideSystemLocationProvider()
@@ skipping 80 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) {
-  geoposition_received_callback_.Run(position);
+  task_runner_->PostTask(FROM_HERE,
+                         base::Bind(geoposition_received_callback_, 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;
+  SetTaskRunner(base::ThreadTaskRunnerHandle::Get());
+}
+
+void EngineGeolocationFeature::SetTaskRunner(
+    scoped_refptr<base::SingleThreadTaskRunner> runner) {
+  task_runner_ = std::move(runner);

[Wez, 2016/09/01 02:45:43]

Why can't we just assign task_runner_ directly in SetUpdateCallback?

[CJ, 2016/09/01 18:17:05]

It's because ThreadTaskRunnerHandle::Get() returns a const task runner, and cant
be assigned to the non-const |task_runner_|. Is there a better way to handle
this?

[Wez, 2016/09/01 20:08:17]

You can just assigned the result of Get() directly into a
scoped_refptr<TaskRunner> - that's effectively what you're doing by passing it
to SetTaskRunner(), since that takes a scoped_refptr<>.

 }
 
 }  // namespace engine
 }  // namespace blimp