Introduce base::ScopedPlatformHandle

base/files/scoped_platform_handle_unittest.cc

Index: base/files/scoped_platform_handle_unittest.cc
diff --git a/base/files/scoped_platform_handle_unittest.cc b/base/files/scoped_platform_handle_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..f212f35374f6fd3d3d69f6a6d456e8f20f64f4cc
--- /dev/null
+++ b/base/files/scoped_platform_handle_unittest.cc
@@ -0,0 +1,200 @@
+// Copyright 2017 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/files/scoped_platform_handle.h"
+#include "base/files/file.h"
+#include "base/files/scoped_temp_dir.h"
+#include "base/macros.h"
+#include "base/strings/stringprintf.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+#if defined(OS_WIN)
+#include <windows.h>
+
+#include "base/win/scoped_handle.h"
+#elif defined(OS_POSIX)
+#include "base/files/scoped_file.h"
+#endif
+
+#if defined(OS_MACOSX) && !defined(OS_IOS)
+#include <mach/mach.h>
+
+#include "base/mac/scoped_mach_port.h"
+#endif  // defined(OS_MACOSX) && !defined(OS_IOS)
+
+namespace base {
+namespace {
+
+class ScopedPlatformHandleTest : public testing::Test {
+ public:
+  ScopedPlatformHandleTest() { CHECK(temp_dir_.CreateUniqueTempDir()); }
+
+ protected:
+#if defined(OS_WIN)
+  win::ScopedHandle CreateValidWindowsHandle() {
+    return win::ScopedHandle(OpenTempFile().TakePlatformFile());
+  }
+#elif defined(OS_POSIX)
+  ScopedFD CreateValidFileDescriptor() {
+    return ScopedFD(OpenTempFile().TakePlatformFile());
+  }
+#endif
+
+#if defined(OS_MACOSX) && !defined(OS_IOS)
+  void CreateValidMachPort(mac::ScopedMachReceiveRight* receive,
+                           mac::ScopedMachSendRight* send) {
+    mach_port_t port;
+    kern_return_t error =
+        mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &port);
+    CHECK_EQ(error, KERN_SUCCESS);
+
+    error = mach_port_insert_right(mach_task_self(), port, port,
+                                   MACH_MSG_TYPE_MAKE_SEND);
+    CHECK_EQ(error, KERN_SUCCESS);
+
+    receive->reset(port);
+    send->reset(port);
+  }
+#endif  // defined(OS_MACOSX) && !defined(OS_IOS)
+
+ private:
+  base::File OpenTempFile() {
+    base::File temp_file(temp_dir_.GetPath().AppendASCII(
+                             base::StringPrintf("file_%d", next_file_id_)),
+                         base::File::FLAG_CREATE | base::File::FLAG_WRITE);
+    ++next_file_id_;
+    return temp_file;
+  }
+
+  ScopedTempDir temp_dir_;
+  int next_file_id_ = 1;
+
+  DISALLOW_COPY_AND_ASSIGN(ScopedPlatformHandleTest);
+};
+
+TEST_F(ScopedPlatformHandleTest, Invalid) {
+  ScopedPlatformHandle default_value;
+  EXPECT_TRUE(!default_value.is_valid());
+
+  ScopedPlatformHandle null_value(nullptr);
+  EXPECT_TRUE(!null_value.is_valid());
+
+  default_value.reset();
+  null_value.reset();
+  EXPECT_TRUE(!default_value.is_valid());
+  EXPECT_TRUE(!null_value.is_valid());
+}
+
+#if defined(OS_WIN)
+
+TEST_F(ScopedPlatformHandleTest, WindowsHandles) {
+  win::ScopedHandle scoped_handle = CreateValidWindowsHandle();
+  HANDLE raw_handle = CreateValidWindowsHandle().Take();
+
+  ScopedPlatformHandle handle_a(std::move(scoped_handle));
+  ScopedPlatformHandle handle_b(raw_handle);
+
+  EXPECT_TRUE(handle_a.is_valid());
+  EXPECT_EQ(ScopedPlatformHandle::Type::WINDOWS_HANDLE, handle_a.type());
+  EXPECT_TRUE(handle_b.is_valid());
+  EXPECT_EQ(ScopedPlatformHandle::Type::WINDOWS_HANDLE, handle_b.type());
+
+  HANDLE h;
+  ASSERT_TRUE(handle_b.GetAsWindowsHandle(&h));
+  EXPECT_EQ(raw_handle, h);
+
+  ASSERT_TRUE(handle_b.TakeWindowsHandle(&scoped_handle));
+  EXPECT_FALSE(handle_b.is_valid());
+  EXPECT_EQ(ScopedPlatformHandle::Type::INVALID, handle_b.type());
+  EXPECT_TRUE(scoped_handle.IsValid());
+
+  EXPECT_EQ(scoped_handle.Get(), raw_handle);
+  EXPECT_FALSE(handle_b.GetAsWindowsHandle(&h));
+  EXPECT_FALSE(handle_b.ReleaseAsWindowsHandle(&h));
+
+  handle_b = ScopedPlatformHandle(std::move(scoped_handle));
+  EXPECT_EQ(ScopedPlatformHandle::Type::WINDOWS_HANDLE, handle_b.type());
+  EXPECT_TRUE(handle_b.ReleaseAsWindowsHandle(&h));
+  EXPECT_FALSE(handle_b.is_valid());
+  EXPECT_EQ(ScopedPlatformHandle::Type::INVALID, handle_b.type());
+
+  handle_b = ScopedPlatformHandle(h);
+  handle_a = std::move(handle_b);
+  EXPECT_FALSE(handle_b.is_valid());
+  EXPECT_EQ(ScopedPlatformHandle::Type::INVALID, handle_b.type());
+
+  EXPECT_TRUE(handle_a.is_valid());
+  EXPECT_EQ(ScopedPlatformHandle::Type::WINDOWS_HANDLE, handle_a.type());
+
+  HANDLE h2;
+  EXPECT_TRUE(handle_a.GetAsWindowsHandle(&h2));
+  EXPECT_EQ(h, h2);
+
+  handle_a = nullptr;
+  EXPECT_EQ(ScopedPlatformHandle::Type::INVALID, handle_a.type());
+  EXPECT_FALSE(handle_a.is_valid());
+}
+
+#elif defined(OS_POSIX)
+
+TEST_F(ScopedPlatformHandleTest, FileDescriptors) {
+  ScopedFD scoped_fd = CreateValidFileDescriptor();
+  int raw_fd = CreateValidFileDescriptor().release();
+
+  ScopedPlatformHandle fd_a(std::move(scoped_fd));
+  ScopedPlatformHandle fd_b(raw_fd);
+
+  EXPECT_TRUE(fd_a.is_valid());
+  EXPECT_EQ(ScopedPlatformHandle::Type::FILE_DESCRIPTOR, fd_a.type());
+  EXPECT_TRUE(fd_b.is_valid());
+  EXPECT_EQ(ScopedPlatformHandle::Type::FILE_DESCRIPTOR, fd_b.type());
+
+  int fd;
+  ASSERT_TRUE(fd_b.GetAsFileDescriptor(&fd));
+  EXPECT_EQ(raw_fd, fd);
+
+  ASSERT_TRUE(fd_b.TakeFileDescriptor(&scoped_fd));
+  EXPECT_FALSE(fd_b.is_valid());
+  EXPECT_EQ(ScopedPlatformHandle::Type::INVALID, fd_b.type());
+  EXPECT_TRUE(scoped_fd.is_valid());
+
+  EXPECT_EQ(scoped_fd.get(), raw_fd);
+  EXPECT_FALSE(fd_b.GetAsFileDescriptor(&fd));
+  EXPECT_FALSE(fd_b.ReleaseAsFileDescriptor(&fd));
+
+  fd_b = ScopedPlatformHandle(std::move(scoped_fd));
+  EXPECT_EQ(ScopedPlatformHandle::Type::FILE_DESCRIPTOR, fd_b.type());
+  EXPECT_TRUE(fd_b.ReleaseAsFileDescriptor(&fd));
+  EXPECT_FALSE(fd_b.is_valid());
+  EXPECT_EQ(ScopedPlatformHandle::Type::INVALID, fd_b.type());
+
+  fd_b = ScopedPlatformHandle(fd);
+  fd_a = std::move(fd_b);
+  EXPECT_FALSE(fd_b.is_valid());
+  EXPECT_EQ(ScopedPlatformHandle::Type::INVALID, fd_b.type());
+
+  EXPECT_TRUE(fd_a.is_valid());
+  EXPECT_EQ(ScopedPlatformHandle::Type::FILE_DESCRIPTOR, fd_a.type());
+
+  int fd2;
+  EXPECT_TRUE(fd_a.GetAsFileDescriptor(&fd2));
+  EXPECT_EQ(fd, fd2);
+
+  fd_a = nullptr;
+  EXPECT_EQ(ScopedPlatformHandle::Type::INVALID, fd_a.type());
+  EXPECT_FALSE(fd_a.is_valid());
+}
+
+#endif  // defined(OS_WIN)
+
+#if defined(OS_MACOSX) && !defined(OS_IOS)
+
+TEST_F(ScopedPlatformHandleTest, MachPorts) {
+  // TODO
+}
+
+#endif  // defined(OS_MACOSX) && !defined(OS_IOS)
+
+}  // namespace
+}  // namespace base