[Pepper GL] Use shared state to fix a memory leak in MapSub GL extension.

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 "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/proxy_channel.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,
-    ProxyChannel* channel)
+    ProxyChannel* channel,
+    const SerializedHandle& shared_state)
     : resource_(resource),
       channel_(channel) {
+  shared_state_shm_.reset(
+      new base::SharedMemory(shared_state.shmem(), false));
+  shared_state_shm_->Map(shared_state.size());
 }
 
 PpapiCommandBufferProxy::~PpapiCommandBufferProxy() {
   // gpu::Buffers are no longer referenced, allowing shared memory objects to be
   // deleted, closing the handle in this process.
 }
 
 bool PpapiCommandBufferProxy::Initialize() {
   return true;
 }
 
 gpu::CommandBuffer::State PpapiCommandBufferProxy::GetLastState() {
   ppapi::ProxyLock::AssertAcquiredDebugOnly();
   return last_state_;
 }
 
 int32 PpapiCommandBufferProxy::GetLastToken() {
   ppapi::ProxyLock::AssertAcquiredDebugOnly();
+  TryUpdateState();
   return last_state_.token;
 }
 
 void PpapiCommandBufferProxy::Flush(int32 put_offset) {
   if (last_state_.error != gpu::error::kNoError)
     return;
 
   IPC::Message* message = new PpapiHostMsg_PPBGraphics3D_AsyncFlush(
       ppapi::API_ID_PPB_GRAPHICS_3D, resource_, 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);
 }
 
 void PpapiCommandBufferProxy::WaitForTokenInRange(int32 start, int32 end) {
-  if (last_state_.error != gpu::error::kNoError)
-    return;
-
-  bool success = false;
-  gpu::CommandBuffer::State state;
-  if (Send(new PpapiHostMsg_PPBGraphics3D_WaitForTokenInRange(
-          ppapi::API_ID_PPB_GRAPHICS_3D,
-          resource_,
-          start,
-          end,
-          &state,
-          &success)))
-    UpdateState(state, success);
+  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)))
+      UpdateState(state, success);
+  }
+  DCHECK(InRange(start, end, last_state_.token) ||
+         last_state_.error != gpu::error::kNoError);
 }
 
 void PpapiCommandBufferProxy::WaitForGetOffsetInRange(int32 start, int32 end) {
-  if (last_state_.error != gpu::error::kNoError)
-    return;
-
-  bool success = false;
-  gpu::CommandBuffer::State state;
-  if (Send(new PpapiHostMsg_PPBGraphics3D_WaitForGetOffsetInRange(
-          ppapi::API_ID_PPB_GRAPHICS_3D,
-          resource_,
-          start,
-          end,
-          &state,
-          &success)))
-    UpdateState(state, success);
+  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)))
+      UpdateState(state, success);
+  }
+  DCHECK(InRange(start, end, last_state_.get_offset) ||
+         last_state_.error != gpu::error::kNoError);
 }
 
 void PpapiCommandBufferProxy::SetGetBuffer(int32 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));
   }
 }
 
 scoped_refptr<gpu::Buffer> PpapiCommandBufferProxy::CreateTransferBuffer(
@@ skipping 124 matching lines @@
   if (success) {
     if (state.generation - last_state_.generation < 0x80000000U) {
       last_state_ = state;
     }
   } else {
     last_state_.error = gpu::error::kLostContext;
     ++last_state_.generation;
   }
 }
 
+void PpapiCommandBufferProxy::TryUpdateState() {
+  if (last_state_.error == gpu::error::kNoError)
+    shared_state()->Read(&last_state_);
+}
+
+gpu::CommandBufferSharedState* PpapiCommandBufferProxy::shared_state() const {
+  return reinterpret_cast<gpu::CommandBufferSharedState*>(
+      shared_state_shm_->memory());
+}
+
 }  // namespace proxy
 }  // namespace ppapi