Use base::ScopedTypeRef for CGL types

content/browser/renderer_host/compositing_iosurface_mac.mm

 // 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/browser/renderer_host/compositing_iosurface_mac.h"
 
 #include <OpenGL/CGLRenderers.h>
 #include <OpenGL/OpenGL.h>
 
 #include "base/bind.h"
@@ skipping 239 matching lines @@
           base::Bind(&CompositingIOSurfaceMac::CheckIfAllCopiesAreFinished,
                      base::Unretained(this),
                      false),
           true),
       gl_error_(GL_NO_ERROR) {
   CHECK(offscreen_context_);
 }
 
 CompositingIOSurfaceMac::~CompositingIOSurfaceMac() {
   FailAllCopies();
-  CGLSetCurrentContext(offscreen_context_->cgl_context());
-  DestroyAllCopyContextsWithinContext();
-  UnrefIOSurfaceWithContextCurrent();
-  CGLSetCurrentContext(0);
+  {
+    gfx::ScopedCGLSetCurrentContext scoped_set_current_context(
+        offscreen_context_->cgl_context());
+    DestroyAllCopyContextsWithinContext();
+    UnrefIOSurfaceWithContextCurrent();
+  }
   offscreen_context_ = NULL;
 }
 
 bool CompositingIOSurfaceMac::SetIOSurfaceWithContextCurrent(
     scoped_refptr<CompositingIOSurfaceContext> current_context,
     uint64 io_surface_handle,
     const gfx::Size& size,
     float scale_factor) {
   pixel_io_surface_size_ = size;
   scale_factor_ = scale_factor;
@@ skipping 159 matching lines @@
                     kOpaque_SkAlphaType);
 
   if (!output->allocPixels()) {
     DLOG(ERROR) << "Failed to allocate SkBitmap pixels!";
     callback.Run(false, *output);
     return;
   }
   DCHECK_EQ(output->rowBytesAsPixels(), dst_pixel_size.width())
       << "Stride is required to be equal to width for GPU readback.";
 
-  CGLSetCurrentContext(offscreen_context_->cgl_context());
-  const base::Closure copy_done_callback = CopyToSelectedOutputWithinContext(
-      src_pixel_subrect, gfx::Rect(dst_pixel_size), false,
-      output.get(), NULL,
-      base::Bind(&ReverseArgumentOrder, callback, base::Passed(&output)));
-  CGLSetCurrentContext(0);
+  base::Closure copy_done_callback;
+  {
+    gfx::ScopedCGLSetCurrentContext scoped_set_current_context(
+        offscreen_context_->cgl_context());
+    copy_done_callback = CopyToSelectedOutputWithinContext(
+        src_pixel_subrect, gfx::Rect(dst_pixel_size), false,
+        output.get(), NULL,
+        base::Bind(&ReverseArgumentOrder, callback, base::Passed(&output)));
+  }
   if (!copy_done_callback.is_null())
     copy_done_callback.Run();
 }
 
 void CompositingIOSurfaceMac::CopyToVideoFrame(
     const gfx::Rect& src_pixel_subrect,
     const scoped_refptr<media::VideoFrame>& target,
     const base::Callback<void(bool)>& callback) {
-  CGLSetCurrentContext(offscreen_context_->cgl_context());
-  const base::Closure copy_done_callback = CopyToVideoFrameWithinContext(
-      src_pixel_subrect, false, target, callback);
-  CGLSetCurrentContext(0);
+  base::Closure copy_done_callback;
+  {
+    gfx::ScopedCGLSetCurrentContext scoped_set_current_context(
+        offscreen_context_->cgl_context());
+    copy_done_callback = CopyToVideoFrameWithinContext(
+        src_pixel_subrect, false, target, callback);
+  }
   if (!copy_done_callback.is_null())
     copy_done_callback.Run();
 }
 
 base::Closure CompositingIOSurfaceMac::CopyToVideoFrameWithinContext(
     const gfx::Rect& src_pixel_subrect,
     bool called_within_draw,
     const scoped_refptr<media::VideoFrame>& target,
     const base::Callback<void(bool)>& callback) {
   gfx::Rect region_in_frame = media::ComputeLetterboxRegion(
@@ skipping 64 matching lines @@
   GetAndSaveGLError();
   if (gl_error_ != GL_NO_ERROR) {
     LOG(ERROR) << "GL error in MapIOSurfaceToTexture: " << gl_error_;
     UnrefIOSurfaceWithContextCurrent();
     return false;
   }
   return true;
 }
 
 void CompositingIOSurfaceMac::UnrefIOSurface() {
-  CGLSetCurrentContext(offscreen_context_->cgl_context());
+  gfx::ScopedCGLSetCurrentContext scoped_set_current_context(
+      offscreen_context_->cgl_context());
   UnrefIOSurfaceWithContextCurrent();
-  CGLSetCurrentContext(0);
 }
 
 void CompositingIOSurfaceMac::DrawQuad(const SurfaceQuad& quad) {
   TRACE_EVENT0("gpu", "CompositingIOSurfaceMac::DrawQuad");
 
   glEnableClientState(GL_VERTEX_ARRAY); CHECK_AND_SAVE_GL_ERROR();
   glEnableClientState(GL_TEXTURE_COORD_ARRAY); CHECK_AND_SAVE_GL_ERROR();
 
   glVertexPointer(2, GL_FLOAT, sizeof(SurfaceVertex), &quad.verts_[0].x_);
   glTexCoordPointer(2, GL_FLOAT, sizeof(SurfaceVertex), &quad.verts_[0].tx_);
@@ skipping 182 matching lines @@
       base::Bind(&MapBufferToSkBitmap, bitmap_output) :
       base::Bind(&MapBufferToVideoFrame, video_frame_output, dst_pixel_rect);
 }
 
 void CompositingIOSurfaceMac::CheckIfAllCopiesAreFinished(
     bool block_until_finished) {
   if (copy_requests_.empty())
     return;
 
   std::vector<base::Closure> done_callbacks;
-  CGLContextObj previous_context = CGLGetCurrentContext();
-  CGLSetCurrentContext(offscreen_context_->cgl_context());
-  CheckIfAllCopiesAreFinishedWithinContext(
-      block_until_finished, &done_callbacks);
-  CGLSetCurrentContext(previous_context);
+  {
+    gfx::ScopedCGLSetCurrentContext scoped_set_current_context(
+        offscreen_context_->cgl_context());
+    CheckIfAllCopiesAreFinishedWithinContext(
+        block_until_finished, &done_callbacks);
+  }
   for (size_t i = 0; i < done_callbacks.size(); ++i)
     done_callbacks[i].Run();
 }
 
 void CompositingIOSurfaceMac::CheckIfAllCopiesAreFinishedWithinContext(
     bool block_until_finished,
     std::vector<base::Closure>* done_callbacks) {
   while (!copy_requests_.empty()) {
     CopyContext* const copy_context = copy_requests_.front();
 
@@ skipping 153 matching lines @@
 }
 
 GLenum CompositingIOSurfaceMac::GetAndSaveGLError() {
   GLenum gl_error = glGetError();
   if (gl_error_ == GL_NO_ERROR)
     gl_error_ = gl_error;
   return gl_error;
 }
 
 }  // namespace content