Reland 2:Geolocation: move from content/browser to device/

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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 302 matching lines @@
   session_status_subscription_ = cros_settings_->AddSettingsObserver(
       chromeos::kReportDeviceSessionStatus, callback);
   os_update_status_subscription_ = cros_settings_->AddSettingsObserver(
       chromeos::kReportOsUpdateStatus, callback);
   running_kiosk_app_subscription_ = cros_settings_->AddSettingsObserver(
       chromeos::kReportRunningKioskApp, callback);
 
   // The last known location is persisted in local state. This makes location
   // information available immediately upon startup and avoids the need to
   // reacquire the location on every user session change or browser crash.
-  content::Geoposition position;
+  device::Geoposition position;
   std::string timestamp_str;
   int64_t timestamp;
   const base::DictionaryValue* location =
       local_state_->GetDictionary(prefs::kDeviceLocation);
   if (location->GetDouble(kLatitude, &position.latitude) &&
       location->GetDouble(kLongitude, &position.longitude) &&
       location->GetDouble(kAltitude, &position.altitude) &&
       location->GetDouble(kAccuracy, &position.accuracy) &&
       location->GetDouble(kAltitudeAccuracy, &position.altitude_accuracy) &&
       location->GetDouble(kHeading, &position.heading) &&
@@ skipping 89 matching lines @@
   // not launched yet.
   if (!cros_settings_->GetBoolean(
       chromeos::kReportDeviceLocation, &report_location_)) {
     report_location_ = false;
   }
 
   if (report_location_) {
     ScheduleGeolocationUpdateRequest();
   } else {
     geolocation_update_timer_.Stop();
-    position_ = content::Geoposition();
+    position_ = device::Geoposition();
     local_state_->ClearPref(prefs::kDeviceLocation);
   }
 
   if (!report_hardware_status_) {
     ClearCachedHardwareStatus();
   } else if (!already_reporting_hardware_status) {
     // Turning on hardware status reporting - fetch an initial sample
     // immediately instead of waiting for the sampling timer to fire.
     SampleHardwareStatus();
   }
@@ skipping 671 matching lines @@
           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(
+    geolocation_subscription_ =
+        device::GeolocationProvider::GetInstance()->AddLocationUpdateCallback(
             base::Bind(&DeviceStatusCollector::ReceiveGeolocationUpdate,
                        weak_factory_.GetWeakPtr()),
             true);
   } else {
     location_update_requester_.Run(base::Bind(
         &DeviceStatusCollector::ReceiveGeolocationUpdate,
         weak_factory_.GetWeakPtr()));
   }
 }
 
 void DeviceStatusCollector::ReceiveGeolocationUpdate(
-    const content::Geoposition& position) {
+    const device::Geoposition& position) {
   geolocation_update_in_progress_ = false;
 
   // Ignore update if device location reporting has since been disabled.
   if (!report_location_)
     return;
 
   if (position.Validate()) {
     position_ = position;
     base::DictionaryValue location;
     location.SetDouble(kLatitude, position.latitude);
@@ skipping 11 matching lines @@
   ScheduleGeolocationUpdateRequest();
 }
 
 void DeviceStatusCollector::ReceiveVolumeInfo(
     const std::vector<em::VolumeInfo>& info) {
   if (report_hardware_status_)
     volume_info_ = info;
 }
 
 }  // namespace policy