gpu: Add GpuFence framework.

ui/gfx/shared_event_unittest.cc

Index: ui/gfx/shared_event_unittest.cc
diff --git a/ui/gfx/shared_event_unittest.cc b/ui/gfx/shared_event_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..4583ce879f9f1e6d1ed218aa07ab237ed4078f3b
--- /dev/null
+++ b/ui/gfx/shared_event_unittest.cc
@@ -0,0 +1,113 @@
+// Copyright 2016 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 "ui/gfx/shared_event.h"
+
+#include "base/threading/platform_thread.h"
+#include "base/time/time.h"
+#include "build/build_config.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace gfx {
+
+TEST(SharedEventTest, Basics) {
+  SharedEvent event1;
+  SharedEvent event2(SharedEvent::DuplicateHandle(event1.GetHandle()));
+
+  EXPECT_FALSE(event1.IsSignaled());
+  EXPECT_FALSE(event2.IsSignaled());
+
+  event1.Signal();
+  EXPECT_TRUE(event1.IsSignaled());
+  EXPECT_TRUE(event2.IsSignaled());
+
+  event1.Reset();
+  EXPECT_FALSE(event1.IsSignaled());
+  EXPECT_FALSE(event2.IsSignaled());
+  EXPECT_FALSE(event1.Wait(base::TimeDelta::FromMilliseconds(10)));
+  EXPECT_FALSE(event2.Wait(base::TimeDelta::FromMilliseconds(10)));
+
+  event2.Signal();
+  EXPECT_TRUE(event1.Wait(base::TimeDelta::FromMilliseconds(10)));
+  EXPECT_TRUE(event2.Wait(base::TimeDelta::FromMilliseconds(10)));
+}
+
+class SharedEventSignaler : public base::PlatformThread::Delegate {
+ public:
+  SharedEventSignaler(base::TimeDelta delay, const SharedEventHandle& handle)
+      : delay_(delay), event_(handle) {}
+
+  void ThreadMain() override {
+    base::PlatformThread::Sleep(delay_);
+    event_.Signal();
+  }
+
+ private:
+  const base::TimeDelta delay_;
+  SharedEvent event_;
+};
+
+TEST(SharedEventTest, WaitAndReset) {
+  SharedEvent event;
+
+  SharedEventSignaler signaler(base::TimeDelta::FromMilliseconds(10),
+                               SharedEvent::DuplicateHandle(event.GetHandle()));
+  base::PlatformThreadHandle thread;
+  base::PlatformThread::Create(0, &signaler, &thread);
+
+  base::TimeTicks now = base::TimeTicks::Now();
+  base::TimeTicks end = now + base::TimeDelta::FromSeconds(5);
+  while (now < end) {
+    if (event.Wait(end - now))
+      break;
+    now = base::TimeTicks::Now();
+  }
+
+  EXPECT_TRUE(event.IsSignaled());
+  event.Reset();
+  EXPECT_FALSE(event.IsSignaled());
+  event.Signal();
+  EXPECT_TRUE(event.Wait(base::TimeDelta::FromMilliseconds(10)));
+
+  base::PlatformThread::Join(thread);
+}
+
+class SharedEventWaiter : public base::PlatformThread::Delegate {
+ public:
+  SharedEventWaiter(base::TimeDelta max_time, const SharedEventHandle& handle)
+      : until_(base::TimeTicks::Now() + max_time), event_(handle) {}
+
+  void ThreadMain() override {
+    base::TimeTicks now = base::TimeTicks::Now();
+    while (now < until_) {
+      if (event_.Wait(until_ - now))
+        break;
+      now = base::TimeTicks::Now();
+    }
+    EXPECT_TRUE(event_.IsSignaled());
+  }
+
+ private:
+  const base::TimeTicks until_;
+  SharedEvent event_;
+};
+
+// Tests that a SharedEvent can be safely be deleted before having been
+// signaled.
+TEST(SharedEventTest, SignalAndDelete) {
+  std::unique_ptr<SharedEvent> event(new SharedEvent);
+
+  SharedEventWaiter waiter(base::TimeDelta::FromSeconds(5),
+                           SharedEvent::DuplicateHandle(event->GetHandle()));
+  base::PlatformThreadHandle thread;
+  base::PlatformThread::Create(0, &waiter, &thread);
+
+  EXPECT_FALSE(event->IsSignaled());
+  event->Signal();
+  event.reset();
+
+  base::PlatformThread::Join(thread);
+}
+
+}  // namespace gfx