Linux sandbox: add test to ensure that pread64 can be forwarded.

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/resource.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <unistd.h>
 
 #include <algorithm>
 #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 "base/posix/unix_domain_socket_linux.h"
+#include "sandbox/linux/tests/scoped_temporary_file.h"
 #include "sandbox/linux/tests/test_utils.h"
 #include "sandbox/linux/tests/unit_tests.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace sandbox {
 
 class BrokerProcessTestHelper {
  public:
   static int get_ipc_socketpair(const BrokerProcess* broker) {
     return broker->ipc_socketpair_;
   }
 };
 
 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()
-      : fd_(-1) {
-#if defined(OS_ANDROID)
-    static const char file_template[] = "/data/local/tmp/ScopedTempFileXXXXXX";
-#else
-    static const char file_template[] = "/tmp/ScopedTempFileXXXXXX";
-#endif  // defined(OS_ANDROID)
-    COMPILE_ASSERT(sizeof(full_file_name_) >= sizeof(file_template),
-                   full_file_name_is_large_enough);
-    memcpy(full_file_name_, file_template, sizeof(file_template));
-    fd_ = mkstemp(full_file_name_);
-    CHECK_LE(0, fd_);
-  }
-  ~ScopedTemporaryFile() {
-    CHECK_EQ(0, unlink(full_file_name_));
-    CHECK_EQ(0, IGNORE_EINTR(close(fd_)));
-  }
-
-  int fd() const { return fd_; }
-  const char* full_file_name() const { return full_file_name_; }
-
- private:
-  int fd_;
-  char full_file_name_[128];
-  DISALLOW_COPY_AND_ASSIGN(ScopedTemporaryFile);
-};
-
 bool NoOpCallback() { return true; }
 
 }  // namespace
 
 TEST(BrokerProcess, CreateAndDestroy) {
   std::vector<std::string> read_whitelist;
   read_whitelist.push_back("/proc/cpuinfo");
 
   scoped_ptr<BrokerProcess> open_broker(
       new BrokerProcess(EPERM, read_whitelist, std::vector<std::string>()));
@@ skipping 410 matching lines @@
     SANDBOX_ASSERT(
         UnixDomainSocket::SendMsg(ipc_fd, kBogus, sizeof(kBogus), fds));
   }
 
   const int fd = open_broker.Open(kCpuInfo, O_RDONLY);
   SANDBOX_ASSERT(fd >= 0);
   SANDBOX_ASSERT(0 == IGNORE_EINTR(close(fd)));
 }
 
 }  // namespace sandbox