Make chrome communicate with gpsd through libgps/shared memory

content/browser/geolocation/gps_location_provider_linux.cc

 // Copyright (c) 2011 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/gps_location_provider_linux.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/bind.h"
@@ skipping 28 matching lines @@
       std::pow(std::fabs(position_1.latitude - position_2.latitude), 2) +
       std::pow(std::fabs(position_1.longitude - position_2.longitude), 2));
   // Convert to meters. 1 minute of arc of latitude (or longitude at the
   // equator) is 1 nautical mile or 1852m.
   delta *= 60 * 1852;
   return delta > kMovementThresholdMeters;
 }
 }  // namespace
 
 GpsLocationProviderLinux::GpsLocationProviderLinux(LibGpsFactory libgps_factory)
-    : libgps_factory_(libgps_factory),
+    : gpsd_reconnect_interval_millis_(kGpsdReconnectRetryIntervalMillis),
+      poll_period_moving_millis_(kPollPeriodMovingMillis),
+      poll_period_stationary_millis_(kPollPeriodStationaryMillis),
+      libgps_factory_(libgps_factory),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
   DCHECK(libgps_factory_);
 }
 
 GpsLocationProviderLinux::~GpsLocationProviderLinux() {
 }
 
 bool GpsLocationProviderLinux::StartProvider(bool high_accuracy) {
   if (!high_accuracy) {
     StopProvider();
     return true;  // Not an error condition, so still return true.
   }
   if (gps_ != NULL) {
     DCHECK(weak_factory_.HasWeakPtrs());
     return true;
   }
   position_.error_code = Geoposition::ERROR_CODE_POSITION_UNAVAILABLE;
   gps_.reset(libgps_factory_());
   if (gps_ == NULL) {
-    DLOG(WARNING) << "libgps.so could not be loaded";
+    DLOG(WARNING) << "libgps could not be loaded";
     return false;
   }
   ScheduleNextGpsPoll(0);
   return true;
 }
 
 void GpsLocationProviderLinux::StopProvider() {
   weak_factory_.InvalidateWeakPtrs();
   gps_.reset();
 }
 
 void GpsLocationProviderLinux::GetPosition(Geoposition* position) {
   DCHECK(position);
   *position = position_;
   DCHECK(position->IsInitialized());
 }
 
 void GpsLocationProviderLinux::UpdatePosition() {
   ScheduleNextGpsPoll(0);
 }
 
 void GpsLocationProviderLinux::OnPermissionGranted(
     const GURL& requesting_frame) {
 }
 
 void GpsLocationProviderLinux::DoGpsPollTask() {
   if (!gps_->Start()) {
     DLOG(WARNING) << "Couldn't start GPS provider.";
-    ScheduleNextGpsPoll(kGpsdReconnectRetryIntervalMillis);
+    ScheduleNextGpsPoll(gpsd_reconnect_interval_millis_);
     return;
   }
-  if (!gps_->Poll()) {
-    ScheduleNextGpsPoll(kPollPeriodStationaryMillis);
+
+  Geoposition new_position;
+  if (!gps_->Read(&new_position)) {
+    ScheduleNextGpsPoll(poll_period_stationary_millis_);
     return;
   }
-  Geoposition new_position;
-  gps_->GetPosition(&new_position);
+
   DCHECK(new_position.IsInitialized());
   const bool differ = PositionsDifferSiginificantly(position_, new_position);
-  ScheduleNextGpsPoll(differ ? kPollPeriodMovingMillis :
-                               kPollPeriodStationaryMillis);
+  ScheduleNextGpsPoll(differ ? poll_period_moving_millis_ :
+                               poll_period_stationary_millis_);
   if (differ || new_position.error_code != Geoposition::ERROR_CODE_NONE) {
     // Update if the new location is interesting or we have an error to report.
     position_ = new_position;
     UpdateListeners();
   }
 }
 
 void GpsLocationProviderLinux::ScheduleNextGpsPoll(int interval) {
   weak_factory_.InvalidateWeakPtrs();
   MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&GpsLocationProviderLinux::DoGpsPollTask,
                  weak_factory_.GetWeakPtr()),
       interval);
 }
 
 LocationProviderBase* NewSystemLocationProvider() {
   return new GpsLocationProviderLinux(LibGps::New);
 }