Stop using [Client=...] feature of Mojom for GeolocationService

content/browser/geolocation/geolocation_service_impl.cc

 // Copyright 2014 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 "content/browser/geolocation/geolocation_service_impl.h"
 
 #include "base/bind.h"
 #include "base/metrics/histogram.h"
 #include "content/browser/geolocation/geolocation_service_context.h"
 #include "content/public/common/mojo_geoposition.mojom.h"
@@ skipping 45 matching lines @@
                             GEOPOSITION_ERROR_CODE_COUNT);
 }
 
 }  // namespace
 
 GeolocationServiceImpl::GeolocationServiceImpl(
     GeolocationServiceContext* context,
     const base::Closure& update_callback)
     : context_(context),
       update_callback_(update_callback),
-      high_accuracy_(false) {
+      high_accuracy_(false),
+      has_position_to_report_(false) {
   DCHECK(context_);
 }
 
 GeolocationServiceImpl::~GeolocationServiceImpl() {
 }
 
 void GeolocationServiceImpl::PauseUpdates() {
   geolocation_subscription_.reset();
 }
 
@@ skipping 21 matching lines @@
   high_accuracy_ = high_accuracy;
 
   if (position_override_.Validate()) {
     OnLocationUpdate(position_override_);
     return;
   }
 
   StartListeningForUpdates();
 }
 
+void GeolocationServiceImpl::QueryNextPosition(
+    const PositionCallback& callback) {
+  position_callbacks_.push_back(callback);
+
+  if (has_position_to_report_)
+    ReportCurrentPosition();
+}
+
 void GeolocationServiceImpl::SetOverride(const Geoposition& position) {
   position_override_ = position;
   if (!position_override_.Validate()) {
     ResumeUpdates();
   }
 
   geolocation_subscription_.reset();
 
   OnLocationUpdate(position_override_);
 }
@@ skipping 10 matching lines @@
   // return.
 }
 
 void GeolocationServiceImpl::OnLocationUpdate(const Geoposition& position) {
   RecordGeopositionErrorCode(position.error_code);
   DCHECK(context_);
 
   if (context_->paused())
     return;
 
-  MojoGeopositionPtr geoposition(MojoGeoposition::New());
-  geoposition->valid = position.Validate();
-  geoposition->latitude = position.latitude;
-  geoposition->longitude = position.longitude;
-  geoposition->altitude = position.altitude;
-  geoposition->accuracy = position.accuracy;
-  geoposition->altitude_accuracy = position.altitude_accuracy;
-  geoposition->heading = position.heading;
-  geoposition->speed = position.speed;
-  geoposition->timestamp = position.timestamp.ToDoubleT();
-  geoposition->error_code = MojoGeoposition::ErrorCode(position.error_code);
-  geoposition->error_message = position.error_message;
+  update_callback_.Run();
 
-  update_callback_.Run();
-  client()->OnLocationUpdate(geoposition.Pass());
+  current_position_.valid = position.Validate();
+  current_position_.latitude = position.latitude;
+  current_position_.longitude = position.longitude;
+  current_position_.altitude = position.altitude;
+  current_position_.accuracy = position.accuracy;
+  current_position_.altitude_accuracy = position.altitude_accuracy;
+  current_position_.heading = position.heading;
+  current_position_.speed = position.speed;
+  current_position_.timestamp = position.timestamp.ToDoubleT();
+  current_position_.error_code =
+      MojoGeoposition::ErrorCode(position.error_code);
+  current_position_.error_message = position.error_message;
+
+  has_position_to_report_ = true;
+
+  if (!position_callbacks_.empty())
+    ReportCurrentPosition();
+}
+
+void GeolocationServiceImpl::ReportCurrentPosition() {
+  for (const auto& callback : position_callbacks_)
+    callback.Run(current_position_.Clone());
+  position_callbacks_.clear();
+  has_position_to_report_ = false;
 }
 
 }  // namespace content