Use ScopedMakeCurrent

content/browser/renderer_host/image_transport_client.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 "content/browser/renderer_host/image_transport_client.h"
 
 #include <X11/Xlib.h>
 #include <X11/extensions/Xcomposite.h>
 
 #include "base/debug/trace_event.h"
 #include "base/lazy_instance.h"
 #include "base/memory/scoped_ptr.h"
 #include "third_party/angle/include/EGL/egl.h"
 #include "third_party/angle/include/EGL/eglext.h"
 #include "ui/gfx/gl/gl_bindings.h"
 #include "ui/gfx/gl/gl_implementation.h"
 #include "ui/gfx/gl/gl_surface_egl.h"
 #include "ui/gfx/gl/gl_surface_glx.h"
+#include "ui/gfx/gl/scoped_make_current.h"
 #include "ui/gfx/size.h"
 
 namespace {
 
 class ScopedPtrXFree {
  public:
   void operator()(void* x) const {
     ::XFree(x);
   }
 };
@@ skipping 11 matching lines @@
 
 class ImageTransportClientEGL : public ImageTransportClient {
  public:
   explicit ImageTransportClientEGL(ui::SharedResources* resources)
       : resources_(resources),
         image_(NULL) {
   }
 
   virtual ~ImageTransportClientEGL() {
     if (image_) {
-      resources_->MakeSharedContextCurrent();
+      scoped_ptr<gfx::ScopedMakeCurrent> bind(
+          resources_->GetScopedMakeCurrent());
       eglDestroyImageKHR(gfx::GLSurfaceEGL::GetHardwareDisplay(), image_);
       glFlush();
     }
   }
 
   virtual unsigned int Initialize(uint64* surface_id) {
-    resources_->MakeSharedContextCurrent();
+    scoped_ptr<gfx::ScopedMakeCurrent> bind(resources_->GetScopedMakeCurrent());
     image_ = eglCreateImageKHR(
         gfx::GLSurfaceEGL::GetHardwareDisplay(), EGL_NO_CONTEXT,
         EGL_NATIVE_PIXMAP_KHR, reinterpret_cast<void*>(*surface_id), NULL);
     if (!image_)
       return 0;
     GLuint texture = CreateTexture();
     glBindTexture(GL_TEXTURE_2D, texture);
     glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, image_);
     glFlush();
     return texture;
@@ skipping 25 matching lines @@
     if (glx_pixmap_)
       glXDestroyGLXPixmap(dpy, glx_pixmap_);
     if (pixmap_)
       XFreePixmap(dpy, pixmap_);
   }
 
   virtual unsigned int Initialize(uint64* surface_id) {
     TRACE_EVENT0("renderer_host", "ImageTransportClientGLX::Initialize");
     Display* dpy = static_cast<Display*>(resources_->GetDisplay());
 
-    resources_->MakeSharedContextCurrent();
+    scoped_ptr<gfx::ScopedMakeCurrent> bind(resources_->GetScopedMakeCurrent());
     if (!InitializeOneOff(dpy))
         return 0;
 
     // Create pixmap from window.
     // We receive a window here rather than a pixmap directly because drivers
     // require (or required) that the pixmap used to create the GL texture be
     // created in the same process as the texture.
     pixmap_ = XCompositeNameWindowPixmap(dpy, *surface_id);
 
     const int pixmapAttribs[] = {
@@ skipping 124 matching lines @@
     // ids active from more than one type at the same time, so we have free
     // reign of the id namespace.
     *surface_id = next_id_++;
 
     shared_mem_.reset(
         TransportDIB::Create(size_.GetArea() * 4,  // GL_RGBA=4 B/px
         *surface_id));
     if (!shared_mem_.get())
       return 0;
 
-    resources_->MakeSharedContextCurrent();
+    scoped_ptr<gfx::ScopedMakeCurrent> bind(resources_->GetScopedMakeCurrent());
     texture_ = CreateTexture();
     return texture_;
   }
 
   virtual void Acquire() {
     glBindTexture(GL_TEXTURE_2D, texture_);
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA,
                  size_.width(), size_.height(), 0,
                  GL_RGBA, GL_UNSIGNED_BYTE, shared_mem_->memory());
   }
@@ skipping 21 matching lines @@
       return new ImageTransportClientGLX(resources);
     case gfx::kGLImplementationEGLGLES2:
       return new ImageTransportClientEGL(resources);
     case gfx::kGLImplementationOSMesaGL:
       return new ImageTransportClientOSMesa(resources, size);
     default:
       NOTREACHED();
       return NULL;
   }
 }