Convert ppapi/shared to use TrackedCallback.

ppapi/shared_impl/ppb_graphics_3d_shared.cc

 // Copyright (c) 2011 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/shared_impl/ppb_graphics_3d_shared.h"
 
 #include "base/logging.h"
 #include "gpu/command_buffer/client/gles2_cmd_helper.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "ppapi/c/pp_errors.h"
 
 namespace ppapi {
 
-PPB_Graphics3D_Shared::PPB_Graphics3D_Shared()
-    : transfer_buffer_id_(-1),
-      swap_callback_(PP_BlockUntilComplete()) {
+PPB_Graphics3D_Shared::PPB_Graphics3D_Shared(PP_Instance instance)
+    : Resource(instance),
+      transfer_buffer_id_(-1) {
+}
+
+PPB_Graphics3D_Shared::PPB_Graphics3D_Shared(const HostResource& host_resource)
+    : Resource(host_resource),
+      transfer_buffer_id_(-1) {
 }
 
 PPB_Graphics3D_Shared::~PPB_Graphics3D_Shared() {
   // Make sure that GLES2 implementation has already been destroyed.
   DCHECK_EQ(transfer_buffer_id_, -1);
   DCHECK(!gles2_helper_.get());
   DCHECK(!gles2_impl_.get());
 }
 
+thunk::PPB_Graphics3D_API* PPB_Graphics3D_Shared::AsPPB_Graphics3D_API() {
+  return this;
+}
+
 int32_t PPB_Graphics3D_Shared::GetAttribs(int32_t* attrib_list) {
   // TODO(alokp): Implement me.
   return PP_ERROR_FAILED;
 }
 
 int32_t PPB_Graphics3D_Shared::SetAttribs(int32_t* attrib_list) {
   // TODO(alokp): Implement me.
   return PP_ERROR_FAILED;
 }
 
@@ skipping 16 matching lines @@
     // Blocking SwapBuffers isn't supported (since we have to be on the main
     // thread).
     return PP_ERROR_BADARGUMENT;
   }
 
   if (HasPendingSwap()) {
     // Already a pending SwapBuffers that hasn't returned yet.
     return PP_ERROR_INPROGRESS;
   }
 
-  swap_callback_ = callback;
+  swap_callback_ = new TrackedCallback(this, callback);
   return DoSwapBuffers();
 }
 
 void* PPB_Graphics3D_Shared::MapTexSubImage2DCHROMIUM(GLenum target,
                                                       GLint level,
                                                       GLint xoffset,
                                                       GLint yoffset,
                                                       GLsizei width,
                                                       GLsizei height,
                                                       GLenum format,
                                                       GLenum type,
                                                       GLenum access) {
   return gles2_impl_->MapTexSubImage2DCHROMIUM(
       target, level, xoffset, yoffset, width, height, format, type, access);
 }
 
 void PPB_Graphics3D_Shared::UnmapTexSubImage2DCHROMIUM(const void* mem) {
   gles2_impl_->UnmapTexSubImage2DCHROMIUM(mem);
 }
 
 void PPB_Graphics3D_Shared::SwapBuffersACK(int32_t pp_error) {
   DCHECK(HasPendingSwap());
-  PP_RunAndClearCompletionCallback(&swap_callback_, pp_error);
+  TrackedCallback::ClearAndRun(&swap_callback_, pp_error);
+}
+
+bool PPB_Graphics3D_Shared::HasPendingSwap() const {
+  return !!swap_callback_.get();

[viettrungluu, 2012/01/04 01:15:14]

TrackedCallback::IsPending()?

[viettrungluu, 2012/01/04 01:15:14]

"

 }
 
 bool PPB_Graphics3D_Shared::CreateGLES2Impl(int32 command_buffer_size,
                                             int32 transfer_buffer_size) {
   gpu::CommandBuffer* command_buffer = GetCommandBuffer();
   DCHECK(command_buffer);
 
   // Create the GLES2 helper, which writes the command buffer protocol.
   gles2_helper_.reset(new gpu::gles2::GLES2CmdHelper(command_buffer));
   if (!gles2_helper_->Initialize(command_buffer_size))
@@ skipping 32 matching lines @@
     DCHECK(command_buffer);
     command_buffer->DestroyTransferBuffer(transfer_buffer_id_);
     transfer_buffer_id_ = -1;
   }
 
   gles2_helper_.reset();
 }
 
 }  // namespace ppapi