AU: Simplify the automatic update check code a little.

update_attempter.cc

 // Copyright (c) 2010 The Chromium OS 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 "update_engine/update_attempter.h"
 
 // From 'man clock_gettime': feature test macro: _POSIX_C_SOURCE >= 199309L
 #ifndef _POSIX_C_SOURCE
 #define _POSIX_C_SOURCE 199309L
 #endif  // _POSIX_C_SOURCE
@@ skipping 17 matching lines @@
 #include "update_engine/set_bootable_flag_action.h"
 
 using base::TimeDelta;
 using base::TimeTicks;
 using std::tr1::shared_ptr;
 using std::string;
 using std::vector;
 
 namespace chromeos_update_engine {
 
+namespace {
+
+const int kTimeoutOnce = 7 * 60;  // at 7 minutes
+const int kTimeoutPeriodic = 45 * 60;  // every 45 minutes
+const int kTimeoutFuzz = 10 * 60;  // +/- 5 minutes
+
+gboolean CheckForUpdatePeriodically(void* arg) {
+  UpdateAttempter* update_attempter = reinterpret_cast<UpdateAttempter*>(arg);
+  update_attempter->Update("", "");
+  update_attempter->SchedulePeriodicUpdateCheck(kTimeoutPeriodic);
+  return FALSE;  // Don't run again.
+}
+
+}  // namespace {}
+
 const char* kUpdateCompletedMarker = "/tmp/update_engine_autoupdate_completed";
 
 const char* UpdateStatusToString(UpdateStatus status) {
   switch (status) {
     case UPDATE_STATUS_IDLE:
       return "UPDATE_STATUS_IDLE";
     case UPDATE_STATUS_CHECKING_FOR_UPDATE:
       return "UPDATE_STATUS_CHECKING_FOR_UPDATE";
     case UPDATE_STATUS_UPDATE_AVAILABLE:
       return "UPDATE_STATUS_UPDATE_AVAILABLE";
@@ skipping 356 matching lines @@
                              omaha_request_params_,
                              error_event_.release(),  // Pass ownership.
                              new LibcurlHttpFetcher));
   actions_.push_back(shared_ptr<AbstractAction>(error_event_action));
   processor_.EnqueueAction(error_event_action.get());
   SetStatusAndNotify(UPDATE_STATUS_REPORTING_ERROR_EVENT);
   processor_.StartProcessing();
   return true;
 }
 
+void UpdateAttempter::InitiatePeriodicUpdateChecks() {
+  if (!utils::IsOfficialBuild()) {
+    LOG(WARNING) << "Non-official build: periodic update checks disabled.";
+    return;
+  }
+  if (utils::IsRemovableDevice(utils::RootDevice(utils::BootDevice()))) {
+    LOG(WARNING) << "Removable device boot: periodic update checks disabled.";
+    return;
+  }
+  // Kick off periodic update checks. The first check is scheduled
+  // |kTimeoutOnce| seconds from now. Subsequent checks are scheduled
+  // at |kTimeoutPeriodic|-second intervals.
+  SchedulePeriodicUpdateCheck(kTimeoutOnce);
+}
+
+void UpdateAttempter::SchedulePeriodicUpdateCheck(int seconds) {
+  seconds = utils::FuzzInt(seconds, kTimeoutFuzz);
+  g_timeout_add_seconds(seconds, CheckForUpdatePeriodically, this);
+  LOG(INFO) << "Next update check in " << seconds << " seconds.";
+}
+
 void UpdateAttempter::SetPriority(utils::ProcessPriority priority) {
   if (priority_ == priority) {
     return;
   }
   if (utils::SetProcessPriority(priority)) {
     priority_ = priority;
     LOG(INFO) << "Process priority = " << priority_;
   }
 }
 
@@ skipping 31 matching lines @@
     SetPriority(utils::kProcessPriorityNormal);
     return true;
   }
   // Set the priority to high and let GLib destroy the timeout source.
   SetPriority(utils::kProcessPriorityHigh);
   manage_priority_source_ = NULL;
   return false;
 }
 
 }  // namespace chromeos_update_engine