Revert of Reland: Geolocation: move from content/browser to device/ (patchset #2 id:20001 of https:…

chrome/browser/chromeos/policy/device_status_collector_browsertest.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 <memory>
@@ skipping 33 matching lines @@
 #include "chromeos/disks/disk_mount_manager.h"
 #include "chromeos/disks/mock_disk_mount_manager.h"
 #include "chromeos/network/network_handler.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
 #include "chromeos/settings/cros_settings_names.h"
 #include "chromeos/system/fake_statistics_provider.h"
 #include "components/prefs/pref_service.h"
 #include "components/prefs/testing_pref_service.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/geolocation_provider.h"
 #include "content/public/test/test_browser_thread.h"
 #include "content/public/test/test_utils.h"
-#include "device/geolocation/geolocation_provider.h"
 #include "policy/proto/device_management_backend.pb.h"
 #include "storage/browser/fileapi/external_mount_points.h"
 #include "storage/browser/fileapi/mount_points.h"
 #include "storage/common/fileapi/file_system_mount_option.h"
 #include "storage/common/fileapi/file_system_types.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 using ::testing::Return;
 using ::testing::ReturnRef;
 using base::Time;
 using base::TimeDelta;
 using chromeos::disks::DiskMountManager;
 
 namespace em = enterprise_management;
 
 namespace {
 
 const int64_t kMillisecondsPerDay = Time::kMicrosecondsPerDay / 1000;
 const char kKioskAccountId[] = "kiosk_user@localhost";
 const char kKioskAppId[] = "kiosk_app_id";
 const char kExternalMountPoint[] = "/a/b/c";
 const char kPublicAccountId[] = "public_user@localhost";
 
-std::unique_ptr<device::Geoposition> mock_position_to_return_next;
+std::unique_ptr<content::Geoposition> mock_position_to_return_next;
 
-void SetMockPositionToReturnNext(const device::Geoposition& position) {
-  mock_position_to_return_next.reset(new device::Geoposition(position));
+void SetMockPositionToReturnNext(const content::Geoposition &position) {
+  mock_position_to_return_next.reset(new content::Geoposition(position));
 }
 
 void MockPositionUpdateRequester(
-    const device::GeolocationProvider::LocationUpdateCallback& callback) {
+    const content::GeolocationProvider::LocationUpdateCallback& callback) {
   if (!mock_position_to_return_next.get())
     return;
 
   // If the fix is invalid, the DeviceStatusCollector will immediately request
   // another update when it receives the callback. This is desirable and safe in
   // real life where geolocation updates arrive asynchronously. In this testing
   // harness, the callback is invoked synchronously upon request, leading to a
   // request-callback loop. The loop is broken by returning the mock position
   // only once.
-  std::unique_ptr<device::Geoposition> position(
+  std::unique_ptr<content::Geoposition> position(
       mock_position_to_return_next.release());
   callback.Run(*position);
 }
 
 class TestingDeviceStatusCollector : public policy::DeviceStatusCollector {
  public:
   TestingDeviceStatusCollector(
       PrefService* local_state,
       chromeos::system::StatisticsProvider* provider,
       const policy::DeviceStatusCollector::LocationUpdateRequester&
@@ skipping 670 matching lines @@
   EXPECT_TRUE(status_.has_os_version());
   EXPECT_TRUE(status_.has_firmware_version());
 
   // Check that the browser version is not empty. OS version & firmware
   // don't have any reasonable values inside the unit test, so those
   // aren't checked.
   EXPECT_NE("", status_.browser_version());
 }
 
 TEST_F(DeviceStatusCollectorTest, Location) {
-  device::Geoposition valid_fix;
+  content::Geoposition valid_fix;
   valid_fix.latitude = 4.3;
   valid_fix.longitude = -7.8;
   valid_fix.accuracy = 3.;
   valid_fix.timestamp = Time::Now();
 
-  device::Geoposition invalid_fix;
-  invalid_fix.error_code = device::Geoposition::ERROR_CODE_POSITION_UNAVAILABLE;
+  content::Geoposition invalid_fix;
+  invalid_fix.error_code =
+      content::Geoposition::ERROR_CODE_POSITION_UNAVAILABLE;
   invalid_fix.timestamp = Time::Now();
 
   // Check that when device location reporting is disabled, no location is
   // reported.
   SetMockPositionToReturnNext(valid_fix);
   CheckThatNoLocationIsReported();
 
   // Check that when device location reporting is enabled and a valid fix is
   // available, the location is reported and is stored in local state.
   SetMockPositionToReturnNext(valid_fix);
@@ skipping 678 matching lines @@
       AccountId::FromUserEmail(kPublicAccountId));
   EXPECT_CALL(*user_manager_, IsLoggedInAsPublicAccount())
       .WillRepeatedly(Return(true));
 
   settings_helper_.SetBoolean(chromeos::kReportDeviceNetworkInterfaces, true);
   GetStatus();
   VerifyNetworkReporting();
 }
 
 }  // namespace policy