Dispatch geolocation IPCs on the UI thread. Aside from simplifying the code to avoid a lot of threa…

chrome/browser/chromeos/policy/device_status_collector.cc

 // Copyright (c) 2012 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 "chrome/browser/chromeos/policy/device_status_collector.h"
 
 #include <limits>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 63 matching lines @@
   return (Time::FromUTCExploded(exploded) - Time::UnixEpoch()).InMilliseconds();
 }
 
 // Maximum number of users to report.
 const int kMaxUserCount = 5;
 
 }  // namespace
 
 namespace policy {
 
-DeviceStatusCollector::Context::Context() {
-}
-
-DeviceStatusCollector::Context::~Context() {
-}
-
-void DeviceStatusCollector::Context::GetLocationUpdate(
-    const content::GeolocationProvider::LocationUpdateCallback& callback) {
-  owner_callback_ = callback;
-  content::BrowserThread::PostTask(
-      content::BrowserThread::IO,
-      FROM_HERE,
-      base::Bind(&DeviceStatusCollector::Context::GetLocationUpdateInternal,
-                 this));
-}
-
-void DeviceStatusCollector::Context::GetLocationUpdateInternal() {
-  our_callback_ = base::Bind(
-      &DeviceStatusCollector::Context::OnLocationUpdate, this);
-  content::GeolocationProvider::GetInstance()->AddLocationUpdateCallback(
-      our_callback_, true);
-}
-
-void DeviceStatusCollector::Context::OnLocationUpdate(
-    const content::Geoposition& geoposition) {
-  content::GeolocationProvider::GetInstance()->RemoveLocationUpdateCallback(
-      our_callback_);
-  our_callback_.Reset();
-  content::BrowserThread::PostTask(
-      content::BrowserThread::UI,
-      FROM_HERE,
-      base::Bind(&DeviceStatusCollector::Context::CallCollector,
-                 this, geoposition));
-}
-
-void DeviceStatusCollector::Context::CallCollector(
-    const content::Geoposition& geoposition) {
-  owner_callback_.Run(geoposition);
-  owner_callback_.Reset();
-}
-
 DeviceStatusCollector::DeviceStatusCollector(
     PrefService* local_state,
     chromeos::system::StatisticsProvider* provider,
     LocationUpdateRequester* location_update_requester)
     : max_stored_past_activity_days_(kMaxStoredPastActivityDays),
       max_stored_future_activity_days_(kMaxStoredFutureActivityDays),
       local_state_(local_state),
       last_idle_check_(Time()),
       last_reported_day_(0),
       duration_for_last_reported_day_(0),
       geolocation_update_in_progress_(false),
       statistics_provider_(provider),
       weak_factory_(this),
       report_version_info_(false),
       report_activity_times_(false),
       report_boot_mode_(false),
       report_location_(false),
       report_network_interfaces_(false),
-      report_users_(false),
-      context_(new Context()) {
-  if (location_update_requester) {
+      report_users_(false) {
+  if (location_update_requester)
     location_update_requester_ = *location_update_requester;
-  } else {
-    location_update_requester_ =
-        base::Bind(&Context::GetLocationUpdate, context_.get());
-  }
   idle_poll_timer_.Start(FROM_HERE,
                          TimeDelta::FromSeconds(kIdlePollIntervalSeconds),
                          this, &DeviceStatusCollector::CheckIdleState);
 
   cros_settings_ = chromeos::CrosSettings::Get();
 
   // Watch for changes to the individual policies that control what the status
   // reports contain.
   base::Closure callback =
       base::Bind(&DeviceStatusCollector::UpdateReportingSettings,
@@ skipping 384 matching lines @@
 }
 
 void DeviceStatusCollector::ScheduleGeolocationUpdateRequest() {
   if (geolocation_update_timer_.IsRunning() || geolocation_update_in_progress_)
     return;
 
   if (position_.Validate()) {
     TimeDelta elapsed = GetCurrentTime() - position_.timestamp;
     TimeDelta interval =
         TimeDelta::FromSeconds(kGeolocationPollIntervalSeconds);
-    if (elapsed > interval) {
-      geolocation_update_in_progress_ = true;
-      location_update_requester_.Run(base::Bind(
-          &DeviceStatusCollector::ReceiveGeolocationUpdate,
-          weak_factory_.GetWeakPtr()));
-    } else {
+    if (elapsed <= interval) {
       geolocation_update_timer_.Start(
           FROM_HERE,
           interval - elapsed,
           this,
           &DeviceStatusCollector::ScheduleGeolocationUpdateRequest);
+      return;
     }
+  }
+
+  geolocation_update_in_progress_ = true;
+  if (location_update_requester_.is_null()) {
+    geolocation_subscription_ = content::GeolocationProvider::GetInstance()->
+        AddLocationUpdateCallback(
+            base::Bind(&DeviceStatusCollector::ReceiveGeolocationUpdate,
+                       weak_factory_.GetWeakPtr()),
+            true);
   } else {
-    geolocation_update_in_progress_ = true;
     location_update_requester_.Run(base::Bind(
         &DeviceStatusCollector::ReceiveGeolocationUpdate,
         weak_factory_.GetWeakPtr()));
   }
 }
 
 void DeviceStatusCollector::ReceiveGeolocationUpdate(
     const content::Geoposition& position) {
   geolocation_update_in_progress_ = false;
 
@@ skipping 13 matching lines @@
     location.SetDouble(kSpeed, position.speed);
     location.SetString(kTimestamp,
         base::Int64ToString(position.timestamp.ToInternalValue()));
     local_state_->Set(prefs::kDeviceLocation, location);
   }
 
   ScheduleGeolocationUpdateRequest();
 }
 
 }  // namespace policy