Updater: Implement ControlServiceInProcess::Run().

Bug: 1107586

Change-Id: I7ced77b044da43ae4b9d23b5065c396fdbb570f7
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2321531
Commit-Queue: Mila Green <milagreen@chromium.org>
Reviewed-by: Sorin Jianu <sorin@chromium.org>
Reviewed-by: Joshua Pawlicki <waffles@chromium.org>
Cr-Commit-Position: refs/heads/master@{#792806}

chrome/updater/app/server/mac/server.mm

@@ -60,7 +60,8 @@ void AppServerMac::ActiveDuty() {
 
     // Sets up a listener and delegate for the CRUControlling XPC connection
     control_service_delegate_.reset([[CRUControlServiceXPCDelegate alloc]
-        initWithControlService:base::MakeRefCounted<ControlServiceInProcess>()
+        initWithControlService:base::MakeRefCounted<ControlServiceInProcess>(
+                                   config_)
                      appServer:scoped_refptr<AppServerMac>(this)]);
 
     control_service_listener_.reset([[NSXPCListener alloc]

chrome/updater/control_service_in_process.cc

@@ -4,18 +4,52 @@
 
 #include "chrome/updater/control_service_in_process.h"
 
+#include "base/bind.h"
 #include "base/callback.h"
+#include "base/logging.h"
 #include "base/threading/sequenced_task_runner_handle.h"
+#include "base/time/time.h"
+#include "chrome/updater/configurator.h"
+#include "chrome/updater/prefs.h"
+#include "chrome/updater/update_service.h"
+#include "components/prefs/pref_service.h"
 
 namespace updater {
 
-ControlServiceInProcess::ControlServiceInProcess()
-    : main_task_runner_(base::SequencedTaskRunnerHandle::Get()) {}
+ControlServiceInProcess::ControlServiceInProcess(
+    scoped_refptr<updater::Configurator> config)
+    : config_(config),
+      main_task_runner_(base::SequencedTaskRunnerHandle::Get()) {}
 
 void ControlServiceInProcess::Run(base::OnceClosure callback) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
-  // TODO(crbug.com/1107586): Implement.
+  const base::Time lastUpdateTime =
+      config_->GetPrefService()->GetTime(kPrefUpdateTime);
+
+  const base::TimeDelta timeSinceUpdate =
+      base::Time::NowFromSystemTime() - lastUpdateTime;
+  if (timeSinceUpdate >=
+          base::TimeDelta::FromSeconds(config_->NextCheckDelay()) ||
+      timeSinceUpdate < base::TimeDelta()) {
+    scoped_refptr<UpdateService> update_service = CreateUpdateService(config_);
+
+    update_service->UpdateAll(
+        base::BindRepeating([](UpdateService::UpdateState) {}),
+        base::BindOnce(
+            [](base::OnceClosure closure,
+               scoped_refptr<updater::Configurator> config,
+               UpdateService::Result result) {
+              const int exit_code = static_cast<int>(result);
+              VLOG(0) << "UpdateAll complete: exit_code = " << exit_code;
+              if (result == UpdateService::Result::kSuccess) {
+                config->GetPrefService()->SetTime(
+                    kPrefUpdateTime, base::Time::NowFromSystemTime());
+              }
+              std::move(closure).Run();
+            },
+            base::BindOnce(std::move(callback)), config_));
+  }
 }
 
 void ControlServiceInProcess::Uninitialize() {

chrome/updater/control_service_in_process.h

@@ -16,10 +16,12 @@ class SequencedTaskRunner;
 
 namespace updater {
 
+class Configurator;
+
 // All functions and callbacks must be called on the same sequence.
 class ControlServiceInProcess : public ControlService {
  public:
-  ControlServiceInProcess();
+  explicit ControlServiceInProcess(scoped_refptr<updater::Configurator> config);
 
   // Overrides for updater::ControlService.
   void Run(base::OnceClosure callback) override;
@@ -31,6 +33,7 @@ class ControlServiceInProcess : public ControlService {
 
   SEQUENCE_CHECKER(sequence_checker_);
 
+  scoped_refptr<updater::Configurator> config_;
   scoped_refptr<base::SequencedTaskRunner> main_task_runner_;
 };
 

chrome/updater/prefs.cc

@@ -29,6 +29,8 @@ const char kPrefActiveVersion[] = "active_version";
 
 }  // namespace
 
+const char kPrefUpdateTime[] = "update_time";
+
 UpdaterPrefsImpl::UpdaterPrefsImpl(std::unique_ptr<ScopedPrefsLock> lock,
                                    std::unique_ptr<PrefService> prefs)
     : lock_(std::move(lock)), prefs_(std::move(prefs)) {}
@@ -81,6 +83,7 @@ std::unique_ptr<GlobalPrefs> CreateGlobalPrefs() {
   update_client::RegisterPrefs(pref_registry.get());
   pref_registry->RegisterBooleanPref(kPrefSwapping, false);
   pref_registry->RegisterStringPref(kPrefActiveVersion, "0");
+  pref_registry->RegisterTimePref(kPrefUpdateTime, base::Time());
 
   return std::make_unique<UpdaterPrefsImpl>(
       std::move(lock), pref_service_factory.Create(pref_registry));
@@ -98,6 +101,7 @@ std::unique_ptr<LocalPrefs> CreateLocalPrefs() {
   auto pref_registry = base::MakeRefCounted<PrefRegistrySimple>();
   update_client::RegisterPrefs(pref_registry.get());
   pref_registry->RegisterBooleanPref(kPrefQualified, false);
+  pref_registry->RegisterTimePref(kPrefUpdateTime, base::Time());
 
   return std::make_unique<UpdaterPrefsImpl>(
       nullptr, pref_service_factory.Create(pref_registry));

chrome/updater/prefs.h

@@ -11,6 +11,8 @@ class PrefService;
 
 namespace updater {
 
+extern const char kPrefUpdateTime[];
+
 class UpdaterPrefs {
  public:
   UpdaterPrefs() = default;

chrome/updater/prefs_impl.h

@@ -44,7 +44,7 @@ class UpdaterPrefsImpl : public LocalPrefs, public GlobalPrefs {
   bool GetQualified() const override;
   void SetQualified(bool value) override;
 
-  // Overrides for GlobalPrfs
+  // Overrides for GlobalPrefs
   std::string GetActiveVersion() const override;
   void SetActiveVersion(std::string value) override;
   bool GetSwapping() const override;