ash / system / geolocation / geolocation_controller_unittest.cc [blame]

// Copyright 2021 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "ash/system/geolocation/geolocation_controller.h"

#include <string_view>

#include "ash/constants/ash_pref_names.h"
#include "ash/constants/geolocation_access_level.h"
#include "ash/session/session_controller_impl.h"
#include "ash/session/test_session_controller_client.h"
#include "ash/shell.h"
#include "ash/system/geolocation/geolocation_controller_test_util.h"
#include "ash/system/geolocation/test_geolocation_url_loader_factory.h"
#include "ash/system/privacy_hub/privacy_hub_controller.h"
#include "ash/system/time/time_of_day.h"
#include "ash/test/ash_test_base.h"
#include "ash/test/time_of_day_test_util.h"
#include "ash/test_shell_delegate.h"
#include "base/check.h"
#include "base/memory/raw_ptr.h"
#include "base/strings/utf_string_conversions.h"
#include "base/test/simple_test_clock.h"
#include "base/time/clock.h"
#include "base/time/time.h"
#include "base/timer/mock_timer.h"
#include "chromeos/ash/components/geolocation/simple_geolocation_provider.h"
#include "chromeos/dbus/power/fake_power_manager_client.h"
#include "components/prefs/pref_service.h"
#include "services/network/public/cpp/shared_url_loader_factory.h"
#include "third_party/icu/source/i18n/unicode/timezone.h"

namespace ash {

namespace {

constexpr char kUser1Email[] = "user1@geolocation";
constexpr char kUser2Email[] = "user2@geolocation";

// Sets of test longitudes/latitude and the corresponding sunrise/sunset times
// for testing. They all assume the clock's current time is `kTestNow`.
constexpr std::string_view kTestNow = "23 Dec 2021 12:00:00";

constexpr double kTestLatitude1 = 23.5;
constexpr double kTestLongitude1 = 35.88;
constexpr std::string_view kTestSunriseTime1 = "23 Dec 2021 04:14:36.626";
constexpr std::string_view kTestSunsetTime1 = "23 Dec 2021 14:59:58.459";

constexpr double kTestLatitude2 = 37.5;
constexpr double kTestLongitude2 = -100.5;
constexpr std::string_view kTestSunriseTime2 = "23 Dec 2021 13:55:13.306";
constexpr std::string_view kTestSunsetTime2 = "23 Dec 2021 23:33:46.855";

constexpr SimpleGeoposition kSanJoseGeoposition = {37.335480, -121.893028};

constexpr SimpleGeoposition kSanFranciscoGeoposition = {37.773972, -122.431297};

constexpr SimpleGeoposition kNewYorkGeoposition = {40.730610, -73.935242};

// Kiruna, Sweden
constexpr SimpleGeoposition kNoDarknessGeoposition = {67.855800, 20.225282};

// Belgrano II Base, Antarctica
constexpr SimpleGeoposition kNoDaylightGeoposition = {-77.87361, -34.62745};

constexpr char kNoDaylightDarknessTimestamp[] = "07 Jun 2023 20:30:00.000";

constexpr int kDefaultSunsetTimeOffsetMinutes = 18 * 60;
constexpr int kDefaultSunriseTimeOffsetMinutes = 6 * 60;

// Constructs a TimeZone object from the given `timezone_id`.
std::unique_ptr<icu::TimeZone> CreateTimezone(const char* timezone_id) {
  return base::WrapUnique(icu::TimeZone::createTimeZone(
      icu::UnicodeString(timezone_id, -1, US_INV)));
}

std::u16string GetTimezoneId(const icu::TimeZone& timezone) {
  return system::TimezoneSettings::GetTimezoneID(timezone);
}

base::Time ToUTCTime(std::string_view utc_time_str) {
  base::Time time;
  CHECK(base::Time::FromUTCString(std::string(utc_time_str).c_str(), &time))
      << "Invalid UTC time string specified: " << utc_time_str;
  return time;
}

class FakeGeolocationController : public GeolocationController {
 public:
  explicit FakeGeolocationController(
      SimpleGeolocationProvider* geolocation_provider)
      : GeolocationController(geolocation_provider) {}

  // Proxy method to call the `OnGeoposition()` callback directly, without
  // waiting for the server response. Need this to test scheduler behavior.
  void ImitateGeopositionReceived() {
    Geoposition fake_pos;
    fake_pos.latitude = kTestLatitude1;
    fake_pos.longitude = kTestLongitude1;
    fake_pos.status = Geoposition::STATUS_OK;
    fake_pos.accuracy = 10;
    fake_pos.timestamp = base::Time::Now();

    GeolocationController::OnGeoposition(fake_pos, false, base::Seconds(1));
  }

  // TODO(b/286233027): Override `RequestGeolocation()` to fake the server
  // communication.
};

// Base test fixture.
class GeolocationControllerTest : public AshTestBase {
 public:
  GeolocationControllerTest()
      : AshTestBase(base::test::TaskEnvironment::TimeSource::MOCK_TIME) {}
  GeolocationControllerTest(const GeolocationControllerTest&) = delete;
  GeolocationControllerTest& operator=(const GeolocationControllerTest&) =
      delete;

  ~GeolocationControllerTest() override = default;

  // AshTestBase:
  void SetUp() override {
    AshTestBase::SetUp();
    CreateTestUserSessions();
    // `SimpleGeolocationProvider` is initialized by `AshTestHelper`.
    controller_ = std::make_unique<FakeGeolocationController>(
        SimpleGeolocationProvider::GetInstance());

    test_clock_.SetNow(base::Time::Now());
    controller_->SetClockForTesting(&test_clock_);
    timer_ptr_ = controller_->GetTimerForTesting();

    // Prepare a valid geoposition.
    Geoposition position;
    position.latitude = 32.0;
    position.longitude = 31.0;
    position.status = Geoposition::STATUS_OK;
    position.accuracy = 10;
    position.timestamp = base::Time::Now();
    SetServerPosition(position);
  }

  // AshTestBase:
  void TearDown() override {
    controller_.reset();
    AshTestBase::TearDown();
  }

  FakeGeolocationController* controller() const { return controller_.get(); }
  base::SimpleTestClock* test_clock() { return &test_clock_; }
  base::OneShotTimer* timer_ptr() const { return timer_ptr_; }
  const Geoposition& position() const { return position_; }

  PrefService* user1_pref_service() {
    return Shell::Get()->session_controller()->GetUserPrefServiceForUser(
        AccountId::FromUserEmail(kUser1Email));
  }

  PrefService* user2_pref_service() {
    return Shell::Get()->session_controller()->GetUserPrefServiceForUser(
        AccountId::FromUserEmail(kUser2Email));
  }

  void CreateTestUserSessions() {
    GetSessionControllerClient()->Reset();
    GetSessionControllerClient()->AddUserSession(kUser1Email);
    GetSessionControllerClient()->AddUserSession(kUser2Email);
  }

  void SwitchActiveUser(const std::string& email) {
    GetSessionControllerClient()->SwitchActiveUser(
        AccountId::FromUserEmail(email));
  }

  // Fires the timer of the scheduler to request geoposition and wait for all
  // observers to receive the latest geoposition from the server.
  void FireTimerToFetchGeoposition() {
    GeopositionResponsesWaiter waiter(controller());
    EXPECT_TRUE(timer_ptr()->IsRunning());
    // Fast forward the scheduler to reach the time when the controller
    // requests for geoposition from the server in
    // `GeolocationController::RequestGeoposition`.
    timer_ptr_->FireNow();
    // Waits for the observers to receive the geoposition from the server.
    waiter.Wait();
  }

  // Sets the geoposition to be returned from the `factory_` upon the
  // `GeolocationController` request.
  void SetServerPosition(const Geoposition& position) {
    position_ = position;
    auto* factory = static_cast<TestGeolocationUrlLoaderFactory*>(
        SimpleGeolocationProvider::GetInstance()
            ->GetSharedURLLoaderFactoryForTesting());
    factory->ClearResponses();
    factory->set_position(position_);
  }

  void UpdateUserGeolocationPermission(GeolocationAccessLevel access_level) {
    SimpleGeolocationProvider::GetInstance()->SetGeolocationAccessLevel(
        access_level);
  }

 private:
  std::unique_ptr<FakeGeolocationController> controller_;
  base::SimpleTestClock test_clock_;
  raw_ptr<base::OneShotTimer, DanglingUntriaged> timer_ptr_;
  Geoposition position_;
};

// Tests adding and removing an observer should request and stop receiving
// a position update.
TEST_F(GeolocationControllerTest, Observer) {
  EXPECT_FALSE(timer_ptr()->IsRunning());

  // Add an observer should start the timer requesting the geoposition.
  GeolocationControllerObserver observer;
  controller()->AddObserver(&observer);
  FireTimerToFetchGeoposition();
  EXPECT_EQ(1, observer.position_received_num());

  // Check that the timer fires another schedule after a successful request.
  EXPECT_TRUE(timer_ptr()->IsRunning());

  // Removing an observer should stop the timer.
  controller()->RemoveObserver(&observer);
  EXPECT_FALSE(timer_ptr()->IsRunning());
  EXPECT_EQ(1, observer.position_received_num());
}

// Tests adding and removing observer and make sure that only observing ones
// receive the position updates.
TEST_F(GeolocationControllerTest, MultipleObservers) {
  EXPECT_FALSE(timer_ptr()->IsRunning());

  // Add an observer should start the timer requesting for the first
  // geoposition request.
  GeolocationControllerObserver observer1;
  controller()->AddObserver(&observer1);
  FireTimerToFetchGeoposition();
  EXPECT_EQ(1, observer1.position_received_num());
  EXPECT_TRUE(timer_ptr()->IsRunning());

  // Since `OnGeoposition()` handling a geoposition update always schedule
  // the next geoposition request, the timer should keep running and
  // update position periodically.
  FireTimerToFetchGeoposition();
  EXPECT_EQ(2, observer1.position_received_num());
  EXPECT_TRUE(timer_ptr()->IsRunning());

  // Adding `observer2` should not interrupt the request flow. Check that both
  // observers receive the new position.
  GeolocationControllerObserver observer2;
  controller()->AddObserver(&observer2);
  FireTimerToFetchGeoposition();
  EXPECT_EQ(3, observer1.position_received_num());
  EXPECT_EQ(1, observer2.position_received_num());
  EXPECT_TRUE(timer_ptr()->IsRunning());

  // Remove `observer1` and make sure that the timer is still running.
  // Only `observer2` should receive the new position.
  controller()->RemoveObserver(&observer1);
  FireTimerToFetchGeoposition();
  EXPECT_EQ(3, observer1.position_received_num());
  EXPECT_EQ(2, observer2.position_received_num());
  EXPECT_TRUE(timer_ptr()->IsRunning());

  // Removing `observer2` should stop the timer. The request count should
  // not change.
  controller()->RemoveObserver(&observer2);
  EXPECT_FALSE(timer_ptr()->IsRunning());
  EXPECT_EQ(3, observer1.position_received_num());
  EXPECT_EQ(2, observer2.position_received_num());
}

// Tests that controller only pushes valid positions.
TEST_F(GeolocationControllerTest, InvalidPositions) {
  GeolocationControllerObserver observer;
  // Update to an invalid position
  Geoposition invalid_position(position());
  invalid_position.error_code = 10;
  SetServerPosition(invalid_position);
  EXPECT_FALSE(timer_ptr()->IsRunning());
  controller()->AddObserver(&observer);

  // If the position is invalid, the controller won't push the geoposition
  // update to its observers.
  EXPECT_TRUE(timer_ptr()->IsRunning());
  timer_ptr()->FireNow();
  // Wait for the request and response to finish.
  base::RunLoop().RunUntilIdle();
  EXPECT_EQ(0, observer.position_received_num());
  // With error response, the server will retry with another timer which we
  // have no control over, so `mock_timer_ptr_` will not be running (refers to
  // `SimpleGeolocationRequest::Retry()` for more detail).
  EXPECT_FALSE(timer_ptr()->IsRunning());
}

// Tests that timezone changes result.
TEST_F(GeolocationControllerTest, TimezoneChanges) {
  EXPECT_FALSE(timer_ptr()->IsRunning());
  controller()->SetCurrentTimezoneIdForTesting(u"America/Los_Angeles");

  // Add an observer.
  GeolocationControllerObserver observer;
  controller()->AddObserver(&observer);
  EXPECT_EQ(0, observer.position_received_num());
  FireTimerToFetchGeoposition();
  EXPECT_EQ(1, observer.position_received_num());
  EXPECT_EQ(u"America/Los_Angeles", controller()->current_timezone_id());
  EXPECT_TRUE(timer_ptr()->IsRunning());

  // A new timezone results in new geoposition request.
  auto timezone = CreateTimezone("Asia/Tokyo");

  controller()->TimezoneChanged(*timezone);
  FireTimerToFetchGeoposition();
  EXPECT_EQ(2, observer.position_received_num());
  EXPECT_EQ(GetTimezoneId(*timezone), controller()->current_timezone_id());
  EXPECT_TRUE(timer_ptr()->IsRunning());
}

TEST_F(GeolocationControllerTest, SystemGeolocationPermissionChanges) {
  EXPECT_FALSE(timer_ptr()->IsRunning());

  GeolocationControllerObserver observer;
  controller()->AddObserver(&observer);
  EXPECT_EQ(0, observer.position_received_num());

  FireTimerToFetchGeoposition();
  EXPECT_EQ(1, observer.position_received_num());
  EXPECT_TRUE(timer_ptr()->IsRunning());

  // Block geolocation usage to apps only, shouldn't affect
  // `GeolocationController`.
  UpdateUserGeolocationPermission(
      GeolocationAccessLevel::kOnlyAllowedForSystem);
  EXPECT_TRUE(timer_ptr()->IsRunning());

  // Disable system geo permission. Scheduling should stop.
  UpdateUserGeolocationPermission(GeolocationAccessLevel::kDisallowed);
  EXPECT_FALSE(timer_ptr()->IsRunning());

  // Re-enabling the system geo permission, should resume scheduling.
  UpdateUserGeolocationPermission(GeolocationAccessLevel::kAllowed);
  EXPECT_TRUE(timer_ptr()->IsRunning());
}

TEST_F(GeolocationControllerTest, StopSchedulingWhileResponseIsComing) {
  EXPECT_FALSE(timer_ptr()->IsRunning());

  // This will start scheduling.
  GeolocationControllerObserver observer;
  controller()->AddObserver(&observer);
  EXPECT_TRUE(timer_ptr()->IsRunning());

  // Fire Geolocation request.
  timer_ptr()->FireNow();
  EXPECT_FALSE(timer_ptr()->IsRunning());

  // Disable user geolocation permission, this should stop scheduling.
  UpdateUserGeolocationPermission(GeolocationAccessLevel::kDisallowed);
  EXPECT_FALSE(timer_ptr()->IsRunning());

  // Simulate server response and check it didn't resume scheduling.
  controller()->ImitateGeopositionReceived();
  EXPECT_FALSE(timer_ptr()->IsRunning());

  // Re-enable user geolocation permission, this should resume scheduling.
  UpdateUserGeolocationPermission(GeolocationAccessLevel::kAllowed);
  EXPECT_TRUE(timer_ptr()->IsRunning());

  // Unsubscribe the observer before being destroyed.
  controller()->RemoveObserver(&observer);
}

TEST_F(GeolocationControllerTest, StopSchedulingWhenObserverListIsEmpty) {
  EXPECT_FALSE(timer_ptr()->IsRunning());

  // Add the first observer. This will kick off scheduling.
  GeolocationControllerObserver observer;
  controller()->AddObserver(&observer);

  // Fire Geolocation request.
  timer_ptr()->FireNow();

  // Unsubscribe the only observer.
  controller()->RemoveObserver(&observer);

  // Simulate the server response and check it didn't resume the scheduler.
  controller()->ImitateGeopositionReceived();
  EXPECT_FALSE(timer_ptr()->IsRunning());

  // Add the observer back, scheduling should resume.
  controller()->AddObserver(&observer);
  EXPECT_TRUE(timer_ptr()->IsRunning());

  // Unsubscribe the observer before being destroyed.
  controller()->RemoveObserver(&observer);
}

// Tests obtaining sunset/sunrise time when there is no valid geoposition, for
// example, due to lack of connectivity.
TEST_F(GeolocationControllerTest, SunsetSunriseDefault) {
  // If geoposition is unset, the controller should return the default sunset
  // and sunrise time .
  EXPECT_EQ(controller()->GetSunsetTime(),
            ToTimeToday(TimeOfDay(kDefaultSunsetTimeOffsetMinutes)));
  EXPECT_EQ(controller()->GetSunriseTime(),
            ToTimeToday(TimeOfDay(kDefaultSunriseTimeOffsetMinutes)));
}

// Tests the behavior when there is a valid geoposition, sunrise and sunset
// times are calculated correctly.
TEST_F(GeolocationControllerTest, GetSunRiseSet) {
  test_clock()->SetNow(ToUTCTime(kTestNow));

  // Add an observer and make sure that sunset and sunrise time are not
  // updated until the timer is fired.
  GeolocationControllerObserver observer1;
  controller()->AddObserver(&observer1);
  EXPECT_TRUE(timer_ptr()->IsRunning());
  EXPECT_NE(controller()->GetSunsetTime(), ToUTCTime(kTestSunsetTime1));
  EXPECT_NE(controller()->GetSunriseTime(), ToUTCTime(kTestSunriseTime1));
  EXPECT_EQ(0, observer1.position_received_num());

  // Prepare a valid geoposition.
  Geoposition position;
  position.latitude = kTestLatitude1;
  position.longitude = kTestLongitude1;
  position.status = Geoposition::STATUS_OK;
  position.accuracy = 10;
  position.timestamp = ToUTCTime(kTestNow);

  // Test that after sending the new position, sunrise and sunset time are
  // updated correctly.
  SetServerPosition(position);
  FireTimerToFetchGeoposition();
  EXPECT_EQ(1, observer1.position_received_num());
  EXPECT_EQ(controller()->GetSunsetTime(), ToUTCTime(kTestSunsetTime1));
  EXPECT_EQ(controller()->GetSunriseTime(), ToUTCTime(kTestSunriseTime1));
  EXPECT_TRUE(timer_ptr()->IsRunning());
}

// Tests that when there is a geoposition with 24 hours of daylight or darkness,
// sunrise and sunset times honor the API.
TEST_F(GeolocationControllerTest, GetSunRiseSetWithAllDaylightOrDarkness) {
  test_clock()->SetNow(ToUTCTime(kNoDaylightDarknessTimestamp));

  Geoposition position;
  position.latitude = kNoDarknessGeoposition.latitude;
  position.longitude = kNoDarknessGeoposition.longitude;
  position.status = Geoposition::STATUS_OK;
  position.accuracy = 10;
  position.timestamp = test_clock()->Now();

  // Test that after sending the new position, sunrise and sunset time are
  // updated correctly.
  SetServerPosition(position);
  FireTimerToFetchGeoposition();
  EXPECT_EQ(controller()->GetSunsetTime(),
            GeolocationController::kNoSunRiseSet);
  EXPECT_EQ(controller()->GetSunriseTime(),
            GeolocationController::kNoSunRiseSet);

  position.latitude = kNoDaylightGeoposition.latitude;
  position.longitude = kNoDaylightGeoposition.longitude;

  // Test that after sending the new position, sunrise and sunset time are
  // updated correctly.
  SetServerPosition(position);
  FireTimerToFetchGeoposition();
  EXPECT_EQ(controller()->GetSunsetTime(),
            GeolocationController::kNoSunRiseSet);
  EXPECT_EQ(controller()->GetSunriseTime(),
            GeolocationController::kNoSunRiseSet);
}

// Tests that if device sleeps more than a day, the geoposition is fetched
// instantly.
TEST_F(GeolocationControllerTest, RequestGeopositionAfterSuspend) {
  const base::TimeDelta zero_duration = base::Seconds(0);
  auto* power_manager_client = chromeos::FakePowerManagerClient::Get();
  const base::TimeDelta next_request_delay_after_success = base::Days(1);
  // Add an observer. Adding the first observer automatically requests a
  // geoposition instantly.
  GeolocationControllerObserver observer;
  controller()->AddObserver(&observer);
  EXPECT_EQ(0, observer.position_received_num());
  EXPECT_EQ(zero_duration, timer_ptr()->GetCurrentDelay());

  // Fetch that instant request to make the next request has a delay becomes
  // `kNextRequestDelayAfterSuccess`, i.e. `next_request_delay_after_success`,
  FireTimerToFetchGeoposition();
  EXPECT_EQ(next_request_delay_after_success, timer_ptr()->GetCurrentDelay());
  EXPECT_EQ(1, observer.position_received_num());

  // Suspend the device for a day and wake the device.
  power_manager_client->SendSuspendImminent(
      power_manager::SuspendImminent::Reason::SuspendImminent_Reason_IDLE);
  power_manager_client->SendSuspendDone(base::Days(1));
  // Test that after waking up from 1-day suspension, the controller request a
  // new geoposition instantly.
  EXPECT_EQ(zero_duration, timer_ptr()->GetCurrentDelay());
  FireTimerToFetchGeoposition();
  EXPECT_EQ(2, observer.position_received_num());
  EXPECT_EQ(next_request_delay_after_success, timer_ptr()->GetCurrentDelay());

  // Suspend the device for less than a day.
  power_manager_client->SendSuspendImminent(
      power_manager::SuspendImminent::Reason::SuspendImminent_Reason_IDLE);
  // Test that after waking up from 2-hr suspension, the controller continues
  // the old geoposition request with the same delay.
  power_manager_client->SendSuspendDone(base::Hours(2));
  EXPECT_EQ(next_request_delay_after_success, timer_ptr()->GetCurrentDelay());
}

// Tests the behavior when there is no valid geoposition for example due to lack
// of connectivity.
TEST_F(GeolocationControllerTest, AbsentValidGeoposition) {
  test_clock()->SetNow(ToUTCTime(kTestNow));

  // Initially, no values are stored in either of the two users' prefs.
  ASSERT_FALSE(user1_pref_service()->HasPrefPath(
      prefs::kDeviceGeolocationCachedLatitude));
  ASSERT_FALSE(user1_pref_service()->HasPrefPath(
      prefs::kDeviceGeolocationCachedLongitude));
  ASSERT_FALSE(user2_pref_service()->HasPrefPath(
      prefs::kDeviceGeolocationCachedLatitude));
  ASSERT_FALSE(user2_pref_service()->HasPrefPath(
      prefs::kDeviceGeolocationCachedLongitude));

  // Store fake geoposition in user 2's prefs.
  user2_pref_service()->SetDouble(prefs::kDeviceGeolocationCachedLatitude,
                                  kTestLatitude1);
  user2_pref_service()->SetDouble(prefs::kDeviceGeolocationCachedLongitude,
                                  kTestLongitude1);

  // Switch to user 2 and expect that geoposition is loaded from pref.
  SwitchActiveUser(kUser2Email);
  EXPECT_EQ(controller()->GetSunsetTime(), ToUTCTime(kTestSunsetTime1));
  EXPECT_EQ(controller()->GetSunriseTime(), ToUTCTime(kTestSunriseTime1));

  // Switching to user 1 should ignore the current geoposition since it's
  // a cached value from user 2's prefs rather than a newly-updated value.
  SwitchActiveUser(kUser1Email);
  EXPECT_EQ(
      controller()->GetSunsetTime(),
      ToTimeToday(
          TimeOfDay(kDefaultSunsetTimeOffsetMinutes).SetClock(test_clock())));
  EXPECT_EQ(
      controller()->GetSunriseTime(),
      ToTimeToday(
          TimeOfDay(kDefaultSunriseTimeOffsetMinutes).SetClock(test_clock())));

  // Now simulate receiving a live geoposition update.
  Geoposition position;
  position.latitude = kTestLatitude1;
  position.longitude = kTestLongitude1;
  position.status = Geoposition::STATUS_OK;
  position.accuracy = 10;
  position.timestamp = ToUTCTime(kTestNow);
  SetServerPosition(position);
  FireTimerToFetchGeoposition();
  EXPECT_EQ(controller()->GetSunsetTime(), ToUTCTime(kTestSunsetTime1));
  EXPECT_EQ(controller()->GetSunriseTime(), ToUTCTime(kTestSunriseTime1));

  // Update user 2's prefs with different geoposition.
  user2_pref_service()->SetDouble(prefs::kDeviceGeolocationCachedLatitude,
                                  kTestLatitude2);
  user2_pref_service()->SetDouble(prefs::kDeviceGeolocationCachedLongitude,
                                  kTestLongitude2);

  // Now switching to user 2 should completely ignore their cached geopsoition,
  // since from now on we have a valid newly-retrieved value.
  SwitchActiveUser(kUser2Email);
  EXPECT_EQ(controller()->GetSunsetTime(), ToUTCTime(kTestSunsetTime1));
  EXPECT_EQ(controller()->GetSunriseTime(), ToUTCTime(kTestSunriseTime1));

  // Clear all cached geoposition prefs for all users, just to make sure getting
  // a new geoposition will persist it for all users not just the active one.
  user1_pref_service()->ClearPref(prefs::kDeviceGeolocationCachedLatitude);
  user1_pref_service()->ClearPref(prefs::kDeviceGeolocationCachedLongitude);
  user2_pref_service()->ClearPref(prefs::kDeviceGeolocationCachedLatitude);
  user2_pref_service()->ClearPref(prefs::kDeviceGeolocationCachedLongitude);

  // Now simulate receiving another live geoposition update.
  position.latitude = kTestLatitude2;
  position.longitude = kTestLongitude2;
  SetServerPosition(position);
  FireTimerToFetchGeoposition();
  EXPECT_EQ(controller()->GetSunsetTime(), ToUTCTime(kTestSunsetTime2));
  EXPECT_EQ(controller()->GetSunriseTime(), ToUTCTime(kTestSunriseTime2));
  EXPECT_EQ(kTestLatitude2, user1_pref_service()->GetDouble(
                                prefs::kDeviceGeolocationCachedLatitude));
  EXPECT_EQ(kTestLongitude2, user1_pref_service()->GetDouble(
                                 prefs::kDeviceGeolocationCachedLongitude));
  EXPECT_EQ(kTestLatitude2, user2_pref_service()->GetDouble(
                                prefs::kDeviceGeolocationCachedLatitude));
  EXPECT_EQ(kTestLongitude2, user2_pref_service()->GetDouble(
                                 prefs::kDeviceGeolocationCachedLongitude));
}

// Tests that the `possible_change_in_timezone` is correct.
TEST_F(GeolocationControllerTest, ObserverPossibleChangeInTimezone) {
  test_clock()->SetNow(ToUTCTime(kTestNow));

  GeolocationControllerObserver observer;
  controller()->AddObserver(&observer);

  Geoposition position;
  position.latitude = kSanJoseGeoposition.latitude;
  position.longitude = kSanJoseGeoposition.longitude;
  position.status = Geoposition::STATUS_OK;
  position.accuracy = 10;
  position.timestamp = test_clock()->Now();
  SetServerPosition(position);
  FireTimerToFetchGeoposition();
  // First geoposition should always count as a possible change.
  ASSERT_EQ(observer.position_received_num(), 1);
  EXPECT_TRUE(observer.possible_change_in_timezone());

  position.latitude = kSanFranciscoGeoposition.latitude;
  position.longitude = kSanFranciscoGeoposition.longitude;
  SetServerPosition(position);
  FireTimerToFetchGeoposition();
  ASSERT_EQ(observer.position_received_num(), 2);
  EXPECT_FALSE(observer.possible_change_in_timezone());

  position.latitude = kNewYorkGeoposition.latitude;
  position.longitude = kNewYorkGeoposition.longitude;
  SetServerPosition(position);
  FireTimerToFetchGeoposition();
  ASSERT_EQ(observer.position_received_num(), 3);
  EXPECT_TRUE(observer.possible_change_in_timezone());

  controller()->RemoveObserver(&observer);
}

// Tests that the `possible_change_in_timezone` is correct when areas with no
// daylight/darkness are involved.
TEST_F(GeolocationControllerTest,
       ObserverPossibleChangeInTimezoneNoDaylightDarkness) {
  test_clock()->SetNow(ToUTCTime(kNoDaylightDarknessTimestamp));

  Geoposition position;
  position.status = Geoposition::STATUS_OK;
  position.accuracy = 10;
  position.timestamp = test_clock()->Now();

  GeolocationControllerObserver observer;
  controller()->AddObserver(&observer);
  int expected_position_received_num = 1;
  const auto test_new_geoposition = [this, &position,
                                     &expected_position_received_num,
                                     &observer](
                                        const SimpleGeoposition& new_lat_long) {
    position.latitude = new_lat_long.latitude;
    position.longitude = new_lat_long.longitude;
    SetServerPosition(position);
    FireTimerToFetchGeoposition();
    ASSERT_EQ(observer.position_received_num(), expected_position_received_num);
    EXPECT_TRUE(observer.possible_change_in_timezone());
    expected_position_received_num++;
  };

  test_new_geoposition(kSanJoseGeoposition);
  test_new_geoposition(kNoDarknessGeoposition);
  test_new_geoposition(kSanFranciscoGeoposition);
  test_new_geoposition(kNoDaylightGeoposition);
  test_new_geoposition(kNoDarknessGeoposition);

  controller()->RemoveObserver(&observer);
}

}  // namespace

}  // namespace ash