base::Bind() conversion for remaining GPU files.

gpu/command_buffer/service/gles2_cmd_decoder.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 "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
 #include <stdio.h>
 
 #include <algorithm>
 #include <list>
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/atomicops.h"
 #include "base/at_exit.h"
-#include "base/callback.h"
+#include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "build/build_config.h"
 #define GLES2_GPU_SERVICE 1
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/common/id_allocator.h"
 #include "gpu/command_buffer/common/trace_event.h"
 #include "gpu/command_buffer/service/buffer_manager.h"
 #include "gpu/command_buffer/service/cmd_buffer_engine.h"
@@ skipping 476 matching lines @@
   virtual bool ResizeOffscreenFrameBuffer(const gfx::Size& size);
   void UpdateParentTextureInfo();
   virtual bool MakeCurrent();
   virtual void ReleaseCurrent();
   virtual GLES2Util* GetGLES2Util() { return &util_; }
   virtual gfx::GLContext* GetGLContext() { return context_.get(); }
   virtual gfx::GLSurface* GetGLSurface() { return surface_.get(); }
   virtual ContextGroup* GetContextGroup() { return group_.get(); }
 
   virtual void SetGLError(GLenum error, const char* msg);
-  virtual void SetResizeCallback(Callback1<gfx::Size>::Type* callback);
+  virtual void SetResizeCallback(
+      const base::Callback<void(gfx::Size)>& callback);
 
-  virtual void SetSwapBuffersCallback(Callback0::Type* callback);
+  virtual void SetSwapBuffersCallback(const base::Closure& callback);
 
   virtual void SetStreamTextureManager(StreamTextureManager* manager);
   virtual bool GetServiceTextureId(uint32 client_texture_id,
                                    uint32* service_texture_id);
 
   // Restores the current state to the user's settings.
   void RestoreCurrentFramebufferBindings();
   void RestoreCurrentRenderbufferBindings();
   void RestoreCurrentTexture2DBindings();
 
@@ skipping 837 matching lines @@
 
   // The copy that is saved when SwapBuffers is called.
   scoped_ptr<FrameBuffer> offscreen_saved_frame_buffer_;
   scoped_ptr<Texture> offscreen_saved_color_texture_;
 
   // The copy that is used as the destination for multi-sample resolves.
   scoped_ptr<FrameBuffer> offscreen_resolved_frame_buffer_;
   scoped_ptr<Texture> offscreen_resolved_color_texture_;
   GLenum offscreen_saved_color_format_;
 
-  scoped_ptr<Callback1<gfx::Size>::Type> resize_callback_;
+  base::Callback<void(gfx::Size)> resize_callback_;
 
-  scoped_ptr<Callback0::Type> swap_buffers_callback_;
+  base::Closure swap_buffers_callback_;
 
   StreamTextureManager* stream_texture_manager_;
 
   // The format of the back buffer_
   GLenum back_buffer_color_format_;
   bool back_buffer_has_depth_;
   bool back_buffer_has_stencil_;
 
   bool teximage2d_faster_than_texsubimage2d_;
   bool bufferdata_faster_than_buffersubdata_;
@@ skipping 1124 matching lines @@
         GL_CLAMP_TO_EDGE);
     parent_texture_manager->SetParameter(
         feature_info_,
         info,
         GL_TEXTURE_WRAP_T,
         GL_CLAMP_TO_EDGE);
   }
 }
 
 void GLES2DecoderImpl::SetResizeCallback(
-    Callback1<gfx::Size>::Type* callback) {
-  resize_callback_.reset(callback);
+    const base::Callback<void(gfx::Size)>& callback) {
+  resize_callback_ = callback;
 }
 
-void GLES2DecoderImpl::SetSwapBuffersCallback(Callback0::Type* callback) {
-  swap_buffers_callback_.reset(callback);
+void GLES2DecoderImpl::SetSwapBuffersCallback(const base::Closure& callback) {
+  swap_buffers_callback_ = callback;
 }
 
 void GLES2DecoderImpl::SetStreamTextureManager(StreamTextureManager* manager) {
   stream_texture_manager_ = manager;
 }
 
 bool GLES2DecoderImpl::GetServiceTextureId(uint32 client_texture_id,
                                            uint32* service_texture_id) {
   TextureManager::TextureInfo* texture =
       texture_manager()->GetTextureInfo(client_texture_id);
@@ skipping 252 matching lines @@
 #if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(TOUCH_UI)
   // Make sure that we are done drawing to the back buffer before resizing.
   glFinish();
 #endif
   bool is_offscreen = !!offscreen_target_frame_buffer_.get();
   if (is_offscreen) {
     if (!ResizeOffscreenFrameBuffer(gfx::Size(width, height)))
       return error::kLostContext;
   }
 
-  if (resize_callback_.get()) {
-    resize_callback_->Run(gfx::Size(width, height));
+  if (!resize_callback_.is_null()) {
+    resize_callback_.Run(gfx::Size(width, height));
     DCHECK(context_->IsCurrent(surface_.get()));
     if (!context_->IsCurrent(surface_.get()))
       return error::kLostContext;
   }
 
   return error::kNoError;
 }
 
 const char* GLES2DecoderImpl::GetCommandName(unsigned int command_id) const {
   if (command_id > kStartPoint && command_id < kNumCommands) {
@@ skipping 4319 matching lines @@
 
       UpdateParentTextureInfo();
     }
 
     ScopedGLErrorSuppressor suppressor(this);
 
     if (IsOffscreenBufferMultisampled()) {
       // For multisampled buffers, bind the resolved frame buffer so that
       // callbacks can call ReadPixels or CopyTexImage2D.
       ScopedResolvedFrameBufferBinder binder(this, true, false);
-      if (swap_buffers_callback_.get()) {
-        swap_buffers_callback_->Run();
+      if (!swap_buffers_callback_.is_null()) {
+        swap_buffers_callback_.Run();
       }
 
       return error::kNoError;
     } else {
       ScopedFrameBufferBinder binder(this,
                                      offscreen_target_frame_buffer_->id());
 
       if (surface_->IsOffscreen()) {
         // Copy the target frame buffer to the saved offscreen texture.
         offscreen_saved_color_texture_->Copy(
             offscreen_saved_color_texture_->size(),
             offscreen_saved_color_format_);
 
         // Ensure the side effects of the copy are visible to the parent
         // context. There is no need to do this for ANGLE because it uses a
         // single D3D device for all contexts.
         if (!IsAngle())
           glFlush();
       }
 
       // Run the callback with |binder| in scope, so that the callback can call
       // ReadPixels or CopyTexImage2D.
-      if (swap_buffers_callback_.get()) {
-        swap_buffers_callback_->Run();
+      if (!swap_buffers_callback_.is_null()) {
+        swap_buffers_callback_.Run();
       }
 
       return error::kNoError;
     }
   } else {
     TRACE_EVENT1("gpu", "GLContext::SwapBuffers", "frame", this_frame_number);
     if (!surface_->SwapBuffers()) {
       LOG(ERROR) << "Context lost because SwapBuffers failed.";
       return error::kLostContext;
     }
   }
 
-  if (swap_buffers_callback_.get()) {
-    swap_buffers_callback_->Run();
+  if (!swap_buffers_callback_.is_null()) {
+    swap_buffers_callback_.Run();
   }
 
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleEnableFeatureCHROMIUM(
     uint32 immediate_data_size, const gles2::EnableFeatureCHROMIUM& c) {
   Bucket* bucket = GetBucket(c.bucket_id);
   if (!bucket || bucket->size() == 0) {
     return error::kInvalidArguments;
@@ skipping 294 matching lines @@
   return error::kNoError;
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu