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

content/common/gpu/media/vaapi_h264_decoder.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 <dlfcn.h>
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/stl_util.h"
+#include "content/common/gpu/gl_scoped_binders.h"
 #include "content/common/gpu/media/vaapi_h264_decoder.h"
 #include "third_party/libva/va/va.h"
 #include "third_party/libva/va/va_x11.h"
 #include "ui/gl/gl_bindings.h"
 
 #define VA_LOG_ON_ERROR(va_res, err_msg)                   \
   do {                                                     \
     if ((va_res) != VA_STATUS_SUCCESS) {                   \
       DVLOG(1) << err_msg                                  \
                << " VA error: " << VAAPI_ErrorStr(va_res); \
@@ skipping 228 matching lines @@
       height_(height),
       available_(false),
       poc_(0),
       x_pixmap_(0),
       glx_pixmap_(0) {
   // Bind the surface to a texture of the given width and height,
   // allocating pixmaps as needed.
   if (!make_context_current_.Run())
     return;
 
-  glEnable(GL_TEXTURE_2D);
-  glBindTexture(GL_TEXTURE_2D, texture_id_);
+  gfx::ScopedTextureBinder texture_binder(texture_id_);
   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
   glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 
   XWindowAttributes win_attr;
   int screen = DefaultScreen(x_display_);
   XGetWindowAttributes(x_display_, RootWindow(x_display_, screen), &win_attr);
+  //TODO(posciak): pass the depth required by libva, not the RootWindow's depth
   x_pixmap_ = XCreatePixmap(x_display_, RootWindow(x_display_, screen),
                             width_, height_, win_attr.depth);
   if (!x_pixmap_) {
     DVLOG(1) << "Failed creating an X Pixmap for TFP";
     return;
   }
 
   static const int pixmap_attr[] = {
     GLX_TEXTURE_TARGET_EXT, GLX_TEXTURE_2D_EXT,
     GLX_TEXTURE_FORMAT_EXT, GLX_TEXTURE_FORMAT_RGB_EXT,
     GL_NONE,
   };
 
   glx_pixmap_ = glXCreatePixmap(x_display_, fb_config, x_pixmap_, pixmap_attr);
   if (!glx_pixmap_) {
     // x_pixmap_ will be freed in the destructor.
     DVLOG(1) << "Failed creating a GLX Pixmap for TFP";
     return;
   }
 
-  glBindTexture(GL_TEXTURE_2D, texture_id_);
   glXBindTexImageEXT(x_display_, glx_pixmap_, GLX_FRONT_LEFT_EXT, NULL);
 
   available_ = true;
 }
 
 VaapiH264Decoder::DecodeSurface::~DecodeSurface() {
   // Unbind surface from texture and deallocate resources.
   if (glx_pixmap_ && make_context_current_.Run()) {
     glXReleaseTexImageEXT(x_display_, glx_pixmap_, GLX_FRONT_LEFT_EXT);
-    glXDestroyGLXPixmap(x_display_, glx_pixmap_);
+    glXDestroyPixmap(x_display_, glx_pixmap_);
   }
 
   if (x_pixmap_)
     XFreePixmap(x_display_, x_pixmap_);
 }
 
 void VaapiH264Decoder::DecodeSurface::Acquire(int32 input_id, int poc) {
   DCHECK_EQ(available_, true);
   available_ = false;
   input_id_ = input_id;
@@ skipping 1787 matching lines @@
     }
   }
 }
 
 // static
 size_t VaapiH264Decoder::GetRequiredNumOfPictures() {
   return kNumReqPictures;
 }
 
 }  // namespace content