5 files changed, 202 insertions, 4 deletions
diff --git a/chromium/ui/base/idle/BUILD.gn b/chromium/ui/base/idle/BUILD.gn
index 6feed4fbb44..bd3ac4e8ba8 100644
--- a/chromium/ui/base/idle/BUILD.gn
+++ b/chromium/ui/base/idle/BUILD.gn
@@ -18,7 +18,11 @@ component("idle") {
   # All targets in this file are allowed to access any of the headers.
   friend = [ ":*" ]
 
-  public = [ "idle.h" ]
+  public = [
+    "idle.h",
+    "idle_polling_service.h",
+    "idle_time_provider.h",
+  ]
 
   deps = [
     "//base",
@@ -34,6 +38,9 @@ component("idle") {
     "idle.h",
     "idle_internal.cc",
     "idle_internal.h",
+    "idle_polling_service.cc",
+    "idle_polling_service.h",
+    "idle_time_provider.h",
   ]
 
   if (is_chromeos_ash) {
diff --git a/chromium/ui/base/idle/idle_linux.cc b/chromium/ui/base/idle/idle_linux.cc
index 3d43db331f1..d1f3f058617 100644
--- a/chromium/ui/base/idle/idle_linux.cc
+++ b/chromium/ui/base/idle/idle_linux.cc
@@ -45,11 +45,12 @@ struct {
     {"org.cinnamon.ScreenSaver", "/org/cinnamon/ScreenSaver",
      "org.cinnamon.ScreenSaver"},
     // gnome-screensaver
-    {"org.gnome.ScreenSaver", "/", "org.gnome.ScreenSaver"},
+    {"org.gnome.ScreenSaver", "/org/gnome/ScreenSaver",
+     "org.gnome.ScreenSaver"},
     // mate-screensaver
-    {"org.mate.ScreenSaver", "/", "org.mate.ScreenSaver"},
+    {"org.mate.ScreenSaver", "/org/mate/ScreenSaver", "org.mate.ScreenSaver"},
     // xfce4-screensaver
-    {"org.xfce.ScreenSaver", "/", "org.xfce.ScreenSaver"},
+    {"org.xfce.ScreenSaver", "/org/xfce/ScreenSaver", "org.xfce.ScreenSaver"},
 };
 
 constexpr size_t kServiceCount = sizeof(kServices) / sizeof(kServices[0]);
diff --git a/chromium/ui/base/idle/idle_polling_service.cc b/chromium/ui/base/idle/idle_polling_service.cc
new file mode 100644
index 00000000000..a1da7216c1c
--- /dev/null
+++ b/chromium/ui/base/idle/idle_polling_service.cc
@@ -0,0 +1,102 @@
+// Copyright 2021 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 "ui/base/idle/idle_polling_service.h"
+
+#include "base/no_destructor.h"
+#include "base/observer_list.h"
+#include "ui/base/idle/idle.h"
+#include "ui/base/idle/idle_time_provider.h"
+
+namespace ui {
+
+namespace {
+
+constexpr base::TimeDelta kPollInterval = base::Seconds(1);
+
+// Default provider implementation. Everything is delegated to
+// ui::CalculateIdleTime and ui::CheckIdleStateIsLocked.
+class DefaultIdleProvider : public IdleTimeProvider {
+ public:
+  DefaultIdleProvider() = default;
+  ~DefaultIdleProvider() override = default;
+
+  base::TimeDelta CalculateIdleTime() override {
+    return base::Seconds(ui::CalculateIdleTime());
+  }
+
+  bool CheckIdleStateIsLocked() override {
+    return ui::CheckIdleStateIsLocked();
+  }
+};
+
+}  // namespace
+
+// static
+IdlePollingService* IdlePollingService::GetInstance() {
+  static base::NoDestructor<IdlePollingService> instance;
+  return instance.get();
+}
+
+const IdlePollingService::State& IdlePollingService::GetIdleState() {
+  // |last_state_| won't be valid if we aren't polling.
+  DCHECK(timer_.IsRunning());
+  return last_state_;
+}
+
+void IdlePollingService::AddObserver(Observer* observer) {
+  // Fetch the current state and start polling if this was the first observer.
+  if (observers_.empty()) {
+    DCHECK(!timer_.IsRunning());
+    PollIdleState();
+    timer_.Reset();
+  }
+
+  observers_.AddObserver(observer);
+}
+
+void IdlePollingService::RemoveObserver(Observer* observer) {
+  DCHECK(timer_.IsRunning());
+  observers_.RemoveObserver(observer);
+
+  // Stop polling when there are no observers to save resources.
+  if (observers_.empty()) {
+    timer_.Stop();
+  }
+}
+
+void IdlePollingService::SetProviderForTest(
+    std::unique_ptr<IdleTimeProvider> provider) {
+  provider_ = std::move(provider);
+  if (!provider_) {
+    provider_ = std::make_unique<DefaultIdleProvider>();
+  }
+}
+
+bool IdlePollingService::IsPollingForTest() {
+  return timer_.IsRunning();
+}
+
+IdlePollingService::IdlePollingService()
+    : timer_(FROM_HERE,
+             kPollInterval,
+             base::BindRepeating(&IdlePollingService::PollIdleState,
+                                 base::Unretained(this))),
+      provider_(std::make_unique<DefaultIdleProvider>()) {
+  DCHECK(!timer_.IsRunning());
+}
+
+IdlePollingService::~IdlePollingService() = default;
+
+void IdlePollingService::PollIdleState() {
+  last_state_.idle_time = provider_->CalculateIdleTime();
+  last_state_.locked = provider_->CheckIdleStateIsLocked();
+
+  // TODO(https://crbug.com/939870): Only notify observers on change.
+  for (Observer& observer : observers_) {
+    observer.OnIdleStateChange(last_state_);
+  }
+}
+
+}  // namespace ui
diff --git a/chromium/ui/base/idle/idle_polling_service.h b/chromium/ui/base/idle/idle_polling_service.h
new file mode 100644
index 00000000000..ee2b13f3f7a
--- /dev/null
+++ b/chromium/ui/base/idle/idle_polling_service.h
@@ -0,0 +1,64 @@
+// Copyright 2021 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.
+
+#ifndef UI_BASE_IDLE_IDLE_POLLING_SERVICE_H_
+#define UI_BASE_IDLE_IDLE_POLLING_SERVICE_H_
+
+#include <memory>
+
+#include "base/component_export.h"
+#include "base/no_destructor.h"
+#include "base/observer_list.h"
+#include "base/observer_list_types.h"
+#include "base/time/time.h"
+#include "base/timer/timer.h"
+
+namespace ui {
+
+class IdleTimeProvider;
+
+// Polls the system to determine whether the user is idle or the screen is
+// locked and notifies observers.
+class COMPONENT_EXPORT(UI_BASE_IDLE) IdlePollingService {
+ public:
+  static IdlePollingService* GetInstance();
+
+  struct State {
+    bool locked;
+    base::TimeDelta idle_time;
+  };
+
+  class Observer : public base::CheckedObserver {
+   public:
+    virtual void OnIdleStateChange(const State& state) = 0;
+  };
+
+  IdlePollingService(const IdlePollingService&) = delete;
+  IdlePollingService& operator=(const IdlePollingService&) = delete;
+
+  void AddObserver(Observer* observer);
+  void RemoveObserver(Observer* observer);
+
+  const State& GetIdleState();
+
+  void SetProviderForTest(std::unique_ptr<IdleTimeProvider> provider);
+  bool IsPollingForTest();
+
+ private:
+  friend class base::NoDestructor<IdlePollingService>;
+
+  IdlePollingService();
+  ~IdlePollingService();
+
+  void PollIdleState();
+
+  base::RepeatingTimer timer_;
+  std::unique_ptr<IdleTimeProvider> provider_;
+  State last_state_;
+  base::ObserverList<Observer> observers_;
+};
+
+}  // namespace ui
+
+#endif  // UI_BASE_IDLE_IDLE_POLLING_SERVICE_H_
diff --git a/chromium/ui/base/idle/idle_time_provider.h b/chromium/ui/base/idle/idle_time_provider.h
new file mode 100644
index 00000000000..a5af57badb3
--- /dev/null
+++ b/chromium/ui/base/idle/idle_time_provider.h
@@ -0,0 +1,24 @@
+// Copyright 2021 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.
+
+#ifndef UI_BASE_IDLE_IDLE_TIME_PROVIDER_H_
+#define UI_BASE_IDLE_IDLE_TIME_PROVIDER_H_
+
+#include "base/time/time.h"
+
+namespace ui {
+
+// Provides an interface for querying a user's idle time and screen state.
+class IdleTimeProvider {
+ public:
+  virtual ~IdleTimeProvider() = default;
+
+  // See ui/base/idle/idle.h for the semantics of these methods.
+  virtual base::TimeDelta CalculateIdleTime() = 0;
+  virtual bool CheckIdleStateIsLocked() = 0;
+};
+
+}  // namespace ui
+
+#endif  // UI_BASE_IDLE_IDLE_TIME_PROVIDER_H_