gpu: Add GpuFence framework.

cc/test/test_gpu_memory_buffer_manager.cc

 // Copyright 2014 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 "cc/test/test_gpu_memory_buffer_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/numerics/safe_conversions.h"
 #include "ui/gfx/buffer_format_util.h"
 #include "ui/gfx/gpu_memory_buffer.h"
+#include "ui/gfx/shared_event.h"
 
 namespace cc {
 namespace {
 
 class GpuMemoryBufferImpl : public gfx::GpuMemoryBuffer {
  public:
   GpuMemoryBufferImpl(TestGpuMemoryBufferManager* manager,
                       int id,
                       const gfx::Size& size,
                       gfx::BufferFormat format,
@@ skipping 91 matching lines @@
   ClientBuffer AsClientBuffer() override {
     return client_buffer_->AsClientBuffer();
   }
 
  private:
   TestGpuMemoryBufferManager* manager_;
   gfx::GpuMemoryBufferId id_;
   gfx::GpuMemoryBuffer* client_buffer_;
 };
 
+class GpuFenceImpl : public gfx::GpuFence {
+ public:
+  GpuFenceImpl() {}
+  explicit GpuFenceImpl(const gfx::GpuFenceHandle& handle)
+      : shared_event_(handle.shared_event_handle) {}
+  ~GpuFenceImpl() override {}
+
+  // Overridden from gfx::GpuFence:
+  bool IsSignaled() override { return shared_event_.IsSignaled(); }
+  bool Wait(const base::TimeDelta& max_time) override {
+    return shared_event_.Wait(max_time);
+  }
+  void Reset() override { shared_event_.Reset(); }
+  gfx::GpuFenceHandle GetHandle() const override {
+    gfx::GpuFenceHandle handle;
+    handle.shared_event_handle = shared_event_.GetHandle();
+    return handle;
+  }
+  ClientFence AsClientFence() override {
+    return reinterpret_cast<ClientFence>(this);
+  }
+
+ private:
+  gfx::SharedEvent shared_event_;
+};
+
 }  // namespace
 
 TestGpuMemoryBufferManager::TestGpuMemoryBufferManager() {
 }
 
 TestGpuMemoryBufferManager::~TestGpuMemoryBufferManager() {
   DCHECK(buffers_.empty());
   DCHECK(clients_.empty());
   if (parent_gpu_memory_buffer_manager_)
     parent_gpu_memory_buffer_manager_->clients_.erase(client_id_);
@@ skipping 50 matching lines @@
       base::MakeUnique<base::SharedMemory>(handle.handle, false), handle.offset,
       handle.stride));
   buffers_[last_gpu_memory_buffer_id_] = result.get();
   return result;
 }
 
 void TestGpuMemoryBufferManager::SetDestructionSyncToken(
     gfx::GpuMemoryBuffer* buffer,
     const gpu::SyncToken& sync_token) {}
 
+std::unique_ptr<gfx::GpuFence> TestGpuMemoryBufferManager::CreateGpuFence() {
+  std::unique_ptr<gfx::GpuFence> result(new GpuFenceImpl);
+  return result;
+}
+
+std::unique_ptr<gfx::GpuFence>
+TestGpuMemoryBufferManager::CreateGpuFenceFromHandle(
+    const gfx::GpuFenceHandle& handle) {
+  std::unique_ptr<gfx::GpuFence> result(new GpuFenceImpl(handle));
+  return result;
+}
+
+gfx::GpuFence* TestGpuMemoryBufferManager::GpuFenceFromClientFence(
+    ClientFence fence) {
+  return reinterpret_cast<gfx::GpuFence*>(fence);
+}
+
 }  // namespace cc