Implement ScopedFD in terms of ScopedGeneric.

chrome/browser/chromeos/system/automatic_reboot_manager.cc

 // Copyright (c) 2013 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 "chrome/browser/chromeos/system/automatic_reboot_manager.h"
 
 #include <fcntl.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 
 #include <algorithm>
 #include <string>
 
 #include "ash/shell.h"
 #include "ash/wm/user_activity_detector.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
+#include "base/files/scoped_file.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/path_service.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/thread_task_runner_handle.h"
@@ skipping 18 matching lines @@
 
 namespace {
 
 const int kMinRebootUptimeMs = 60 * 60 * 1000;     // 1 hour.
 const int kLoginManagerIdleTimeoutMs = 60 * 1000;  // 60 seconds.
 const int kGracePeriodMs = 24 * 60 * 60 * 1000;    // 24 hours.
 const int kOneKilobyte = 1 << 10;                  // 1 kB in bytes.
 
 base::TimeDelta ReadTimeDeltaFromFile(const base::FilePath& path) {
   base::ThreadRestrictions::AssertIOAllowed();
-  int fd = HANDLE_EINTR(open(path.value().c_str(), O_RDONLY | O_NOFOLLOW));
-  if (fd < 0)
+  base::ScopedFD fd(
+      HANDLE_EINTR(open(path.value().c_str(), O_RDONLY | O_NOFOLLOW)));
+  if (!fd.is_valid())
     return base::TimeDelta();
-  file_util::ScopedFD fd_closer(&fd);
 
   std::string contents;
   char buffer[kOneKilobyte];
   ssize_t length;
-  while ((length = read(fd, buffer, sizeof(buffer))) > 0)
+  while ((length = read(fd.get(), buffer, sizeof(buffer))) > 0)
     contents.append(buffer, length);
 
   double seconds;
   if (!base::StringToDouble(contents.substr(0, contents.find(' ')), &seconds) ||
       seconds < 0.0) {
     return base::TimeDelta();
   }
   return base::TimeDelta::FromMilliseconds(seconds * 1000.0);
 }
 
@@ skipping 23 matching lines @@
       ReadTimeDeltaFromFile(update_reboot_needed_uptime_file);
   if (last_update_reboot_needed_uptime != kZeroTimeDelta)
     return;
 
   base::FilePath uptime_file;
   CHECK(PathService::Get(chromeos::FILE_UPTIME, &uptime_file));
   const base::TimeDelta uptime = ReadTimeDeltaFromFile(uptime_file);
   if (uptime == kZeroTimeDelta)
     return;
 
-  int fd = HANDLE_EINTR(open(update_reboot_needed_uptime_file.value().c_str(),
-                             O_CREAT | O_WRONLY | O_TRUNC | O_NOFOLLOW,
-                             0666));
-  if (fd < 0)
+  base::ScopedFD fd(HANDLE_EINTR(
+      open(update_reboot_needed_uptime_file.value().c_str(),
+           O_CREAT | O_WRONLY | O_TRUNC | O_NOFOLLOW,
+           0666)));
+  if (!fd.is_valid())
     return;
-  file_util::ScopedFD fd_closer(&fd);
 
   std::string update_reboot_needed_uptime =
       base::DoubleToString(uptime.InSecondsF());
-  base::WriteFileDescriptor(fd, update_reboot_needed_uptime.c_str(),
+  base::WriteFileDescriptor(fd.get(), update_reboot_needed_uptime.c_str(),
                             update_reboot_needed_uptime.size());
 }
 
 }  // namespace
 
 AutomaticRebootManager::SystemEventTimes::SystemEventTimes()
     : has_boot_time(false),
       has_update_reboot_needed_time(false) {
 }
 
@@ skipping 278 matching lines @@
   }
 
   login_screen_idle_timer_.reset();
   grace_start_timer_.reset();
   grace_end_timer_.reset();
   DBusThreadManager::Get()->GetPowerManagerClient()->RequestRestart();
 }
 
 }  // namespace system
 }  // namespace chromeos