Implemented new fence syncs which replaces the old sync points.

ppapi/proxy/ppapi_command_buffer_proxy.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 "ppapi/proxy/ppapi_command_buffer_proxy.h"
 
 #include "base/numerics/safe_conversions.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/shared_impl/api_id.h"
 #include "ppapi/shared_impl/host_resource.h"
 #include "ppapi/shared_impl/proxy_lock.h"
 
 namespace ppapi {
 namespace proxy {
 
 PpapiCommandBufferProxy::PpapiCommandBufferProxy(
     const ppapi::HostResource& resource,
     PluginDispatcher* dispatcher,
     const gpu::Capabilities& capabilities,
     const SerializedHandle& shared_state,
     uint64_t command_buffer_id)
     : command_buffer_id_(command_buffer_id),
       capabilities_(capabilities),
       resource_(resource),
-      dispatcher_(dispatcher) {
+      dispatcher_(dispatcher),
+      next_fence_sync_release_(1),
+      pending_fence_sync_release_(0),
+      flushed_fence_sync_release_(0) {
   shared_state_shm_.reset(
       new base::SharedMemory(shared_state.shmem(), false));
   shared_state_shm_->Map(shared_state.size());
   InstanceData* data = dispatcher->GetInstanceData(resource.instance());
   flush_info_ = &data->flush_info_;
 }
 
 PpapiCommandBufferProxy::~PpapiCommandBufferProxy() {
   // gpu::Buffers are no longer referenced, allowing shared memory objects to be
   // deleted, closing the handle in this process.
@@ skipping 19 matching lines @@
     return;
 
   OrderingBarrier(put_offset);
   FlushInternal();
 }
 
 void PpapiCommandBufferProxy::OrderingBarrier(int32 put_offset) {
   if (last_state_.error != gpu::error::kNoError)
     return;
 
-  if (flush_info_->flush_pending && flush_info_->resource != resource_)
+  if (flush_info_->flush_pending && flush_info_->resource != resource_) {
     FlushInternal();
+  }
 
   flush_info_->flush_pending = true;
   flush_info_->resource = resource_;
   flush_info_->put_offset = put_offset;
+  pending_fence_sync_release_ = next_fence_sync_release_ - 1;
 }
 
 void PpapiCommandBufferProxy::WaitForTokenInRange(int32 start, int32 end) {
   TryUpdateState();
   if (!InRange(start, end, last_state_.token) &&
       last_state_.error == gpu::error::kNoError) {
     bool success = false;
     gpu::CommandBuffer::State state;
     if (Send(new PpapiHostMsg_PPBGraphics3D_WaitForTokenInRange(
              ppapi::API_ID_PPB_GRAPHICS_3D,
@@ skipping 99 matching lines @@
 }
 
 gpu::CommandBufferNamespace PpapiCommandBufferProxy::GetNamespaceID() const {
   return gpu::CommandBufferNamespace::GPU_IO;
 }
 
 uint64_t PpapiCommandBufferProxy::GetCommandBufferID() const {
   return command_buffer_id_;
 }
 
+uint64_t PpapiCommandBufferProxy::GenerateFenceSyncRelease() {
+  return next_fence_sync_release_++;
+}
+
+bool PpapiCommandBufferProxy::IsFenceSyncRelease(uint64_t release) {
+  return release != 0 && release < next_fence_sync_release_;
+}
+
+bool PpapiCommandBufferProxy::IsFenceSyncFlushed(uint64_t release) {
+  return release <= flushed_fence_sync_release_;
+}
+
 uint32 PpapiCommandBufferProxy::InsertSyncPoint() {
   uint32 sync_point = 0;
   if (last_state_.error == gpu::error::kNoError) {
     Send(new PpapiHostMsg_PPBGraphics3D_InsertSyncPoint(
          ppapi::API_ID_PPB_GRAPHICS_3D, resource_, &sync_point));
   }
   return sync_point;
 }
 
 uint32 PpapiCommandBufferProxy::InsertFutureSyncPoint() {
@@ skipping 87 matching lines @@
 
 gpu::CommandBufferSharedState* PpapiCommandBufferProxy::shared_state() const {
   return reinterpret_cast<gpu::CommandBufferSharedState*>(
       shared_state_shm_->memory());
 }
 
 void PpapiCommandBufferProxy::FlushInternal() {
   DCHECK(last_state_.error == gpu::error::kNoError);
 
   DCHECK(flush_info_->flush_pending);
+  DCHECK_GE(pending_fence_sync_release_, flushed_fence_sync_release_);
 
   IPC::Message* message = new PpapiHostMsg_PPBGraphics3D_AsyncFlush(
       ppapi::API_ID_PPB_GRAPHICS_3D, flush_info_->resource,
       flush_info_->put_offset);
 
   // Do not let a synchronous flush hold up this message. If this handler is
   // deferred until after the synchronous flush completes, it will overwrite the
   // cached last_state_ with out-of-date data.
   message->set_unblock(true);
   Send(message);
 
   flush_info_->flush_pending = false;
   flush_info_->resource.SetHostResource(0, 0);
+  flushed_fence_sync_release_ = pending_fence_sync_release_;
 }
 
 }  // namespace proxy
 }  // namespace ppapi