Extract Scoped{FrameBuffer,Texture}Binder and clean up TFP in VAVDA.

content/common/gpu/texture_image_transport_surface.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 "content/common/gpu/texture_image_transport_surface.h"
 
 #include <string>
 #include <vector>
 
 #include "base/command_line.h"
+#include "content/common/gpu/gl_scoped_binders.h"
 #include "content/common/gpu/gpu_channel.h"
 #include "content/common/gpu/gpu_channel_manager.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/common/gpu/sync_point_manager.h"
 #include "content/public/common/content_switches.h"
 #include "gpu/command_buffer/service/context_group.h"
 #include "gpu/command_buffer/service/gpu_scheduler.h"
 #include "gpu/command_buffer/service/texture_manager.h"
 
 using gpu::gles2::ContextGroup;
 using gpu::gles2::TextureManager;
 typedef TextureManager::TextureInfo TextureInfo;
 
-namespace {
-
-class ScopedFrameBufferBinder {
- public:
-  explicit ScopedFrameBufferBinder(unsigned int fbo) {
-    glGetIntegerv(GL_FRAMEBUFFER_BINDING, &old_fbo_);
-    glBindFramebufferEXT(GL_FRAMEBUFFER, fbo);
-  }
-
-  ~ScopedFrameBufferBinder() {
-    glBindFramebufferEXT(GL_FRAMEBUFFER, old_fbo_);
-  }
-
- private:
-  int old_fbo_;
-};
-
-class ScopedTextureBinder {
- public:
-  explicit ScopedTextureBinder(unsigned int id) {
-    glGetIntegerv(GL_TEXTURE_BINDING_2D, &old_id_);
-    glBindTexture(GL_TEXTURE_2D, id);
-  }
-
-  ~ScopedTextureBinder() {
-    glBindTexture(GL_TEXTURE_2D, old_id_);
-  }
-
- private:
-  int old_id_;
-};
-
-}  // anonymous namespace
-
 TextureImageTransportSurface::Texture::Texture()
     : client_id(0),
       sent_to_client(false) {
 }
 
 TextureImageTransportSurface::Texture::~Texture() {
 }
 
 TextureImageTransportSurface::TextureImageTransportSurface(
     GpuChannelManager* manager,
@@ skipping 213 matching lines @@
   const gfx::Rect new_damage_rect(x, y, width, height);
 
   // An empty damage rect is a successful no-op.
   if (new_damage_rect.IsEmpty())
     return true;
 
   if (surfaces_same_size) {
     std::vector<gfx::Rect> regions_to_copy;
     GetRegionsToCopy(previous_damage_rect_, new_damage_rect, &regions_to_copy);
 
-    ScopedFrameBufferBinder fbo_binder(fbo_id_);
+    gfx::ScopedFrameBufferBinder fbo_binder(fbo_id_);
     glFramebufferTexture2DEXT(GL_FRAMEBUFFER,
         GL_COLOR_ATTACHMENT0,
         GL_TEXTURE_2D,
         front_texture_service_id,
         0);
-    ScopedTextureBinder texture_binder(back_texture_service_id);
+    gfx::ScopedTextureBinder texture_binder(back_texture_service_id);
 
     for (size_t i = 0; i < regions_to_copy.size(); ++i) {
       const gfx::Rect& region_to_copy = regions_to_copy[i];
       if (!region_to_copy.IsEmpty()) {
         glCopyTexSubImage2D(GL_TEXTURE_2D, 0, region_to_copy.x(),
             region_to_copy.y(), region_to_copy.x(), region_to_copy.y(),
             region_to_copy.width(), region_to_copy.height());
       }
     }
   } else {
@@ skipping 77 matching lines @@
     return;
   TextureInfo* info = textures_[back()].info;
   DCHECK(info);
 
   GLuint service_id = info->service_id();
   if (!service_id)
     return;
   info->SetServiceId(0);
 
   {
-    ScopedFrameBufferBinder fbo_binder(fbo_id_);
+    gfx::ScopedFrameBufferBinder fbo_binder(fbo_id_);
     glDeleteTextures(1, &service_id);
   }
   glFlush();
   CHECK_GL_ERROR();
 }
 
 void TextureImageTransportSurface::CreateBackTexture(const gfx::Size& size) {
   if (!parent_stub_)
     return;
   Texture& texture = textures_[back()];
@@ skipping 22 matching lines @@
         size.width(),
         size.height(),
         1,
         0,
         GL_RGBA,
         GL_UNSIGNED_BYTE,
         true);
   }
 
   {
-    ScopedTextureBinder texture_binder(service_id);
+    gfx::ScopedTextureBinder texture_binder(service_id);
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
     glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA,
         size.width(), size.height(), 0,
         GL_RGBA, GL_UNSIGNED_BYTE, NULL);
     CHECK_GL_ERROR();
   }
 
   AttachBackTextureToFBO();
 
   GpuHostMsg_AcceleratedSurfaceNew_Params params;
   params.width = size.width();
   params.height = size.height();
   params.surface_handle = texture.client_id;
   helper_->SendAcceleratedSurfaceNew(params);
   texture.sent_to_client = true;
 }
 
 void TextureImageTransportSurface::AttachBackTextureToFBO() {
   if (!parent_stub_)
     return;
   DCHECK(textures_[back()].info);
 
-  ScopedFrameBufferBinder fbo_binder(fbo_id_);
+  gfx::ScopedFrameBufferBinder fbo_binder(fbo_id_);
   glFramebufferTexture2DEXT(GL_FRAMEBUFFER,
       GL_COLOR_ATTACHMENT0,
       GL_TEXTURE_2D,
       textures_[back()].info->service_id(),
       0);
   glFlush();
   CHECK_GL_ERROR();
 
 #ifndef NDEBUG
   GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER);
@@ skipping 10 matching lines @@
     Texture& texture = textures_[i];
     texture.info = NULL;
     if (!texture.sent_to_client)
       continue;
     GpuHostMsg_AcceleratedSurfaceRelease_Params params;
     params.identifier = texture.client_id;
     helper_->SendAcceleratedSurfaceRelease(params);
   }
   parent_stub_ = NULL;
 }