gpu: Thread-safe command buffer state lookup.

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 <utility>
 
 #include "base/numerics/safe_conversions.h"
 #include "ppapi/proxy/ppapi_messages.h"
@@ skipping 11 matching lines @@
     const SerializedHandle& shared_state,
     gpu::CommandBufferId command_buffer_id)
     : command_buffer_id_(command_buffer_id),
       capabilities_(capabilities),
       resource_(resource),
       dispatcher_(dispatcher),
       next_fence_sync_release_(1),
       pending_fence_sync_release_(0),
       flushed_fence_sync_release_(0),
       validated_fence_sync_release_(0) {
-  shared_state_shm_.reset(
-      new base::SharedMemory(shared_state.shmem(), false));
+  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.
 }
 
 gpu::CommandBuffer::State PpapiCommandBufferProxy::GetLastState() {
   ppapi::ProxyLock::AssertAcquiredDebugOnly();
+  TryUpdateState();
   return last_state_;
 }
 
-int32_t PpapiCommandBufferProxy::GetLastToken() {
-  ppapi::ProxyLock::AssertAcquiredDebugOnly();
-  TryUpdateState();
-  return last_state_.token;
-}
-
 void PpapiCommandBufferProxy::Flush(int32_t put_offset) {
   if (last_state_.error != gpu::error::kNoError)
     return;
 
   OrderingBarrier(put_offset);
   FlushInternal();
 }
 
 void PpapiCommandBufferProxy::OrderingBarrier(int32_t put_offset) {
   if (last_state_.error != gpu::error::kNoError)
     return;
 
   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_t start, int32_t end) {
+gpu::CommandBuffer::State PpapiCommandBufferProxy::WaitForTokenInRange(
+    int32_t start,
+    int32_t 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,
-             resource_,
-             start,
-             end,
-             &state,
-             &success)))
+            ppapi::API_ID_PPB_GRAPHICS_3D, resource_, start, end, &state,
+            &success)))
       UpdateState(state, success);
   }
   DCHECK(InRange(start, end, last_state_.token) ||
          last_state_.error != gpu::error::kNoError);
+  return last_state_;
 }
 
-void PpapiCommandBufferProxy::WaitForGetOffsetInRange(int32_t start,
-                                                      int32_t end) {
+gpu::CommandBuffer::State PpapiCommandBufferProxy::WaitForGetOffsetInRange(
+    int32_t start,
+    int32_t end) {
   TryUpdateState();
   if (!InRange(start, end, last_state_.get_offset) &&
       last_state_.error == gpu::error::kNoError) {
     bool success = false;
     gpu::CommandBuffer::State state;
     if (Send(new PpapiHostMsg_PPBGraphics3D_WaitForGetOffsetInRange(
-             ppapi::API_ID_PPB_GRAPHICS_3D,
-             resource_,
-             start,
-             end,
-             &state,
-             &success)))
+            ppapi::API_ID_PPB_GRAPHICS_3D, resource_, start, end, &state,
+            &success)))
       UpdateState(state, success);
   }
   DCHECK(InRange(start, end, last_state_.get_offset) ||
          last_state_.error != gpu::error::kNoError);
+  return last_state_;
 }
 
 void PpapiCommandBufferProxy::SetGetBuffer(int32_t transfer_buffer_id) {
   if (last_state_.error == gpu::error::kNoError) {
     Send(new PpapiHostMsg_PPBGraphics3D_SetGetBuffer(
-         ppapi::API_ID_PPB_GRAPHICS_3D, resource_, transfer_buffer_id));
+        ppapi::API_ID_PPB_GRAPHICS_3D, resource_, transfer_buffer_id));
   }
 }
 
 scoped_refptr<gpu::Buffer> PpapiCommandBufferProxy::CreateTransferBuffer(
     size_t size,
     int32_t* id) {
   *id = -1;
 
   if (last_state_.error != gpu::error::kNoError)
     return NULL;
 
   // Assuming we are in the renderer process, the service is responsible for
   // duplicating the handle. This might not be true for NaCl.
   ppapi::proxy::SerializedHandle handle(
       ppapi::proxy::SerializedHandle::SHARED_MEMORY);
   if (!Send(new PpapiHostMsg_PPBGraphics3D_CreateTransferBuffer(
-            ppapi::API_ID_PPB_GRAPHICS_3D, resource_,
-            base::checked_cast<uint32_t>(size), id, &handle))) {
+          ppapi::API_ID_PPB_GRAPHICS_3D, resource_,
+          base::checked_cast<uint32_t>(size), id, &handle))) {
     if (last_state_.error == gpu::error::kNoError)
       last_state_.error = gpu::error::kLostContext;
     return NULL;
   }
 
   if (*id <= 0 || !handle.is_shmem()) {
     if (last_state_.error == gpu::error::kNoError)
       last_state_.error = gpu::error::kOutOfBounds;
     return NULL;
   }
@@ skipping 58 matching lines @@
   if (!IsFenceSyncFlushed(release))
     return false;
 
   if (release <= validated_fence_sync_release_)
     return true;
 
   EnsureWorkVisible();
   return release <= validated_fence_sync_release_;
 }
 
+bool PpapiCommandBufferProxy::IsFenceSyncReleased(uint64_t release) {
+  NOTIMPLEMENTED();
+  return false;
+}
+
 void PpapiCommandBufferProxy::SignalSyncToken(const gpu::SyncToken& sync_token,
                                               const base::Closure& callback) {
   NOTIMPLEMENTED();
 }
 
 bool PpapiCommandBufferProxy::CanWaitUnverifiedSyncToken(
     const gpu::SyncToken* sync_token) {
   return false;
 }
 
@@ skipping 91 matching lines @@
   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