Implement ScopedFD in terms of ScopedGeneric.

sandbox/linux/services/broker_process_unittest.cc

 // Copyright (c) 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 "sandbox/linux/services/broker_process.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <unistd.h>
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/file_util.h"
+#include "base/files/scoped_file.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/posix/eintr_wrapper.h"
 #include "sandbox/linux/tests/unit_tests.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-using file_util::ScopedFD;
-
 namespace sandbox {
 
 namespace {
 
 // Creates and open a temporary file on creation and closes
 // and removes it on destruction.
 // Unlike base/ helpers, this does not require JNI on Android.
 class ScopedTemporaryFile {
  public:
   ScopedTemporaryFile()
@@ skipping 227 matching lines @@
   std::vector<std::string> read_whitelist;
   read_whitelist.push_back(kFileCpuInfo);
 
   scoped_ptr<BrokerProcess> open_broker(new BrokerProcess(
       EPERM, read_whitelist, std::vector<std::string>(), fast_check_in_client));
   ASSERT_TRUE(open_broker->Init(base::Bind(&NoOpCallback)));
   pid_t broker_pid = open_broker->broker_pid();
 
   int fd = -1;
   fd = open_broker->Open(kFileCpuInfo, O_RDWR);
-  ScopedFD fd_closer(&fd);
+  base::ScopedFD fd_closer(fd);
   ASSERT_EQ(fd, -EPERM);
 
   // Check we can read /proc/cpuinfo.
   int can_access = open_broker->Access(kFileCpuInfo, R_OK);
   ASSERT_EQ(can_access, 0);
   can_access = open_broker->Access(kFileCpuInfo, W_OK);
   ASSERT_EQ(can_access, -EPERM);
   // Check we can not write /proc/cpuinfo.
 
   // Open cpuinfo via the broker.
   int cpuinfo_fd = open_broker->Open(kFileCpuInfo, O_RDONLY);
-  ScopedFD cpuinfo_fd_closer(&cpuinfo_fd);
+  base::ScopedFD cpuinfo_fd_closer(cpuinfo_fd);
   ASSERT_GE(cpuinfo_fd, 0);
   char buf[3];
   memset(buf, 0, sizeof(buf));
   int read_len1 = read(cpuinfo_fd, buf, sizeof(buf));
   ASSERT_GT(read_len1, 0);
 
   // Open cpuinfo directly.
   int cpuinfo_fd2 = open(kFileCpuInfo, O_RDONLY);
-  ScopedFD cpuinfo_fd2_closer(&cpuinfo_fd2);
+  base::ScopedFD cpuinfo_fd2_closer(cpuinfo_fd2);
   ASSERT_GE(cpuinfo_fd2, 0);
   char buf2[3];
   memset(buf2, 1, sizeof(buf2));
   int read_len2 = read(cpuinfo_fd2, buf2, sizeof(buf2));
   ASSERT_GT(read_len1, 0);
 
   // The following is not guaranteed true, but will be in practice.
   ASSERT_EQ(read_len1, read_len2);
   // Compare the cpuinfo as returned by the broker with the one we opened
   // ourselves.
@@ skipping 125 matching lines @@
   // expected.
 }
 
 TEST(BrokerProcess, OpenComplexFlagsNoClientCheck) {
   TestOpenComplexFlags(false /* fast_check_in_client */);
   // Don't do anything here, so that ASSERT works in the subfunction as
   // expected.
 }
 
 }  // namespace sandbox