gpu: Add GpuFence framework.

gpu/ipc/client/command_buffer_proxy_impl.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/client/command_buffer_proxy_impl.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/callback.h"
@@ skipping 646 matching lines @@
   // catches upwith the command buffer.
   // A malicious caller trying to create a collision by making next_signal_id
   // would have to make calls at an astounding rate (300B/s) and even if they
   // could do that, all they would do is to prevent some callbacks from getting
   // called, leading to stalled threads and/or memory leaks.
   uint32_t signal_id = next_signal_id_++;
   Send(new GpuCommandBufferMsg_SignalQuery(route_id_, query, signal_id));
   signal_tasks_.insert(std::make_pair(signal_id, callback));
 }
 
+int32_t CommandBufferProxyImpl::CreateFence(ClientFence fence) {
+  CheckLock();
+  if (last_state_.error != gpu::error::kNoError)
+    return -1;
+
+  int32_t new_id = channel_->ReserveFenceId();
+
+  gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager =
+      channel_->gpu_memory_buffer_manager();
+  gfx::GpuFence* gpu_fence =
+      gpu_memory_buffer_manager->GpuFenceFromClientFence(fence);
+  DCHECK(gpu_fence);
+
+  // This handle is owned by the GPU process and must be passed to it or it
+  // will leak. In otherwords, do not early out on error between here and the
+  // sending of the CreateFence IPC below.
+  gfx::GpuFenceHandle handle =
+      channel_->ShareGpuFenceToGpuProcess(gpu_fence->GetHandle());
+
+  GpuCommandBufferMsg_CreateFence_Params params;
+  params.id = new_id;
+  params.gpu_fence = handle;
+
+  Send(new GpuCommandBufferMsg_CreateFence(route_id_, params));
+
+  return new_id;
+}
+
+void CommandBufferProxyImpl::DestroyFence(int32_t id) {
+  CheckLock();
+  if (last_state_.error != gpu::error::kNoError)
+    return;
+
+  Send(new GpuCommandBufferMsg_DestroyFence(route_id_, id));
+}
+
 void CommandBufferProxyImpl::TakeFrontBuffer(const gpu::Mailbox& mailbox) {
   CheckLock();
   if (last_state_.error != gpu::error::kNoError)
     return;
 
   Send(new GpuCommandBufferMsg_TakeFrontBuffer(route_id_, mailbox));
 }
 
 void CommandBufferProxyImpl::ReturnFrontBuffer(const gpu::Mailbox& mailbox,
                                                const gpu::SyncToken& sync_token,
@@ skipping 189 matching lines @@
     return;
   channel_->FlushPendingStream(stream_id_);
   channel_->Send(new GpuChannelMsg_DestroyCommandBuffer(route_id_));
   channel_->RemoveRoute(route_id_);
   channel_ = nullptr;
   if (gpu_control_client_)
     gpu_control_client_->OnGpuControlLostContext();
 }
 
 }  // namespace gpu