Revert of Implement ScopedFD in terms of ScopedGeneric.

chrome/browser/mac/relauncher.cc

 // Copyright 2012 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/mac/relauncher.h"
 
 #include <ApplicationServices/ApplicationServices.h>
 #include <AvailabilityMacros.h>
 #include <crt_externs.h>
 #include <dlfcn.h>
 #include <string.h>
 #include <sys/event.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <unistd.h>
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/file_util.h"
-#include "base/files/scoped_file.h"
 #include "base/logging.h"
 #include "base/mac/mac_logging.h"
 #include "base/mac/mac_util.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "base/path_service.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/process/launch.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/sys_string_conversions.h"
 #include "chrome/browser/mac/install_from_dmg.h"
@@ skipping 93 matching lines @@
     PLOG(ERROR) << "pipe";
     return false;
   }
 
   // The parent process will only use pipe_read_fd as the read side of the
   // pipe. It can close the write side as soon as the relauncher process has
   // forked off. The relauncher process will only use pipe_write_fd as the
   // write side of the pipe. In that process, the read side will be closed by
   // base::LaunchApp because it won't be present in fd_map, and the write side
   // will be remapped to kRelauncherSyncFD by fd_map.
-  base::ScopedFD pipe_read_fd(pipe_fds[0]);
-  base::ScopedFD pipe_write_fd(pipe_fds[1]);
+  file_util::ScopedFD pipe_read_fd(&pipe_fds[0]);
+  file_util::ScopedFD pipe_write_fd(&pipe_fds[1]);
 
   // Make sure kRelauncherSyncFD is a safe value. base::LaunchProcess will
   // preserve these three FDs in forked processes, so kRelauncherSyncFD should
   // not conflict with them.
   COMPILE_ASSERT(kRelauncherSyncFD != STDIN_FILENO &&
                  kRelauncherSyncFD != STDOUT_FILENO &&
                  kRelauncherSyncFD != STDERR_FILENO,
                  kRelauncherSyncFD_must_not_conflict_with_stdio_fds);
 
   base::FileHandleMappingVector fd_map;
-  fd_map.push_back(std::make_pair(pipe_write_fd.get(), kRelauncherSyncFD));
+  fd_map.push_back(std::make_pair(*pipe_write_fd, kRelauncherSyncFD));
 
   base::LaunchOptions options;
   options.fds_to_remap = &fd_map;
   if (!base::LaunchProcess(relaunch_args, options, NULL)) {
     LOG(ERROR) << "base::LaunchProcess failed";
     return false;
   }
 
   // The relauncher process is now starting up, or has started up. The
   // original parent process continues.
 
   pipe_write_fd.reset();  // close(pipe_fds[1]);
 
   // Synchronize with the relauncher process.
   char read_char;
-  int read_result = HANDLE_EINTR(read(pipe_read_fd.get(), &read_char, 1));
+  int read_result = HANDLE_EINTR(read(*pipe_read_fd, &read_char, 1));
   if (read_result != 1) {
     if (read_result < 0) {
       PLOG(ERROR) << "read";
     } else {
       LOG(ERROR) << "read: unexpected result " << read_result;
     }
     return false;
   }
 
   // Since a byte has been successfully read from the relauncher process, it's
   // guaranteed to have set up its kqueue monitoring this process for exit.
   // It's safe to exit now.
   return true;
 }
 
 namespace {
 
 // In the relauncher process, performs the necessary synchronization steps
 // with the parent by setting up a kqueue to watch for it to exit, writing a
 // byte to the pipe, and then waiting for the exit notification on the kqueue.
 // If anything fails, this logs a message and returns immediately. In those
 // situations, it can be assumed that something went wrong with the parent
 // process and the best recovery approach is to attempt relaunch anyway.
 void RelauncherSynchronizeWithParent() {
-  base::ScopedFD relauncher_sync_fd(kRelauncherSyncFD);
+  // file_util::ScopedFD needs something non-const to operate on.
+  int relauncher_sync_fd = kRelauncherSyncFD;
+  file_util::ScopedFD relauncher_sync_fd_closer(&relauncher_sync_fd);
 
   int parent_pid = getppid();
 
   // PID 1 identifies init. launchd, that is. launchd never starts the
   // relauncher process directly, having this parent_pid means that the parent
   // already exited and launchd "inherited" the relauncher as its child.
   // There's no reason to synchronize with launchd.
   if (parent_pid == 1) {
     LOG(ERROR) << "unexpected parent_pid";
     return;
   }
 
   // Set up a kqueue to monitor the parent process for exit.
-  base::ScopedFD kq(kqueue());
-  if (!kq.is_valid()) {
+  int kq = kqueue();
+  if (kq < 0) {
     PLOG(ERROR) << "kqueue";
     return;
   }
+  file_util::ScopedFD kq_closer(&kq);
 
   struct kevent change = { 0 };
   EV_SET(&change, parent_pid, EVFILT_PROC, EV_ADD, NOTE_EXIT, 0, NULL);
-  if (kevent(kq.get(), &change, 1, NULL, 0, NULL) == -1) {
+  if (kevent(kq, &change, 1, NULL, 0, NULL) == -1) {
     PLOG(ERROR) << "kevent (add)";
     return;
   }
 
   // Write a '\0' character to the pipe.
-  if (HANDLE_EINTR(write(relauncher_sync_fd.get(), "", 1)) != 1) {
+  if (HANDLE_EINTR(write(relauncher_sync_fd, "", 1)) != 1) {
     PLOG(ERROR) << "write";
     return;
   }
 
   // Up until now, the parent process was blocked in a read waiting for the
   // write above to complete. The parent process is now free to exit. Wait for
   // that to happen.
   struct kevent event;
-  int events = kevent(kq.get(), NULL, 0, &event, 1, NULL);
+  int events = kevent(kq, NULL, 0, &event, 1, NULL);
   if (events != 1) {
     if (events < 0) {
       PLOG(ERROR) << "kevent (monitor)";
     } else {
       LOG(ERROR) << "kevent (monitor): unexpected result " << events;
     }
     return;
   }
 
   if (event.filter != EVFILT_PROC ||
@@ skipping 133 matching lines @@
   if (!dmg_bsd_device_name.empty()) {
     EjectAndTrashDiskImage(dmg_bsd_device_name);
   }
 
   return 0;
 }
 
 }  // namespace internal
 
 }  // namespace mac_relauncher