exo: Fix CreateLinuxFence test.

components/exo/display_unittest.cc

 // Copyright 2015 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 "ash/public/cpp/shell_window_ids.h"
 #include "components/exo/buffer.h"
 #include "components/exo/display.h"
 #include "components/exo/shared_memory.h"
 #include "components/exo/shell_surface.h"
 #include "components/exo/sub_surface.h"
 #include "components/exo/surface.h"
 #include "components/exo/test/exo_test_base.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+#if defined(OS_LINUX)
+#include "third_party/libsync/include/sw_sync.h"
+#include "ui/gfx/gpu_fence.h"
+#endif
+
 #if defined(USE_OZONE)
 #include "ui/ozone/public/native_pixmap.h"
 #include "ui/ozone/public/ozone_platform.h"
 #include "ui/ozone/public/surface_factory_ozone.h"
 #endif
 
 namespace exo {
 namespace {
 
 using DisplayTest = test::ExoTestBase;
@@ skipping 54 matching lines @@
 
   std::vector<base::ScopedFD> invalid_fds;
   invalid_fds.push_back(base::ScopedFD());
   // Creating a prime buffer using an invalid fd should fail.
   std::unique_ptr<Buffer> buffer2 = display->CreateLinuxDMABufBuffer(
       buffer_size, gfx::BufferFormat::RGBA_8888, planes,
       std::move(invalid_fds));
   EXPECT_FALSE(buffer2);
 }
 
-TEST_F(DisplayTest, CreateLinuxFence) {
-  int sockets_unscoped[2];
-
-  ASSERT_EQ(0, socketpair(AF_UNIX, SOCK_STREAM, 0, fds));
-
-  // Emulate the behaviour of a fence FD (returns POLLIN when signaled) using
-  // a socket pair.
-  Base::ScopedFD socket_waitee(sockets_unscoped[0]);
-
-  std::unique_ptr<gfx::GpuFence> fence1 =
-      display->CreateLinuxFence(sockets_unscoped[1]);
-  ASSERT_TRUE(fence1);
-  close(sockets_unscoped[1]);
-
-  // The fence must be unsignaled when we start.
-  EXPECT_FALSE(fence1->Wait(TimeDelta::FromMilliseconds(50)));
-
-  // Unblock the fence, and make sure this signals success.
-  uint32_t dummy = 1;
-  ASSERT_EQ(sizeof(dummy), UnixDomainSocket::SendMsg(socket_waitee, &dummy,
-                                                     sizeof(dummy), nullptr));
-
-  EXPECT_TRUE(fence1->Wait(TimeDelta::FromMilliseconds(50)));
-
-  // Check that invalid file descriptors are rejected.
-  std::unique_ptr<gfx::GpuFence> fence2 = display->CreateLinuxFence(-1);
-  EXPECT_FALSE(fence2);
-}
-
 // TODO(dcastagna): Add YV12 unittest once we can allocate the buffer
 // via Ozone. crbug.com/618516
+#endif  // defined(USE_OZONE)
 
-#endif
+#if defined(OS_LINUX)
+TEST_F(DisplayTest, CreateLinuxFence) {
+  std::unique_ptr<Display> display(new Display);
+
+  // Skip test if sw sync device doesn't exist.
+  if (!base::PathExists(base::FilePath(FILE_PATH_LITERAL("/dev/sw_sync"))))
+    return;
+
+  // Initial position for timeline is 0.
+  base::ScopedFD timeline_fd(sw_sync_timeline_create());
+  ASSERT_TRUE(timeline_fd.is_valid());
+
+  int sync_point = 1;
+  // Create a fence for |sync_point|.
+  base::ScopedFD fence_fd(
+      sw_sync_fence_create(timeline_fd.get(), "cr-test-fence", sync_point));
+
+  std::unique_ptr<gfx::GpuFence> fence1 =
+      display->CreateLinuxFence(std::move(fence_fd));
+  ASSERT_TRUE(fence1);
+
+  // The fence must be unsignaled when we start.
+  EXPECT_FALSE(fence1->IsSignaled());
+
+  // Increment timeline to 1 to signal fence.
+  int rv = sw_sync_timeline_inc(timeline_fd.get(), 1);
+  EXPECT_EQ(0, rv);
+
+  EXPECT_TRUE(fence1->Wait(base::TimeDelta::FromMilliseconds(50)));
+
+  base::ScopedFD invalid_fd;
+  // Check that invalid file descriptors are rejected.
+  std::unique_ptr<gfx::GpuFence> fence2 =
+      display->CreateLinuxFence(std::move(invalid_fd));
+  EXPECT_FALSE(fence2);
+}
+#endif  // defined(OS_LINUX)
 
 TEST_F(DisplayTest, CreateShellSurface) {
   std::unique_ptr<Display> display(new Display);
 
   // Create two surfaces.
   std::unique_ptr<Surface> surface1 = display->CreateSurface();
   ASSERT_TRUE(surface1);
   std::unique_ptr<Surface> surface2 = display->CreateSurface();
   ASSERT_TRUE(surface2);
 
@@ skipping 114 matching lines @@
   // Attempting to create a sub surface for parent with grandchild as its parent
   // should fail.
   EXPECT_FALSE(display->CreateSubSurface(parent.get(), grandchild.get()));
 
   // Create a sub surface for parent.
   EXPECT_TRUE(display->CreateSubSurface(parent.get(), toplevel.get()));
 }
 
 }  // namespace
 }  // namespace exo