AU: Always run setgoodkernel, unless we abort within 45 seconds of launch.

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 10 matching lines @@
 #include "update_engine/dbus_service.h"
 #include "update_engine/download_action.h"
 #include "update_engine/filesystem_copier_action.h"
 #include "update_engine/libcurl_http_fetcher.h"
 #include "update_engine/multi_range_http_fetcher.h"
 #include "update_engine/omaha_request_action.h"
 #include "update_engine/omaha_request_params.h"
 #include "update_engine/omaha_response_handler_action.h"
 #include "update_engine/postinstall_runner_action.h"
 #include "update_engine/prefs_interface.h"
+#include "update_engine/subprocess.h"
 #include "update_engine/update_check_scheduler.h"
 
 using base::TimeDelta;
 using base::TimeTicks;
 using google::protobuf::NewPermanentCallback;
 using std::make_pair;
 using std::tr1::shared_ptr;
 using std::string;
 using std::vector;
 
@@ skipping 66 matching lines @@
       manage_priority_source_(NULL),
       download_active_(false),
       status_(UPDATE_STATUS_IDLE),
       download_progress_(0.0),
       last_checked_time_(0),
       new_version_("0.0.0.0"),
       new_size_(0),
       is_full_update_(false),
       proxy_manual_checks_(0),
       obeying_proxies_(true),
-      chrome_proxy_resolver_(dbus_iface) {
+      chrome_proxy_resolver_(dbus_iface),
+      updated_boot_flags_(false) {
   if (utils::FileExists(kUpdateCompletedMarker))
     status_ = UPDATE_STATUS_UPDATED_NEED_REBOOT;
 }
 
 UpdateAttempter::~UpdateAttempter() {
   CleanupPriorityManagement();
 }
 
 void UpdateAttempter::Update(const std::string& app_version,
                              const std::string& omaha_url,
                              bool obey_proxies) {
   chrome_proxy_resolver_.Init();
+  UpdateBootFlags();  // Just in case we didn't do this yet.
   if (status_ == UPDATE_STATUS_UPDATED_NEED_REBOOT) {
     LOG(INFO) << "Not updating b/c we already updated and we're waiting for "
               << "reboot";
     return;
   }
   if (status_ != UPDATE_STATUS_IDLE) {
     // Update in progress. Do nothing
     return;
   }
   http_response_code_ = 0;
@@ skipping 304 matching lines @@
                                 std::string* new_version,
                                 int64_t* new_size) {
   *last_checked_time = last_checked_time_;
   *progress = download_progress_;
   *current_operation = UpdateStatusToString(status_);
   *new_version = new_version_;
   *new_size = new_size_;
   return true;
 }
 
+void UpdateAttempter::UpdateBootFlags() {
+  if (updated_boot_flags_) {
+    LOG(INFO) << "Already updated boot flags. Skipping.";
+    return;
+  }
+  // This is purely best effort. Failures should be logged by Subprocess.
+  int unused = 0;
+  vector<string> cmd(1, "/usr/sbin/chromeos-setgoodkernel");
+  Subprocess::SynchronousExec(cmd, &unused);
+  updated_boot_flags_ = true;
+  return;
+}
+
 void UpdateAttempter::SetStatusAndNotify(UpdateStatus status) {
   status_ = status;
   if (update_check_scheduler_) {
     update_check_scheduler_->SetUpdateStatus(status_);
   }
   if (!dbus_service_)
     return;
   last_notify_time_ = TimeTicks::Now();
   update_engine_service_emit_status_update(
       dbus_service_,
@@ skipping 132 matching lines @@
     uint64_t resume_offset = manifest_metadata_size + next_data_offset;
     if (resume_offset < response_handler_action_->install_plan().size) {
       fetcher->AddRange(resume_offset, -1);
     }
   } else {
     fetcher->AddRange(0, -1);
   }
 }
 
 }  // namespace chromeos_update_engine