gpu: Add GpuFence framework.

gpu/ipc/service/gpu_command_buffer_stub.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/ipc/service/gpu_command_buffer_stub.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/hash.h"
 #include "base/json/json_writer.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/shared_memory.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "gpu/command_buffer/common/constants.h"
 #include "gpu/command_buffer/common/gpu_memory_buffer_support.h"
 #include "gpu/command_buffer/common/mailbox.h"
 #include "gpu/command_buffer/common/sync_token.h"
+#include "gpu/command_buffer/service/fence_manager.h"
 #include "gpu/command_buffer/service/gl_context_virtual.h"
 #include "gpu/command_buffer/service/gl_state_restorer_impl.h"
 #include "gpu/command_buffer/service/image_manager.h"
 #include "gpu/command_buffer/service/logger.h"
 #include "gpu/command_buffer/service/mailbox_manager.h"
 #include "gpu/command_buffer/service/memory_tracking.h"
 #include "gpu/command_buffer/service/query_manager.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 "gpu/ipc/common/gpu_messages.h"
 #include "gpu/ipc/service/gpu_channel.h"
 #include "gpu/ipc/service/gpu_channel_manager.h"
 #include "gpu/ipc/service/gpu_channel_manager_delegate.h"
 #include "gpu/ipc/service/gpu_memory_buffer_factory.h"
 #include "gpu/ipc/service/gpu_memory_manager.h"
 #include "gpu/ipc/service/gpu_memory_tracking.h"
 #include "gpu/ipc/service/gpu_watchdog_thread.h"
 #include "gpu/ipc/service/image_transport_surface.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_context.h"
+#include "ui/gl/gl_fence.h"
 #include "ui/gl/gl_image.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_switches.h"
 #include "ui/gl/init/gl_factory.h"
 
 #if defined(OS_WIN)
 #include "base/win/win_util.h"
 #endif
 
 #if defined(OS_ANDROID)
@@ skipping 195 matching lines @@
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_WaitSyncToken,
                         OnWaitSyncToken)
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_SignalSyncToken,
                         OnSignalSyncToken)
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_SignalQuery,
                         OnSignalQuery)
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_CreateImage, OnCreateImage);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_DestroyImage, OnDestroyImage);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_CreateStreamTexture,
                         OnCreateStreamTexture)
+    IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_CreateFence, OnCreateFence);
+    IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_DestroyFence, OnDestroyFence);
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   CheckCompleteWaits();
 
   // Ensure that any delayed work that was created will be handled.
   if (have_context) {
     if (executor_)
       executor_->ProcessPendingQueries();
     ScheduleDelayedWork(
@@ skipping 803 matching lines @@
   gles2::ImageManager* image_manager = decoder_->GetImageManager();
   DCHECK(image_manager);
   if (!image_manager->LookupImage(id)) {
     LOG(ERROR) << "Image with ID doesn't exist.";
     return;
   }
 
   image_manager->RemoveImage(id);
 }
 
+void GpuCommandBufferStub::OnCreateFence(
+    const GpuCommandBufferMsg_CreateFence_Params& params) {
+  TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnCreateFence");
+  const int32_t id = params.id;
+  const gfx::GpuFenceHandle& handle = params.gpu_fence;
+
+  if (!decoder_)
+    return;
+
+  gles2::FenceManager* fence_manager = decoder_->GetFenceManager();
+  DCHECK(fence_manager);
+  if (fence_manager->LookupFence(id)) {
+    LOG(ERROR) << "Fence already exists with same ID.";
+    return;
+  }
+
+  std::unique_ptr<gl::GLFence> fence =
+      channel()->CreateFenceForGpuFence(handle);
+  if (!fence) {
+    DLOG(ERROR) << "Failed to create GLFence from GpuFence handle.";
+    return;
+  }
+
+  fence_manager->AddFence(std::move(fence), id);
+}
+
+void GpuCommandBufferStub::OnDestroyFence(int32_t id) {
+  TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnDestroyFence");
+
+  if (!decoder_)
+    return;
+
+  gles2::FenceManager* fence_manager = decoder_->GetFenceManager();
+  DCHECK(fence_manager);
+  if (!fence_manager->LookupFence(id)) {
+    LOG(ERROR) << "Fence with ID doesn't exist.";
+    return;
+  }
+  fence_manager->RemoveFence(id);
+}
+
 void GpuCommandBufferStub::SendConsoleMessage(int32_t id,
                                               const std::string& message) {
   GPUCommandBufferConsoleMessage console_message;
   console_message.id = id;
   console_message.message = message;
   IPC::Message* msg = new GpuCommandBufferMsg_ConsoleMsg(
       route_id_, console_message);
   msg->set_unblock(true);
   Send(msg);
 }
@@ skipping 50 matching lines @@
       command_buffer_->GetLastState().error == error::kLostContext)
     return;
 
   command_buffer_->SetContextLostReason(error::kUnknown);
   if (decoder_)
     decoder_->MarkContextLost(error::kUnknown);
   command_buffer_->SetParseError(error::kLostContext);
 }
 
 }  // namespace gpu