cc: Convert non-const reference arguments to pointers.

cc/output/gl_renderer.cc

 // Copyright 2010 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 "cc/output/gl_renderer.h"
 
 #include <set>
 #include <string>
 #include <vector>
 
@@ skipping 217 matching lines @@
   stats.bytesVisibleAndNearby = bytes_visible_and_nearby;
   stats.bytesAllocated = bytes_allocated;
   stats.backbufferRequested = !is_backbuffer_discarded_;
   context_->sendManagedMemoryStatsCHROMIUM(&stats);
 }
 
 void GLRenderer::ReleaseRenderPassTextures() { render_pass_textures_.clear(); }
 
 void GLRenderer::ViewportChanged() { is_viewport_changed_ = true; }
 
-void GLRenderer::ClearFramebuffer(DrawingFrame& frame) {
+void GLRenderer::ClearFramebuffer(DrawingFrame* frame) {
   // On DEBUG builds, opaque render passes are cleared to blue to easily see
   // regions that were not drawn on the screen.
-  if (frame.current_render_pass->has_transparent_background)
+  if (frame->current_render_pass->has_transparent_background)
     GLC(context_, context_->clearColor(0, 0, 0, 0));
   else
     GLC(context_, context_->clearColor(0, 0, 1, 1));
 
 #ifdef NDEBUG
-  if (frame.current_render_pass->has_transparent_background)
+  if (frame->current_render_pass->has_transparent_background)
 #endif
     context_->clear(GL_COLOR_BUFFER_BIT);
 }
 
-void GLRenderer::BeginDrawingFrame(DrawingFrame& frame) {
+void GLRenderer::BeginDrawingFrame(DrawingFrame* frame) {
   // FIXME: Remove this once backbuffer is automatically recreated on first use
   EnsureBackbuffer();
 
   if (ViewportSize().IsEmpty())
     return;
 
   TRACE_EVENT0("cc", "GLRenderer::DrawLayers");
   if (is_viewport_changed_) {
     // Only reshape when we know we are going to draw. Otherwise, the reshape
     // can leave the window at the wrong size if we never draw and the proper
@@ skipping 14 matching lines @@
   GLC(context_, context_->blendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA));
   GLC(Context(), Context()->activeTexture(GL_TEXTURE0));
   program_shadow_ = 0;
 }
 
 void GLRenderer::DoNoOp() {
   GLC(context_, context_->bindFramebuffer(GL_FRAMEBUFFER, 0));
   GLC(context_, context_->flush());
 }
 
-void GLRenderer::DoDrawQuad(DrawingFrame& frame, const DrawQuad* quad) {
+void GLRenderer::DoDrawQuad(DrawingFrame* frame, const DrawQuad* quad) {
   DCHECK(quad->rect.Contains(quad->visible_rect));
   if (quad->material != DrawQuad::TEXTURE_CONTENT) {
     FlushTextureQuadCache();
   }
 
   switch (quad->material) {
     case DrawQuad::INVALID:
       NOTREACHED();
       break;
     case DrawQuad::CHECKERBOARD:
@@ skipping 19 matching lines @@
       break;
     case DrawQuad::TILED_CONTENT:
       DrawTileQuad(frame, TileDrawQuad::MaterialCast(quad));
       break;
     case DrawQuad::YUV_VIDEO_CONTENT:
       DrawYUVVideoQuad(frame, YUVVideoDrawQuad::MaterialCast(quad));
       break;
   }
 }
 
-void GLRenderer::DrawCheckerboardQuad(const DrawingFrame& frame,
+void GLRenderer::DrawCheckerboardQuad(const DrawingFrame* frame,
                                       const CheckerboardDrawQuad* quad) {
   SetBlendEnabled(quad->ShouldDrawWithBlending());
 
   const TileCheckerboardProgram* program = GetTileCheckerboardProgram();
   DCHECK(program && (program->initialized() || IsContextLost()));
   SetUseProgram(program->program());
 
   SkColor color = quad->color;
   GLC(Context(),
       Context()->uniform4f(program->fragment_shader().color_location(),
@@ skipping 22 matching lines @@
                            frequency));
 
   SetShaderOpacity(quad->opacity(),
                    program->fragment_shader().alpha_location());
   DrawQuadGeometry(frame,
                    quad->quadTransform(),
                    quad->rect,
                    program->vertex_shader().matrix_location());
 }
 
-void GLRenderer::DrawDebugBorderQuad(const DrawingFrame& frame,
+void GLRenderer::DrawDebugBorderQuad(const DrawingFrame* frame,
                                      const DebugBorderDrawQuad* quad) {
   SetBlendEnabled(quad->ShouldDrawWithBlending());
 
   static float gl_matrix[16];
   const DebugBorderProgram* program = GetDebugBorderProgram();
   DCHECK(program && (program->initialized() || IsContextLost()));
   SetUseProgram(program->program());
 
   // Use the full quad_rect for debug quads to not move the edges based on
   // partial swaps.
   gfx::Rect layer_rect = quad->rect;
   gfx::Transform render_matrix = quad->quadTransform();
   render_matrix.Translate(0.5f * layer_rect.width() + layer_rect.x(),
                           0.5f * layer_rect.height() + layer_rect.y());
   render_matrix.Scale(layer_rect.width(), layer_rect.height());
   GLRenderer::ToGLMatrix(&gl_matrix[0],
-                         frame.projection_matrix * render_matrix);
+                         frame->projection_matrix * render_matrix);
   GLC(Context(),
       Context()->uniformMatrix4fv(
           program->vertex_shader().matrix_location(), 1, false, &gl_matrix[0]));
 
   SkColor color = quad->color;
   float alpha = SkColorGetA(color) * (1.0f / 255.0f);
 
   GLC(Context(),
       Context()->uniform4f(program->fragment_shader().color_location(),
                            (SkColorGetR(color) * (1.0f / 255.0f)) * alpha,
@@ skipping 124 matching lines @@
   // visible in the compositor's context.
   offscreen_contexts->Context3d()->flush();
 
   // Use the compositor's GL context again.
   renderer->resource_provider()->GraphicsContext3D()->makeContextCurrent();
 
   return device.accessBitmap(false);
 }
 
 scoped_ptr<ScopedResource> GLRenderer::DrawBackgroundFilters(
-    DrawingFrame& frame,
+    DrawingFrame* frame,
     const RenderPassDrawQuad* quad,
     const gfx::Transform& contents_device_transform,
     const gfx::Transform& contents_device_transform_inverse) {
   // This method draws a background filter, which applies a filter to any pixels
   // behind the quad and seen through its background.  The algorithm works as
   // follows:
   // 1. Compute a bounding box around the pixels that will be visible through
   // the quad.
   // 2. Read the pixels in the bounding box into a buffer R.
   // 3. Apply the background filter to R, so that it is applied in the pixels'
@@ skipping 13 matching lines @@
   // FIXME: When this algorithm changes, update
   // LayerTreeHost::prioritizeTextures() accordingly.
 
   const WebKit::WebFilterOperations& filters = quad->background_filters;
   if (filters.isEmpty())
     return scoped_ptr<ScopedResource>();
 
   // FIXME: We only allow background filters on an opaque render surface because
   // other surfaces may contain translucent pixels, and the contents behind
   // those translucent pixels wouldn't have the filter applied.
-  if (frame.current_render_pass->has_transparent_background)
+  if (frame->current_render_pass->has_transparent_background)
     return scoped_ptr<ScopedResource>();
-  DCHECK(!frame.current_texture);
+  DCHECK(!frame->current_texture);
 
   // FIXME: Do a single readback for both the surface and replica and cache the
   // filtered results (once filter textures are not reused).
   gfx::Rect device_rect = gfx::ToEnclosingRect(MathUtil::MapClippedRect(
       contents_device_transform, SharedGeometryQuad().BoundingBox()));
 
   int top, right, bottom, left;
   filters.getOutsets(top, right, bottom, left);
   device_rect.Inset(-left, -top, -right, -bottom);
 
-  device_rect.Intersect(frame.current_render_pass->output_rect);
+  device_rect.Intersect(frame->current_render_pass->output_rect);
 
   scoped_ptr<ScopedResource> device_background_texture =
       ScopedResource::create(resource_provider_);
   if (!GetFramebufferTexture(device_background_texture.get(), device_rect))
     return scoped_ptr<ScopedResource>();
 
   SkBitmap filtered_device_background =
       ApplyFilters(this, filters, device_background_texture.get());
   if (!filtered_device_background.getTexture())
     return scoped_ptr<ScopedResource>();
 
   GrTexture* texture =
       reinterpret_cast<GrTexture*>(filtered_device_background.getTexture());
   int filtered_device_background_texture_id = texture->getTextureHandle();
 
   scoped_ptr<ScopedResource> background_texture =
       ScopedResource::create(resource_provider_);
   if (!background_texture->Allocate(quad->rect.size(),
                                     GL_RGBA,
                                     ResourceProvider::TextureUsageFramebuffer))
     return scoped_ptr<ScopedResource>();
 
-  const RenderPass* target_render_pass = frame.current_render_pass;
+  const RenderPass* target_render_pass = frame->current_render_pass;
   bool using_background_texture =
       UseScopedTexture(frame, background_texture.get(), quad->rect);
 
   if (using_background_texture) {
     // Copy the readback pixels from device to the background texture for the
     // surface.
     gfx::Transform device_to_framebuffer_transform;
     device_to_framebuffer_transform.Translate(
         quad->rect.width() * 0.5f + quad->rect.x(),
         quad->rect.height() * 0.5f + quad->rect.y());
@@ skipping 13 matching lines @@
                              device_to_framebuffer_transform);
   }
 
   UseRenderPass(frame, target_render_pass);
 
   if (!using_background_texture)
     return scoped_ptr<ScopedResource>();
   return background_texture.Pass();
 }
 
-void GLRenderer::DrawRenderPassQuad(DrawingFrame& frame,
+void GLRenderer::DrawRenderPassQuad(DrawingFrame* frame,
                                     const RenderPassDrawQuad* quad) {
   SetBlendEnabled(quad->ShouldDrawWithBlending());
 
   CachedResource* contents_texture =
       render_pass_textures_.get(quad->render_pass_id);
   if (!contents_texture || !contents_texture->id())
     return;
 
   gfx::Transform quad_rect_matrix;
   QuadRectTransform(&quad_rect_matrix, quad->quadTransform(), quad->rect);
   gfx::Transform contents_device_transform =
-      frame.window_matrix * frame.projection_matrix * quad_rect_matrix;
+      frame->window_matrix * frame->projection_matrix * quad_rect_matrix;
   contents_device_transform.FlattenTo2d();
 
   // Can only draw surface if device matrix is invertible.
   gfx::Transform contents_device_transform_inverse(
       gfx::Transform::kSkipInitialization);
   if (!contents_device_transform.GetInverse(&contents_device_transform_inverse))
     return;
 
   scoped_ptr<ScopedResource> background_texture =
       DrawBackgroundFilters(frame,
@@ skipping 287 matching lines @@
   DCHECK(did_invert);
   *local_quad = MathUtil::MapQuad(
       inverse_device_transform, device_quad.ToQuadF(), &clipped);
   // We should not DCHECK(!clipped) here, because anti-aliasing inflation may
   // cause device_quad to become clipped. To our knowledge this scenario does
   // not need to be handled differently than the unclipped case.
 
   return true;
 }
 
-void GLRenderer::DrawSolidColorQuad(const DrawingFrame& frame,
+void GLRenderer::DrawSolidColorQuad(const DrawingFrame* frame,
                                     const SolidColorDrawQuad* quad) {
   SetBlendEnabled(quad->ShouldDrawWithBlending());
   gfx::Rect tile_rect = quad->visible_rect;
 
   gfx::Transform device_transform =
-      frame.window_matrix * frame.projection_matrix * quad->quadTransform();
+      frame->window_matrix * frame->projection_matrix * quad->quadTransform();
   device_transform.FlattenTo2d();
   if (!device_transform.IsInvertible())
     return;
 
   gfx::QuadF local_quad = gfx::QuadF(gfx::RectF(tile_rect));
   float edge[24];
   bool use_aa = SetupQuadForAntialiasing(
       device_transform, quad, &local_quad, edge);
 
   SolidColorProgramUniforms uniforms;
@@ skipping 56 matching lines @@
   uniforms->matrix_location = program->vertex_shader().matrix_location();
   uniforms->point_location = program->vertex_shader().point_location();
 
   uniforms->sampler_location = program->fragment_shader().sampler_location();
   uniforms->alpha_location = program->fragment_shader().alpha_location();
   uniforms->fragment_tex_transform_location =
       program->fragment_shader().fragment_tex_transform_location();
   uniforms->edge_location = program->fragment_shader().edge_location();
 }
 
-void GLRenderer::DrawTileQuad(const DrawingFrame& frame,
+void GLRenderer::DrawTileQuad(const DrawingFrame* frame,
                               const TileDrawQuad* quad) {
   gfx::Rect tile_rect = quad->visible_rect;
 
   gfx::RectF tex_coord_rect = quad->tex_coord_rect;
   float tex_to_geom_scale_x = quad->rect.width() / tex_coord_rect.width();
   float tex_to_geom_scale_y = quad->rect.height() / tex_coord_rect.height();
 
   // tex_coord_rect corresponds to quad_rect, but quad_visible_rect may be
   // smaller than quad_rect due to occlusion or clipping. Adjust
   // tex_coord_rect to match.
@@ skipping 31 matching lines @@
   float vertex_tex_scale_y = tile_rect.height() / clamp_geom_rect.height();
 
   // Map to normalized texture coordinates.
   gfx::Size texture_size = quad->texture_size;
   float fragment_tex_translate_x = clamp_tex_rect.x() / texture_size.width();
   float fragment_tex_translate_y = clamp_tex_rect.y() / texture_size.height();
   float fragment_tex_scale_x = clamp_tex_rect.width() / texture_size.width();
   float fragment_tex_scale_y = clamp_tex_rect.height() / texture_size.height();
 
   gfx::Transform device_transform =
-      frame.window_matrix * frame.projection_matrix * quad->quadTransform();
+      frame->window_matrix * frame->projection_matrix * quad->quadTransform();
   device_transform.FlattenTo2d();
   if (!device_transform.IsInvertible())
     return;
 
   gfx::QuadF local_quad = gfx::QuadF(gfx::RectF(tile_rect));
   float edge[24];
   bool use_aa = SetupQuadForAntialiasing(
       device_transform, quad, &local_quad, edge);
 
   TileProgramUniforms uniforms;
@@ skipping 75 matching lines @@
   // un-antialiased quad should have and which vertex this is and the float
   // quad passed in via uniform is the actual geometry that gets used to draw
   // it. This is why this centered rect is used and not the original quad_rect.
   gfx::RectF centered_rect(
       gfx::PointF(-0.5f * tile_rect.width(), -0.5f * tile_rect.height()),
       tile_rect.size());
   DrawQuadGeometry(
       frame, quad->quadTransform(), centered_rect, uniforms.matrix_location);
 }
 
-void GLRenderer::DrawYUVVideoQuad(const DrawingFrame& frame,
+void GLRenderer::DrawYUVVideoQuad(const DrawingFrame* frame,
                                   const YUVVideoDrawQuad* quad) {
   SetBlendEnabled(quad->ShouldDrawWithBlending());
 
   const VideoYUVProgram* program = GetVideoYUVProgram();
   DCHECK(program && (program->initialized() || IsContextLost()));
 
   const VideoLayerImpl::FramePlane& y_plane = quad->y_plane;
   const VideoLayerImpl::FramePlane& u_plane = quad->u_plane;
   const VideoLayerImpl::FramePlane& v_plane = quad->v_plane;
 
@@ skipping 47 matching lines @@
                    program->fragment_shader().alpha_location());
   DrawQuadGeometry(frame,
                    quad->quadTransform(),
                    quad->rect,
                    program->vertex_shader().matrix_location());
 
   // Reset active texture back to texture 0.
   GLC(Context(), Context()->activeTexture(GL_TEXTURE0));
 }
 
-void GLRenderer::DrawStreamVideoQuad(const DrawingFrame& frame,
+void GLRenderer::DrawStreamVideoQuad(const DrawingFrame* frame,
                                      const StreamVideoDrawQuad* quad) {
   SetBlendEnabled(quad->ShouldDrawWithBlending());
 
   static float gl_matrix[16];
 
   DCHECK(capabilities_.using_egl_image);
 
   const VideoStreamTextureProgram* program = GetVideoStreamTextureProgram();
   SetUseProgram(program->program());
 
@@ skipping 113 matching lines @@
   if (!draw_cache_.use_premultiplied_alpha)
     GLC(context_, context_->blendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA));
 
   // Clear the cache.
   draw_cache_.program_id = 0;
   draw_cache_.uv_xform_data.resize(0);
   draw_cache_.vertex_opacity_data.resize(0);
   draw_cache_.matrix_data.resize(0);
 }
 
-void GLRenderer::EnqueueTextureQuad(const DrawingFrame& frame,
+void GLRenderer::EnqueueTextureQuad(const DrawingFrame* frame,
                                     const TextureDrawQuad* quad) {
   // Choose the correct texture program binding
   TexTransformTextureProgramBinding binding;
   if (quad->flipped)
     binding.Set(GetTextureProgramFlip(), Context());
   else
     binding.Set(GetTextureProgram(), Context());
 
   int resource_id = quad->resource_id;
 
@@ skipping 23 matching lines @@
   // Generate the vertex opacity
   const float opacity = quad->opacity();
   draw_cache_.vertex_opacity_data.push_back(quad->vertex_opacity[0] * opacity);
   draw_cache_.vertex_opacity_data.push_back(quad->vertex_opacity[1] * opacity);
   draw_cache_.vertex_opacity_data.push_back(quad->vertex_opacity[2] * opacity);
   draw_cache_.vertex_opacity_data.push_back(quad->vertex_opacity[3] * opacity);
 
   // Generate the transform matrix
   gfx::Transform quad_rect_matrix;
   QuadRectTransform(&quad_rect_matrix, quad->quadTransform(), quad->rect);
-  quad_rect_matrix = frame.projection_matrix * quad_rect_matrix;
+  quad_rect_matrix = frame->projection_matrix * quad_rect_matrix;
 
   Float16 m;
   quad_rect_matrix.matrix().asColMajorf(m.data);
   draw_cache_.matrix_data.push_back(m);
 }
 
-void GLRenderer::DrawTextureQuad(const DrawingFrame& frame,
+void GLRenderer::DrawTextureQuad(const DrawingFrame* frame,
                                  const TextureDrawQuad* quad) {
   TexTransformTextureProgramBinding binding;
   if (quad->flipped)
     binding.Set(GetTextureProgramFlip(), Context());
   else
     binding.Set(GetTextureProgram(), Context());
   SetUseProgram(binding.program_id);
   GLC(Context(), Context()->uniform1i(binding.sampler_location, 0));
   gfx::PointF uv0 = quad->uv_top_left;
   gfx::PointF uv1 = quad->uv_bottom_right;
@@ skipping 27 matching lines @@
             GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ZERO, GL_ONE));
   }
 
   DrawQuadGeometry(
       frame, quad->quadTransform(), quad->rect, binding.matrix_location);
 
   if (!quad->premultiplied_alpha)
     GLC(context_, context_->blendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA));
 }
 
-void GLRenderer::DrawIOSurfaceQuad(const DrawingFrame& frame,
+void GLRenderer::DrawIOSurfaceQuad(const DrawingFrame* frame,
                                    const IOSurfaceDrawQuad* quad) {
   SetBlendEnabled(quad->ShouldDrawWithBlending());
 
   TexTransformTextureProgramBinding binding;
   binding.Set(GetTextureIOSurfaceProgram(), Context());
 
   SetUseProgram(binding.program_id);
   GLC(Context(), Context()->uniform1i(binding.sampler_location, 0));
   if (quad->orientation == IOSurfaceDrawQuad::FLIPPED) {
     GLC(Context(),
@@ skipping 20 matching lines @@
   GLC(Context(),
       Context()->bindTexture(GL_TEXTURE_RECTANGLE_ARB,
                              quad->io_surface_texture_id));
 
   DrawQuadGeometry(
       frame, quad->quadTransform(), quad->rect, binding.matrix_location);
 
   GLC(Context(), Context()->bindTexture(GL_TEXTURE_RECTANGLE_ARB, 0));
 }
 
-void GLRenderer::FinishDrawingFrame(DrawingFrame& frame) {
+void GLRenderer::FinishDrawingFrame(DrawingFrame* frame) {
   current_framebuffer_lock_.reset();
-  swap_buffer_rect_.Union(gfx::ToEnclosingRect(frame.root_damage_rect));
+  swap_buffer_rect_.Union(gfx::ToEnclosingRect(frame->root_damage_rect));
 
   GLC(context_, context_->disable(GL_BLEND));
   blend_shadow_ = false;
 
   if (Settings().compositor_frame_message) {
     CompositorFrame compositor_frame;
     compositor_frame.metadata = client_->MakeCompositorFrameMetadata();
     output_surface_->SendFrameToParentCompositor(&compositor_frame);
   }
 }
@@ skipping 56 matching lines @@
   blend_shadow_ = enabled;
 }
 
 void GLRenderer::SetUseProgram(unsigned program) {
   if (program == program_shadow_)
     return;
   GLC(context_, context_->useProgram(program));
   program_shadow_ = program;
 }
 
-void GLRenderer::DrawQuadGeometry(const DrawingFrame& frame,
+void GLRenderer::DrawQuadGeometry(const DrawingFrame* frame,
                                   const gfx::Transform& draw_transform,
                                   const gfx::RectF& quad_rect,
                                   int matrix_location) {
   gfx::Transform quad_rect_matrix;
   QuadRectTransform(&quad_rect_matrix, draw_transform, quad_rect);
   static float gl_matrix[16];
-  ToGLMatrix(&gl_matrix[0], frame.projection_matrix * quad_rect_matrix);
+  ToGLMatrix(&gl_matrix[0], frame->projection_matrix * quad_rect_matrix);
   GLC(context_,
       context_->uniformMatrix4fv(matrix_location, 1, false, &gl_matrix[0]));
 
   GLC(context_, context_->drawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0));
 }
 
-void GLRenderer::CopyTextureToFramebuffer(const DrawingFrame& frame,
+void GLRenderer::CopyTextureToFramebuffer(const DrawingFrame* frame,
                                           int texture_id,
                                           gfx::Rect rect,
                                           const gfx::Transform& draw_matrix) {
   const RenderPassProgram* program = GetRenderPassProgram();
 
   GLC(Context(), Context()->bindTexture(GL_TEXTURE_2D, texture_id));
 
   SetUseProgram(program->program());
   GLC(Context(),
       Context()->uniform1i(program->fragment_shader().sampler_location(), 0));
@@ skipping 247 matching lines @@
                                0,
                                texture->format(),
                                device_rect.x(),
                                device_rect.y(),
                                device_rect.width(),
                                device_rect.height(),
                                0));
   return true;
 }
 
-bool GLRenderer::UseScopedTexture(DrawingFrame& frame,
+bool GLRenderer::UseScopedTexture(DrawingFrame* frame,
                                   const ScopedResource* texture,
                                   gfx::Rect viewport_rect) {
   DCHECK(texture->id());
-  frame.current_render_pass = 0;
-  frame.current_texture = texture;
+  frame->current_render_pass = NULL;
+  frame->current_texture = texture;
 
   return BindFramebufferToTexture(frame, texture, viewport_rect);
 }
 
-void GLRenderer::BindFramebufferToOutputSurface(DrawingFrame& frame) {
+void GLRenderer::BindFramebufferToOutputSurface(DrawingFrame* frame) {
   current_framebuffer_lock_.reset();
   output_surface_->BindFramebuffer();
 }
 
-bool GLRenderer::BindFramebufferToTexture(DrawingFrame& frame,
+bool GLRenderer::BindFramebufferToTexture(DrawingFrame* frame,
                                           const ScopedResource* texture,
                                           gfx::Rect framebuffer_rect) {
   DCHECK(texture->id());
 
   GLC(context_,
       context_->bindFramebuffer(GL_FRAMEBUFFER, offscreen_framebuffer_id_));
   current_framebuffer_lock_ =
       make_scoped_ptr(new ResourceProvider::ScopedWriteLockGL(
           resource_provider_, texture->id()));
   unsigned texture_id = current_framebuffer_lock_->texture_id();
@@ skipping 313 matching lines @@
     GLC(context_, context_->deleteFramebuffer(offscreen_framebuffer_id_));
 
   ReleaseRenderPassTextures();
 }
 
 bool GLRenderer::IsContextLost() {
   return (context_->getGraphicsResetStatusARB() != GL_NO_ERROR);
 }
 
 }  // namespace cc