gpu: Add GpuFence framework.

gpu/command_buffer/tests/gl_manager.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 "gpu/command_buffer/tests/gl_manager.h"
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
 #include <stddef.h>
@@ skipping 11 matching lines @@
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "gpu/command_buffer/client/gles2_lib.h"
 #include "gpu/command_buffer/client/shared_memory_limits.h"
 #include "gpu/command_buffer/client/transfer_buffer.h"
 #include "gpu/command_buffer/common/constants.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/common/sync_token.h"
 #include "gpu/command_buffer/service/command_buffer_service.h"
 #include "gpu/command_buffer/service/command_executor.h"
 #include "gpu/command_buffer/service/context_group.h"
+#include "gpu/command_buffer/service/fence_manager.h"
 #include "gpu/command_buffer/service/gl_context_virtual.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "gpu/command_buffer/service/image_manager.h"
 #include "gpu/command_buffer/service/mailbox_manager_impl.h"
 #include "gpu/command_buffer/service/memory_tracking.h"
 #include "gpu/command_buffer/service/service_utils.h"
 #include "gpu/command_buffer/service/sync_point_manager.h"
 #include "gpu/command_buffer/service/transfer_buffer_manager.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/buffer_format_util.h"
+#include "ui/gfx/gpu_fence.h"
 #include "ui/gfx/gpu_memory_buffer.h"
+#include "ui/gfx/shared_event.h"
 #include "ui/gl/gl_context.h"
+#include "ui/gl/gl_fence_shared_event.h"
 #include "ui/gl/gl_image_ref_counted_memory.h"
 #include "ui/gl/gl_share_group.h"
 #include "ui/gl/gl_surface.h"
 #include "ui/gl/init/gl_factory.h"
 
 #if defined(OS_MACOSX)
 #include "ui/gfx/mac/io_surface.h"
 #include "ui/gl/gl_image_io_surface.h"
 #endif
 
@@ skipping 108 matching lines @@
   IOSurfaceRef iosurface() { return iosurface_; }
 
  private:
   bool mapped_;
   IOSurfaceRef iosurface_;
   const gfx::Size size_;
   gfx::BufferFormat format_;
 };
 #endif  // defined(OS_MACOSX)
 
+class GpuFenceImpl : public gfx::GpuFence {
+ public:
+  GpuFenceImpl() {}
+  explicit GpuFenceImpl(const gfx::GpuFenceHandle& handle)
+      : shared_event_(handle.shared_event_handle) {}
+  ~GpuFenceImpl() override {}
+
+  static GpuFenceImpl* FromClientFence(ClientFence fence) {
+    return reinterpret_cast<GpuFenceImpl*>(fence);
+  }
+
+  // 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
 
 int GLManager::use_count_;
 scoped_refptr<gl::GLShareGroup>* GLManager::base_share_group_;
 scoped_refptr<gl::GLSurface>* GLManager::base_surface_;
 scoped_refptr<gl::GLContext>* GLManager::base_context_;
 
 GLManager::Options::Options()
     : size(4, 4),
       sync_point_manager(NULL),
@@ skipping 47 matching lines @@
     return base::WrapUnique<gfx::GpuMemoryBuffer>(
         new IOSurfaceGpuMemoryBuffer(size, format));
   }
 #endif  // defined(OS_MACOSX)
   std::vector<uint8_t> data(gfx::BufferSizeForBufferFormat(size, format), 0);
   scoped_refptr<base::RefCountedBytes> bytes(new base::RefCountedBytes(data));
   return base::WrapUnique<gfx::GpuMemoryBuffer>(
       new GpuMemoryBufferImpl(bytes.get(), size, format));
 }
 
+std::unique_ptr<gfx::GpuFence> GLManager::CreateGpuFence() {
+  return base::WrapUnique<gfx::GpuFence>(new GpuFenceImpl);
+}
+
 void GLManager::Initialize(const GLManager::Options& options) {
   InitializeWithCommandLine(options, *base::CommandLine::ForCurrentProcess());
 }
 
 void GLManager::InitializeWithCommandLine(
     const GLManager::Options& options,
     const base::CommandLine& command_line) {
   const int32_t kCommandBufferSize = 1024 * 1024;
   const size_t kStartTransferBufferSize = 4 * 1024 * 1024;
   const size_t kMinTransferBufferSize = 1 * 256 * 1024;
@@ skipping 385 matching lines @@
   }
 
   // Something went wrong, just run the callback now.
   callback.Run();
 }
 
 bool GLManager::CanWaitUnverifiedSyncToken(const gpu::SyncToken* sync_token) {
   return false;
 }
 
+int32_t GLManager::CreateFence(ClientFence fence) {
+  GpuFenceImpl* gpu_fence = GpuFenceImpl::FromClientFence(fence);
+
+  gfx::GpuFenceHandle handle = gpu_fence->GetHandle();
+  std::unique_ptr<gl::GLFenceSharedEvent> gl_fence(new gl::GLFenceSharedEvent(
+      gfx::SharedEvent::DuplicateHandle(handle.shared_event_handle)));
+
+  static int32_t next_id = 1;
+  int32_t new_id = next_id++;
+  gpu::gles2::FenceManager* fence_manager = decoder_->GetFenceManager();
+  DCHECK(fence_manager);
+  fence_manager->AddFence(std::move(gl_fence), new_id);
+  return new_id;
+}
+
+void GLManager::DestroyFence(int32_t id) {
+  gpu::gles2::FenceManager* fence_manager = decoder_->GetFenceManager();
+  DCHECK(fence_manager);
+  fence_manager->RemoveFence(id);
+}
+
 }  // namespace gpu