Revert of Implement ScopedFD in terms of ScopedGeneric.

tools/android/memdump/memdump.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 <fcntl.h>
 #include <signal.h>
 #include <sys/types.h>
 #include <unistd.h>
 
 #include <algorithm>
 #include <cstring>
 #include <fstream>
 #include <iostream>
 #include <limits>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/base64.h"
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/containers/hash_tables.h"
 #include "base/file_util.h"
-#include "base/files/scoped_file.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
 
 const unsigned int kPageSize = getpagesize();
 
 namespace {
 
 class BitSet {
@@ skipping 394 matching lines @@
           memory_map.committed_pages_bits.AsB64String().c_str());
       std::cout << buf;
     }
   }
 }
 
 bool CollectProcessMemoryInformation(int page_count_fd,
                                      int page_flags_fd,
                                      ProcessMemory* process_memory) {
   const pid_t pid = process_memory->pid;
-  base::ScopedFD pagemap_fd(open(
-      base::StringPrintf("/proc/%d/pagemap", pid).c_str(), O_RDONLY));
-  if (!pagemap_fd.is_valid()) {
+  int pagemap_fd = open(
+      base::StringPrintf("/proc/%d/pagemap", pid).c_str(), O_RDONLY);
+  if (pagemap_fd < 0) {
     PLOG(ERROR) << "open";
     return false;
   }
+  file_util::ScopedFD auto_closer(&pagemap_fd);
   std::vector<MemoryMap>* const process_maps = &process_memory->memory_maps;
   if (!GetProcessMaps(pid, process_maps))
     return false;
   for (std::vector<MemoryMap>::iterator it = process_maps->begin();
        it != process_maps->end(); ++it) {
     std::vector<PageInfo>* const committed_pages = &it->committed_pages;
     BitSet* const pages_bits = &it->committed_pages_bits;
-    GetPagesForMemoryMap(pagemap_fd.get(), *it, committed_pages, pages_bits);
+    GetPagesForMemoryMap(pagemap_fd, *it, committed_pages, pages_bits);
     SetPagesInfo(page_count_fd, page_flags_fd, committed_pages);
   }
   return true;
 }
 
 void KillAll(const std::vector<pid_t>& pids, int signal_number) {
   for (std::vector<pid_t>::const_iterator it = pids.begin(); it != pids.end();
        ++it) {
     kill(*it, signal_number);
   }
@@ skipping 18 matching lines @@
   std::vector<pid_t> pids;
   for (const char* const* ptr = argv + 1; *ptr; ++ptr) {
     pid_t pid;
     if (!base::StringToInt(*ptr, &pid))
       return EXIT_FAILURE;
     pids.push_back(pid);
   }
 
   std::vector<ProcessMemory> processes_memory(pids.size());
   {
-    base::ScopedFD page_count_fd(open("/proc/kpagecount", O_RDONLY));
-    if (!page_count_fd.is_valid()) {
+    int page_count_fd = open("/proc/kpagecount", O_RDONLY);
+    if (page_count_fd < 0) {
       PLOG(ERROR) << "open /proc/kpagecount";
       return EXIT_FAILURE;
     }
 
-    base::ScopedFD page_flags_fd(open("/proc/kpageflags", O_RDONLY));
-    if (!page_flags_fd.is_valid()) {
+    int page_flags_fd = open("/proc/kpageflags", O_RDONLY);
+    if (page_flags_fd < 0) {
       PLOG(ERROR) << "open /proc/kpageflags";
       return EXIT_FAILURE;
     }
 
+    file_util::ScopedFD page_count_fd_closer(&page_count_fd);
+    file_util::ScopedFD page_flags_fd_closer(&page_flags_fd);
+
     base::ScopedClosureRunner auto_resume_processes(
         base::Bind(&KillAll, pids, SIGCONT));
     KillAll(pids, SIGSTOP);
     for (std::vector<pid_t>::const_iterator it = pids.begin(); it != pids.end();
          ++it) {
       ProcessMemory* const process_memory =
           &processes_memory[it - pids.begin()];
       process_memory->pid = *it;
       if (!CollectProcessMemoryInformation(
-              page_count_fd.get(), page_flags_fd.get(), process_memory)) {
+              page_count_fd, page_flags_fd, process_memory)) {
         return EXIT_FAILURE;
       }
     }
   }
 
   ClassifyPages(&processes_memory);
   if (short_output)
     DumpProcessesMemoryMapsInShortFormat(processes_memory);
   else
     DumpProcessesMemoryMapsInExtendedFormat(processes_memory);
   return EXIT_SUCCESS;
 }