AU: Provide a reboot_if_needed D-Bus API.

utils.cc

-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// Copyright (c) 2009 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/utils.h"
 #include <sys/mount.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <dirent.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <algorithm>
 #include "chromeos/obsolete_logging.h"
 #include "update_engine/file_writer.h"
+#include "update_engine/subprocess.h"
 
 using std::min;
 using std::string;
 using std::vector;
 
 namespace chromeos_update_engine {
 
 namespace utils {
 
 bool WriteFile(const char* path, const char* data, int data_len) {
@@ skipping 37 matching lines @@
     ssize_t rc = pread(fd, c_buf + bytes_read, count - bytes_read,
                        offset + bytes_read);
     TEST_AND_RETURN_FALSE_ERRNO(rc >= 0);
     if (rc == 0) {
       break;
     }
     bytes_read += rc;
   }
   *out_bytes_read = bytes_read;
   return true;
-  
+
 }
 
 bool ReadFile(const std::string& path, std::vector<char>* out) {
   CHECK(out);
   FILE* fp = fopen(path.c_str(), "r");
   if (!fp)
     return false;
   const size_t kChunkSize = 1024;
   size_t read_size;
   do {
@@ skipping 188 matching lines @@
   return path;
 }
 
 bool MakeTempFile(const std::string& filename_template,
                   std::string* filename,
                   int* fd) {
   DCHECK(filename || fd);
   vector<char> buf(filename_template.size() + 1);
   memcpy(&buf[0], filename_template.data(), filename_template.size());
   buf[filename_template.size()] = '\0';
-  
+
   int mkstemp_fd = mkstemp(&buf[0]);
   TEST_AND_RETURN_FALSE_ERRNO(mkstemp_fd >= 0);
   if (filename) {
     *filename = &buf[0];
   }
   if (fd) {
     *fd = mkstemp_fd;
   } else {
     close(mkstemp_fd);
   }
   return true;
 }
 
 bool MakeTempDirectory(const std::string& dirname_template,
                        std::string* dirname) {
   DCHECK(dirname);
   vector<char> buf(dirname_template.size() + 1);
   memcpy(&buf[0], dirname_template.data(), dirname_template.size());
   buf[dirname_template.size()] = '\0';
-  
+
   char* return_code = mkdtemp(&buf[0]);
   TEST_AND_RETURN_FALSE_ERRNO(return_code != NULL);
   *dirname = &buf[0];
   return true;
 }
 
 bool StringHasSuffix(const std::string& str, const std::string& suffix) {
   if (suffix.size() > str.size())
     return false;
   return 0 == str.compare(str.size() - suffix.size(), suffix.size(), suffix);
@@ skipping 70 matching lines @@
   *out_bootloader = BootLoader_SYSLINUX;
   return true;
 }
 
 const char* GetGErrorMessage(const GError* error) {
   if (!error)
     return "Unknown error.";
   return error->message;
 }
 
+bool Reboot() {
+  vector<string> command;
+  command.push_back("/sbin/shutdown");
+  command.push_back("-r");
+  command.push_back("now");
+  int rc = 0;
+  Subprocess::SynchronousExec(command, &rc);
+  TEST_AND_RETURN_FALSE(rc == 0);
+  return true;
+}
+
 const char* const kStatefulPartition = "/mnt/stateful_partition";
 
 }  // namespace utils
 
 }  // namespace chromeos_update_engine
-