Implement ScopedFD in terms of ScopedGeneric.

base/process/kill_mac.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 "base/process/kill.h"
 
 #include <signal.h>
 #include <sys/event.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 
 #include "base/file_util.h"
+#include "base/files/scoped_file.h"
 #include "base/logging.h"
 #include "base/posix/eintr_wrapper.h"
 
 namespace base {
 
 namespace {
 
 const int kWaitBeforeKillSeconds = 2;
 
 // Reap |child| process. This call blocks until completion.
@@ skipping 46 matching lines @@
   DCHECK(timeout > 0);
 
   // DON'T ADD ANY EARLY RETURNS TO THIS FUNCTION without ensuring that
   // |child| has been reaped. Specifically, even if a kqueue, kevent, or other
   // call fails, this function should fall back to the last resort of trying
   // to kill and reap the process. Not observing this rule will resurrect
   // zombies.
 
   int result;
 
-  int kq = HANDLE_EINTR(kqueue());
-  if (kq == -1) {
+  ScopedFD kq(HANDLE_EINTR(kqueue()));
+  if (!kq.is_valid()) {
     DPLOG(ERROR) << "kqueue()";
   } else {
-    file_util::ScopedFD auto_close_kq(&kq);
-
     struct kevent change = {0};
     EV_SET(&change, child, EVFILT_PROC, EV_ADD, NOTE_EXIT, 0, NULL);
-    result = HANDLE_EINTR(kevent(kq, &change, 1, NULL, 0, NULL));
+    result = HANDLE_EINTR(kevent(kq.get(), &change, 1, NULL, 0, NULL));
 
     if (result == -1) {
       if (errno != ESRCH) {
         DPLOG(ERROR) << "kevent (setup " << child << ")";
       } else {
         // At this point, one of the following has occurred:
         // 1. The process has died but has not yet been reaped.
         // 2. The process has died and has already been reaped.
         // 3. The process is in the process of dying. It's no longer
         //    kqueueable, but it may not be waitable yet either. Mark calls
@@ skipping 15 matching lines @@
       }
     } else {
       // Keep track of the elapsed time to be able to restart kevent if it's
       // interrupted.
       TimeDelta remaining_delta = TimeDelta::FromSeconds(timeout);
       TimeTicks deadline = TimeTicks::Now() + remaining_delta;
       result = -1;
       struct kevent event = {0};
       while (remaining_delta.InMilliseconds() > 0) {
         const struct timespec remaining_timespec = remaining_delta.ToTimeSpec();
-        result = kevent(kq, NULL, 0, &event, 1, &remaining_timespec);
+        result = kevent(kq.get(), NULL, 0, &event, 1, &remaining_timespec);
         if (result == -1 && errno == EINTR) {
           remaining_delta = deadline - TimeTicks::Now();
           result = 0;
         } else {
           break;
         }
       }
 
       if (result == -1) {
         DPLOG(ERROR) << "kevent (wait " << child << ")";
@@ skipping 30 matching lines @@
   }
 }
 
 }  // namespace
 
 void EnsureProcessTerminated(ProcessHandle process) {
   WaitForChildToDie(process, kWaitBeforeKillSeconds);
 }
 
 }  // namespace base