cc: Remove GLC macro

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 <algorithm>
 #include <limits>
 #include <set>
 #include <string>
@@ skipping 364 matching lines @@
 
   in_use_overlay_resources_.clear();
 
   CleanupSharedObjects();
 }
 
 const RendererCapabilitiesImpl& GLRenderer::Capabilities() const {
   return capabilities_;
 }
 
-void GLRenderer::DebugGLCall(GLES2Interface* gl,
-                             const char* command,
-                             const char* file,
-                             int line) {
-  GLuint error = gl->GetError();
-  if (error != GL_NO_ERROR)
-    LOG(ERROR) << "GL command failed: File: " << file << "\n\tLine " << line
-               << "\n\tcommand: " << command << ", error "
-               << static_cast<int>(error) << "\n";
-}
-
 void GLRenderer::DidChangeVisibility() {
   EnforceMemoryPolicy();
 
   context_support_->SetSurfaceVisible(visible());
 }
 
 void GLRenderer::ReleaseRenderPassTextures() { render_pass_textures_.clear(); }
 
 void GLRenderer::DiscardPixels() {
   if (!capabilities_.using_discard_framebuffer)
@@ skipping 26 matching lines @@
       SetScissorTestRect(render_pass_scissor);
       ClearFramebuffer(frame);
       break;
   }
 }
 
 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)
-    GLC(gl_, gl_->ClearColor(0, 0, 0, 0));
+    gl_->ClearColor(0, 0, 0, 0);
   else
-    GLC(gl_, gl_->ClearColor(0, 0, 1, 1));
+    gl_->ClearColor(0, 0, 1, 1);
 
   bool always_clear = false;
 #ifndef NDEBUG
   always_clear = true;
 #endif
   if (always_clear || frame->current_render_pass->has_transparent_background) {
     GLbitfield clear_bits = GL_COLOR_BUFFER_BIT;
     if (always_clear)
       clear_bits |= GL_STENCIL_BUFFER_BIT;
     gl_->Clear(clear_bits);
@@ skipping 47 matching lines @@
   for (const auto& pass : *frame->render_passes_in_draw_order) {
     for (const auto& quad : pass->quad_list)
       quad->IterateResources(wait_on_resource_syncpoints_callback);
   }
 
   // TODO(enne): Do we need to reinitialize all of this state per frame?
   ReinitializeGLState();
 }
 
 void GLRenderer::DoNoOp() {
-  GLC(gl_, gl_->BindFramebuffer(GL_FRAMEBUFFER, 0));
-  GLC(gl_, gl_->Flush());
+  gl_->BindFramebuffer(GL_FRAMEBUFFER, 0);
+  gl_->Flush();
 }
 
 void GLRenderer::DoDrawQuad(DrawingFrame* frame,
                             const DrawQuad* quad,
                             const gfx::QuadF* clip_region) {
   DCHECK(quad->rect.Contains(quad->visible_rect));
   if (quad->material != DrawQuad::TEXTURE_CONTENT) {
     FlushTextureQuadCache(SHARED_BINDING);
   }
 
@@ skipping 56 matching lines @@
   if (clip_region) {
     return;
   }
   SetBlendEnabled(quad->ShouldDrawWithBlending());
 
   const TileCheckerboardProgram* program = GetTileCheckerboardProgram();
   DCHECK(program && (program->initialized() || IsContextLost()));
   SetUseProgram(program->program());
 
   SkColor color = quad->color;
-  GLC(gl_,
-      gl_->Uniform4f(program->fragment_shader().color_location(),
-                     SkColorGetR(color) * (1.0f / 255.0f),
-                     SkColorGetG(color) * (1.0f / 255.0f),
-                     SkColorGetB(color) * (1.0f / 255.0f),
-                     1));
+  gl_->Uniform4f(program->fragment_shader().color_location(),
+                 SkColorGetR(color) * (1.0f / 255.0f),
+                 SkColorGetG(color) * (1.0f / 255.0f),
+                 SkColorGetB(color) * (1.0f / 255.0f), 1);
 
   const int kCheckerboardWidth = 16;
   float frequency = 1.0f / kCheckerboardWidth;
 
   gfx::Rect tile_rect = quad->rect;
   float tex_offset_x =
       static_cast<int>(tile_rect.x() / quad->scale) % kCheckerboardWidth;
   float tex_offset_y =
       static_cast<int>(tile_rect.y() / quad->scale) % kCheckerboardWidth;
   float tex_scale_x = tile_rect.width() / quad->scale;
   float tex_scale_y = tile_rect.height() / quad->scale;
-  GLC(gl_,
-      gl_->Uniform4f(program->fragment_shader().tex_transform_location(),
-                     tex_offset_x,
-                     tex_offset_y,
-                     tex_scale_x,
-                     tex_scale_y));
+  gl_->Uniform4f(program->fragment_shader().tex_transform_location(),
+                 tex_offset_x, tex_offset_y, tex_scale_x, tex_scale_y);
 
-  GLC(gl_,
-      gl_->Uniform1f(program->fragment_shader().frequency_location(),
-                     frequency));
+  gl_->Uniform1f(program->fragment_shader().frequency_location(), frequency);
 
   SetShaderOpacity(quad->opacity(),
                    program->fragment_shader().alpha_location());
   DrawQuadGeometry(frame,
                    quad->quadTransform(),
                    quad->rect,
                    program->vertex_shader().matrix_location());
 }
 
 // This function does not handle 3D sorting right now, since the debug border
 // quads are just drawn as their original quads and not in split pieces. This
 // results in some debug border quads drawing over foreground quads.
 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;
   QuadRectTransform(&render_matrix, quad->quadTransform(), layer_rect);
   GLRenderer::ToGLMatrix(&gl_matrix[0],
                          frame->projection_matrix * render_matrix);
-  GLC(gl_,
-      gl_->UniformMatrix4fv(
-          program->vertex_shader().matrix_location(), 1, false, &gl_matrix[0]));
+  gl_->UniformMatrix4fv(program->vertex_shader().matrix_location(), 1, false,
+                        &gl_matrix[0]);
 
   SkColor color = quad->color;
   float alpha = SkColorGetA(color) * (1.0f / 255.0f);
 
-  GLC(gl_,
-      gl_->Uniform4f(program->fragment_shader().color_location(),
-                     (SkColorGetR(color) * (1.0f / 255.0f)) * alpha,
-                     (SkColorGetG(color) * (1.0f / 255.0f)) * alpha,
-                     (SkColorGetB(color) * (1.0f / 255.0f)) * alpha,
-                     alpha));
+  gl_->Uniform4f(program->fragment_shader().color_location(),
+                 (SkColorGetR(color) * (1.0f / 255.0f)) * alpha,
+                 (SkColorGetG(color) * (1.0f / 255.0f)) * alpha,
+                 (SkColorGetB(color) * (1.0f / 255.0f)) * alpha, alpha);
 
-  GLC(gl_, gl_->LineWidth(quad->width));
+  gl_->LineWidth(quad->width);
 
   // The indices for the line are stored in the same array as the triangle
   // indices.
-  GLC(gl_, gl_->DrawElements(GL_LINE_LOOP, 4, GL_UNSIGNED_SHORT, 0));
+  gl_->DrawElements(GL_LINE_LOOP, 4, GL_UNSIGNED_SHORT, 0);
 }
 
 static skia::RefPtr<SkImage> ApplyImageFilter(
     scoped_ptr<GLRenderer::ScopedUseGrContext> use_gr_context,
     ResourceProvider* resource_provider,
     const gfx::Rect& rect,
     const gfx::Vector2dF& scale,
     SkImageFilter* filter,
     ScopedResource* source_texture_resource) {
   if (!filter)
@@ skipping 139 matching lines @@
       case SkXfermode::kColor_Mode:
         equation = GL_HSL_COLOR_KHR;
         break;
       case SkXfermode::kLuminosity_Mode:
         equation = GL_HSL_LUMINOSITY_KHR;
         break;
       default:
         return;
     }
 
-    GLC(gl_, gl_->BlendEquation(equation));
+    gl_->BlendEquation(equation);
   } else {
     if (blend_mode == SkXfermode::kScreen_Mode) {
-      GLC(gl_, gl_->BlendFunc(GL_ONE_MINUS_DST_COLOR, GL_ONE));
+      gl_->BlendFunc(GL_ONE_MINUS_DST_COLOR, GL_ONE);
     }
   }
 }
 
 void GLRenderer::RestoreBlendFuncToDefault(SkXfermode::Mode blend_mode) {
   if (blend_mode == SkXfermode::kSrcOver_Mode)
     return;
 
   if (use_blend_equation_advanced_) {
-    GLC(gl_, gl_->BlendEquation(GL_FUNC_ADD));
+    gl_->BlendEquation(GL_FUNC_ADD);
   } else {
-    GLC(gl_, gl_->BlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA));
+    gl_->BlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
   }
 }
 
 bool GLRenderer::ShouldApplyBackgroundFilters(DrawingFrame* frame,
                                               const RenderPassDrawQuad* quad) {
   if (quad->background_filters.IsEmpty())
     return false;
 
   // TODO(danakj): We only allow background filters on an opaque render surface
   // because other surfaces may contain translucent pixels, and the contents
@@ skipping 237 matching lines @@
   } else {
     contents_resource_lock =
         make_scoped_ptr(new ResourceProvider::ScopedSamplerGL(
             resource_provider_, contents_texture->id(), GL_LINEAR));
     DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D),
               contents_resource_lock->target());
   }
 
   if (!use_shaders_for_blending) {
     if (!use_blend_equation_advanced_coherent_ && use_blend_equation_advanced_)
-      GLC(gl_, gl_->BlendBarrierKHR());
+      gl_->BlendBarrierKHR();
 
     ApplyBlendModeUsingBlendFunc(blend_mode);
   }
 
   TexCoordPrecision tex_coord_precision = TexCoordPrecisionRequired(
       gl_,
       &highp_threshold_cache_,
       highp_threshold_min_,
       quad->shared_quad_state->visible_content_rect.bottom_right());
 
   ShaderLocations locations;
 
   DCHECK_EQ(background_texture || background_image, use_shaders_for_blending);
   BlendMode shader_blend_mode = use_shaders_for_blending
                                     ? BlendModeFromSkXfermode(blend_mode)
                                     : BLEND_MODE_NONE;
 
   if (use_aa && mask_texture_id && !use_color_matrix) {
     const RenderPassMaskProgramAA* program = GetRenderPassMaskProgramAA(
         tex_coord_precision, mask_sampler,
         shader_blend_mode, mask_for_background);
     SetUseProgram(program->program());
     program->vertex_shader().FillLocations(&locations);
     program->fragment_shader().FillLocations(&locations);
-    GLC(gl_, gl_->Uniform1i(locations.sampler, 0));
+    gl_->Uniform1i(locations.sampler, 0);
   } else if (!use_aa && mask_texture_id && !use_color_matrix) {
     const RenderPassMaskProgram* program = GetRenderPassMaskProgram(
         tex_coord_precision, mask_sampler,
         shader_blend_mode, mask_for_background);
     SetUseProgram(program->program());
     program->vertex_shader().FillLocations(&locations);
     program->fragment_shader().FillLocations(&locations);
-    GLC(gl_, gl_->Uniform1i(locations.sampler, 0));
+    gl_->Uniform1i(locations.sampler, 0);
   } else if (use_aa && !mask_texture_id && !use_color_matrix) {
     const RenderPassProgramAA* program =
         GetRenderPassProgramAA(tex_coord_precision, shader_blend_mode);
     SetUseProgram(program->program());
     program->vertex_shader().FillLocations(&locations);
     program->fragment_shader().FillLocations(&locations);
-    GLC(gl_, gl_->Uniform1i(locations.sampler, 0));
+    gl_->Uniform1i(locations.sampler, 0);
   } else if (use_aa && mask_texture_id && use_color_matrix) {
     const RenderPassMaskColorMatrixProgramAA* program =
         GetRenderPassMaskColorMatrixProgramAA(
             tex_coord_precision, mask_sampler,
             shader_blend_mode, mask_for_background);
     SetUseProgram(program->program());
     program->vertex_shader().FillLocations(&locations);
     program->fragment_shader().FillLocations(&locations);
-    GLC(gl_, gl_->Uniform1i(locations.sampler, 0));
+    gl_->Uniform1i(locations.sampler, 0);
   } else if (use_aa && !mask_texture_id && use_color_matrix) {
     const RenderPassColorMatrixProgramAA* program =
         GetRenderPassColorMatrixProgramAA(tex_coord_precision,
                                           shader_blend_mode);
     SetUseProgram(program->program());
     program->vertex_shader().FillLocations(&locations);
     program->fragment_shader().FillLocations(&locations);
-    GLC(gl_, gl_->Uniform1i(locations.sampler, 0));
+    gl_->Uniform1i(locations.sampler, 0);
   } else if (!use_aa && mask_texture_id && use_color_matrix) {
     const RenderPassMaskColorMatrixProgram* program =
         GetRenderPassMaskColorMatrixProgram(
             tex_coord_precision, mask_sampler,
             shader_blend_mode, mask_for_background);
     SetUseProgram(program->program());
     program->vertex_shader().FillLocations(&locations);
     program->fragment_shader().FillLocations(&locations);
-    GLC(gl_, gl_->Uniform1i(locations.sampler, 0));
+    gl_->Uniform1i(locations.sampler, 0);
   } else if (!use_aa && !mask_texture_id && use_color_matrix) {
     const RenderPassColorMatrixProgram* program =
         GetRenderPassColorMatrixProgram(tex_coord_precision, shader_blend_mode);
     SetUseProgram(program->program());
     program->vertex_shader().FillLocations(&locations);
     program->fragment_shader().FillLocations(&locations);
-    GLC(gl_, gl_->Uniform1i(locations.sampler, 0));
+    gl_->Uniform1i(locations.sampler, 0);
   } else {
     const RenderPassProgram* program =
         GetRenderPassProgram(tex_coord_precision, shader_blend_mode);
     SetUseProgram(program->program());
     program->vertex_shader().FillLocations(&locations);
     program->fragment_shader().FillLocations(&locations);
-    GLC(gl_, gl_->Uniform1i(locations.sampler, 0));
+    gl_->Uniform1i(locations.sampler, 0);
   }
   float tex_scale_x =
       quad->rect.width() / static_cast<float>(contents_texture->size().width());
   float tex_scale_y = quad->rect.height() /
                       static_cast<float>(contents_texture->size().height());
   DCHECK_LE(tex_scale_x, 1.0f);
   DCHECK_LE(tex_scale_y, 1.0f);
 
   DCHECK(locations.tex_transform != -1 || IsContextLost());
   // Flip the content vertically in the shader, as the RenderPass input
   // texture is already oriented the same way as the framebuffer, but the
   // projection transform does a flip.
-  GLC(gl_,
-      gl_->Uniform4f(locations.tex_transform,
-                     0.0f,
-                     tex_scale_y,
-                     tex_scale_x,
-                     -tex_scale_y));
+  gl_->Uniform4f(locations.tex_transform, 0.0f, tex_scale_y, tex_scale_x,
+                 -tex_scale_y);
 
   GLint last_texture_unit = 0;
   if (locations.mask_sampler != -1) {
     DCHECK_NE(locations.mask_tex_coord_scale, 1);
     DCHECK_NE(locations.mask_tex_coord_offset, 1);
-    GLC(gl_, gl_->Uniform1i(locations.mask_sampler, 1));
+    gl_->Uniform1i(locations.mask_sampler, 1);
 
     gfx::RectF mask_uv_rect = quad->MaskUVRect();
     if (mask_sampler != SAMPLER_TYPE_2D) {
       mask_uv_rect.Scale(quad->mask_texture_size.width(),
                          quad->mask_texture_size.height());
     }
 
     // Mask textures are oriented vertically flipped relative to the framebuffer
     // and the RenderPass contents texture, so we flip the tex coords from the
     // RenderPass texture to find the mask texture coords.
-    GLC(gl_,
-        gl_->Uniform2f(locations.mask_tex_coord_offset,
-                       mask_uv_rect.x(),
-                       mask_uv_rect.bottom()));
-    GLC(gl_,
-        gl_->Uniform2f(locations.mask_tex_coord_scale,
-                       mask_uv_rect.width() / tex_scale_x,
-                       -mask_uv_rect.height() / tex_scale_y));
+    gl_->Uniform2f(locations.mask_tex_coord_offset, mask_uv_rect.x(),
+                   mask_uv_rect.bottom());
+    gl_->Uniform2f(locations.mask_tex_coord_scale,
+                   mask_uv_rect.width() / tex_scale_x,
+                   -mask_uv_rect.height() / tex_scale_y);
 
     last_texture_unit = 1;
   }
 
   if (locations.edge != -1)
-    GLC(gl_, gl_->Uniform3fv(locations.edge, 8, edge));
+    gl_->Uniform3fv(locations.edge, 8, edge);
 
   if (locations.viewport != -1) {
     float viewport[4] = {
         static_cast<float>(current_window_space_viewport_.x()),
         static_cast<float>(current_window_space_viewport_.y()),
         static_cast<float>(current_window_space_viewport_.width()),
         static_cast<float>(current_window_space_viewport_.height()),
     };
-    GLC(gl_, gl_->Uniform4fv(locations.viewport, 1, viewport));
+    gl_->Uniform4fv(locations.viewport, 1, viewport);
   }
 
   if (locations.color_matrix != -1) {
     float matrix[16];
     for (int i = 0; i < 4; ++i) {
       for (int j = 0; j < 4; ++j)
         matrix[i * 4 + j] = SkScalarToFloat(color_matrix[j * 5 + i]);
     }
-    GLC(gl_,
-        gl_->UniformMatrix4fv(locations.color_matrix, 1, false, matrix));
+    gl_->UniformMatrix4fv(locations.color_matrix, 1, false, matrix);
   }
   static const float kScale = 1.0f / 255.0f;
   if (locations.color_offset != -1) {
     float offset[4];
     for (int i = 0; i < 4; ++i)
       offset[i] = SkScalarToFloat(color_matrix[i * 5 + 4]) * kScale;
 
-    GLC(gl_, gl_->Uniform4fv(locations.color_offset, 1, offset));
+    gl_->Uniform4fv(locations.color_offset, 1, offset);
   }
 
   scoped_ptr<ResourceProvider::ScopedSamplerGL> shader_background_sampler_lock;
   if (locations.backdrop != -1) {
     DCHECK(background_texture || background_image);
     DCHECK_NE(locations.backdrop, 0);
     DCHECK_NE(locations.backdrop_rect, 0);
 
-    GLC(gl_, gl_->Uniform1i(locations.backdrop, ++last_texture_unit));
+    gl_->Uniform1i(locations.backdrop, ++last_texture_unit);
 
-    GLC(gl_,
-        gl_->Uniform4f(locations.backdrop_rect,
-                       background_rect.x(),
-                       background_rect.y(),
-                       background_rect.width(),
-                       background_rect.height()));
+    gl_->Uniform4f(locations.backdrop_rect, background_rect.x(),
+                   background_rect.y(), background_rect.width(),
+                   background_rect.height());
 
     if (background_image) {
       GrTexture* texture = background_image->getTexture();
-      GLC(gl_, gl_->ActiveTexture(GL_TEXTURE0 + last_texture_unit));
+      gl_->ActiveTexture(GL_TEXTURE0 + last_texture_unit);
       gl_->BindTexture(GL_TEXTURE_2D, texture->getTextureHandle());
-      GLC(gl_, gl_->ActiveTexture(GL_TEXTURE0));
+      gl_->ActiveTexture(GL_TEXTURE0);
       if (mask_for_background)
-        GLC(gl_, gl_->Uniform1i(locations.original_backdrop,
-                                ++last_texture_unit));
+        gl_->Uniform1i(locations.original_backdrop, ++last_texture_unit);
     }
     if (background_texture) {
       shader_background_sampler_lock = make_scoped_ptr(
           new ResourceProvider::ScopedSamplerGL(resource_provider_,
                                                 background_texture->id(),
                                                 GL_TEXTURE0 + last_texture_unit,
                                                 GL_LINEAR));
       DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D),
                 shader_background_sampler_lock->target());
     }
   }
 
   SetShaderOpacity(quad->opacity(), locations.alpha);
   SetShaderQuadF(surface_quad, locations.quad);
   DrawQuadGeometry(
       frame, quad->quadTransform(), quad->rect, locations.matrix);
 
   // Flush the compositor context before the filter bitmap goes out of
   // scope, so the draw gets processed before the filter texture gets deleted.
   if (filter_image)
-    GLC(gl_, gl_->Flush());
+    gl_->Flush();
 
   if (!use_shaders_for_blending)
     RestoreBlendFuncToDefault(blend_mode);
 }
 
 struct SolidColorProgramUniforms {
   unsigned program;
   unsigned matrix_location;
   unsigned viewport_location;
   unsigned quad_location;
@@ skipping 292 matching lines @@
                                       clip_region, &local_quad, edge);
 
   SolidColorProgramUniforms uniforms;
   if (use_aa) {
     SolidColorUniformLocation(GetSolidColorProgramAA(), &uniforms);
   } else {
     SolidColorUniformLocation(GetSolidColorProgram(), &uniforms);
   }
   SetUseProgram(uniforms.program);
 
-  GLC(gl_,
-      gl_->Uniform4f(uniforms.color_location,
-                     (SkColorGetR(color) * (1.0f / 255.0f)) * alpha,
-                     (SkColorGetG(color) * (1.0f / 255.0f)) * alpha,
-                     (SkColorGetB(color) * (1.0f / 255.0f)) * alpha,
-                     alpha));
+  gl_->Uniform4f(uniforms.color_location,
+                 (SkColorGetR(color) * (1.0f / 255.0f)) * alpha,
+                 (SkColorGetG(color) * (1.0f / 255.0f)) * alpha,
+                 (SkColorGetB(color) * (1.0f / 255.0f)) * alpha, alpha);
   if (use_aa) {
     float viewport[4] = {
         static_cast<float>(current_window_space_viewport_.x()),
         static_cast<float>(current_window_space_viewport_.y()),
         static_cast<float>(current_window_space_viewport_.width()),
         static_cast<float>(current_window_space_viewport_.height()),
     };
-    GLC(gl_, gl_->Uniform4fv(uniforms.viewport_location, 1, viewport));
-    GLC(gl_, gl_->Uniform3fv(uniforms.edge_location, 8, edge));
+    gl_->Uniform4fv(uniforms.viewport_location, 1, viewport);
+    gl_->Uniform3fv(uniforms.edge_location, 8, edge);
   }
 
   // Enable blending when the quad properties require it or if we decided
   // to use antialiasing.
   SetBlendEnabled(quad->ShouldDrawWithBlending() || use_aa);
 
   // Normalize to tile_rect.
   local_quad.Scale(1.0f / tile_rect.width(), 1.0f / tile_rect.height());
 
   SetShaderQuadF(local_quad, uniforms.quad_location);
@@ skipping 138 matching lines @@
   TileProgramUniforms uniforms;
   if (quad->swizzle_contents) {
     TileUniformLocation(GetTileProgramSwizzleAA(tex_coord_precision, sampler),
                         &uniforms);
   } else {
     TileUniformLocation(GetTileProgramAA(tex_coord_precision, sampler),
                         &uniforms);
   }
 
   SetUseProgram(uniforms.program);
-  GLC(gl_, gl_->Uniform1i(uniforms.sampler_location, 0));
+  gl_->Uniform1i(uniforms.sampler_location, 0);
 
   float viewport[4] = {
       static_cast<float>(current_window_space_viewport_.x()),
       static_cast<float>(current_window_space_viewport_.y()),
       static_cast<float>(current_window_space_viewport_.width()),
       static_cast<float>(current_window_space_viewport_.height()),
   };
-  GLC(gl_, gl_->Uniform4fv(uniforms.viewport_location, 1, viewport));
-  GLC(gl_, gl_->Uniform3fv(uniforms.edge_location, 8, edge));
+  gl_->Uniform4fv(uniforms.viewport_location, 1, viewport);
+  gl_->Uniform3fv(uniforms.edge_location, 8, edge);
 
-  GLC(gl_,
-      gl_->Uniform4f(uniforms.vertex_tex_transform_location,
-                     vertex_tex_translate_x,
-                     vertex_tex_translate_y,
-                     vertex_tex_scale_x,
-                     vertex_tex_scale_y));
-  GLC(gl_,
-      gl_->Uniform4f(uniforms.fragment_tex_transform_location,
-                     fragment_tex_translate_x,
-                     fragment_tex_translate_y,
-                     fragment_tex_scale_x,
-                     fragment_tex_scale_y));
+  gl_->Uniform4f(uniforms.vertex_tex_transform_location, vertex_tex_translate_x,
+                 vertex_tex_translate_y, vertex_tex_scale_x,
+                 vertex_tex_scale_y);
+  gl_->Uniform4f(uniforms.fragment_tex_transform_location,
+                 fragment_tex_translate_x, fragment_tex_translate_y,
+                 fragment_tex_scale_x, fragment_tex_scale_y);
 
   // Blending is required for antialiasing.
   SetBlendEnabled(true);
 
   // Normalize to tile_rect.
   local_quad.Scale(1.0f / tile_rect.width(), 1.0f / tile_rect.height());
 
   SetShaderOpacity(quad->opacity(), uniforms.alpha_location);
   SetShaderQuadF(local_quad, uniforms.quad_location);
 
@@ skipping 61 matching lines @@
     if (quad->swizzle_contents) {
       TileUniformLocation(
           GetTileProgramSwizzleOpaque(tex_coord_precision, sampler), &uniforms);
     } else {
       TileUniformLocation(GetTileProgramOpaque(tex_coord_precision, sampler),
                           &uniforms);
     }
   }
 
   SetUseProgram(uniforms.program);
-  GLC(gl_, gl_->Uniform1i(uniforms.sampler_location, 0));
+  gl_->Uniform1i(uniforms.sampler_location, 0);
 
-  GLC(gl_,
-      gl_->Uniform4f(uniforms.vertex_tex_transform_location,
-                     vertex_tex_translate_x,
-                     vertex_tex_translate_y,
-                     vertex_tex_scale_x,
-                     vertex_tex_scale_y));
+  gl_->Uniform4f(uniforms.vertex_tex_transform_location, vertex_tex_translate_x,
+                 vertex_tex_translate_y, vertex_tex_scale_x,
+                 vertex_tex_scale_y);
 
   SetBlendEnabled(quad->ShouldDrawWithBlending());
 
   SetShaderOpacity(quad->opacity(), uniforms.alpha_location);
 
   // Pass quad coordinates to the uniform in the same order as GeometryBinding
   // does, then vertices will match the texture mapping in the vertex buffer.
   // The method SetShaderQuadF() changes the order of vertices and so it's
   // not used here.
   gfx::QuadF tile_rect(quad->visible_rect);
@@ skipping 21 matching lines @@
   float gl_quad[8] = {
       tile_rect.p4().x(),
       tile_rect.p4().y(),
       tile_rect.p1().x(),
       tile_rect.p1().y(),
       tile_rect.p2().x(),
       tile_rect.p2().y(),
       tile_rect.p3().x(),
       tile_rect.p3().y(),
   };
-  GLC(gl_, gl_->Uniform2fv(uniforms.quad_location, 4, gl_quad));
+  gl_->Uniform2fv(uniforms.quad_location, 4, gl_quad);
 
   static float gl_matrix[16];
   ToGLMatrix(&gl_matrix[0], frame->projection_matrix * quad->quadTransform());
-  GLC(gl_,
-      gl_->UniformMatrix4fv(uniforms.matrix_location, 1, false, &gl_matrix[0]));
+  gl_->UniformMatrix4fv(uniforms.matrix_location, 1, false, &gl_matrix[0]);
 
-  GLC(gl_, gl_->DrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0));
+  gl_->DrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0);
 }
 
 void GLRenderer::DrawYUVVideoQuad(const DrawingFrame* frame,
                                   const YUVVideoDrawQuad* quad,
                                   const gfx::QuadF* clip_region) {
   SetBlendEnabled(quad->ShouldDrawWithBlending());
 
   TexCoordPrecision tex_coord_precision = TexCoordPrecisionRequired(
       gl_,
       &highp_threshold_cache_,
@@ skipping 60 matching lines @@
     v_texture_location = program->fragment_shader().v_texture_location();
     yuv_matrix_location = program->fragment_shader().yuv_matrix_location();
     yuv_adj_location = program->fragment_shader().yuv_adj_location();
     ya_clamp_rect_location =
         program->fragment_shader().ya_clamp_rect_location();
     uv_clamp_rect_location =
         program->fragment_shader().uv_clamp_rect_location();
     alpha_location = program->fragment_shader().alpha_location();
   }
 
-  GLC(gl_,
-      gl_->Uniform2f(tex_scale_location,
-                     quad->tex_coord_rect.width(),
-                     quad->tex_coord_rect.height()));
-  GLC(gl_,
-      gl_->Uniform2f(tex_offset_location,
-                     quad->tex_coord_rect.x(),
-                     quad->tex_coord_rect.y()));
+  gl_->Uniform2f(tex_scale_location, quad->tex_coord_rect.width(),
+                 quad->tex_coord_rect.height());
+  gl_->Uniform2f(tex_offset_location, quad->tex_coord_rect.x(),
+                 quad->tex_coord_rect.y());
   // Clamping to half a texel inside the tex coord rect prevents bilinear
   // filtering from filtering outside the tex coord rect.
   gfx::RectF ya_clamp_rect(quad->tex_coord_rect);
   // Special case: empty texture size implies no clamping.
   if (!quad->ya_tex_size.IsEmpty()) {
     ya_clamp_rect.Inset(0.5f / quad->ya_tex_size.width(),
                         0.5f / quad->ya_tex_size.height());
   }
   gfx::RectF uv_clamp_rect(quad->tex_coord_rect);
   if (!quad->uv_tex_size.IsEmpty()) {
     uv_clamp_rect.Inset(0.5f / quad->uv_tex_size.width(),
                         0.5f / quad->uv_tex_size.height());
   }
-  GLC(gl_, gl_->Uniform4f(ya_clamp_rect_location, ya_clamp_rect.x(),
-                          ya_clamp_rect.y(), ya_clamp_rect.right(),
-                          ya_clamp_rect.bottom()));
-  GLC(gl_, gl_->Uniform4f(uv_clamp_rect_location, uv_clamp_rect.x(),
-                          uv_clamp_rect.y(), uv_clamp_rect.right(),
-                          uv_clamp_rect.bottom()));
+  gl_->Uniform4f(ya_clamp_rect_location, ya_clamp_rect.x(), ya_clamp_rect.y(),
+                 ya_clamp_rect.right(), ya_clamp_rect.bottom());
+  gl_->Uniform4f(uv_clamp_rect_location, uv_clamp_rect.x(), uv_clamp_rect.y(),
+                 uv_clamp_rect.right(), uv_clamp_rect.bottom());
 
-  GLC(gl_, gl_->Uniform1i(y_texture_location, 1));
-  GLC(gl_, gl_->Uniform1i(u_texture_location, 2));
-  GLC(gl_, gl_->Uniform1i(v_texture_location, 3));
+  gl_->Uniform1i(y_texture_location, 1);
+  gl_->Uniform1i(u_texture_location, 2);
+  gl_->Uniform1i(v_texture_location, 3);
   if (use_alpha_plane)
-    GLC(gl_, gl_->Uniform1i(a_texture_location, 4));
+    gl_->Uniform1i(a_texture_location, 4);
 
   // These values are magic numbers that are used in the transformation from YUV
   // to RGB color values.  They are taken from the following webpage:
   // http://www.fourcc.org/fccyvrgb.php
   float yuv_to_rgb_rec601[9] = {
       1.164f, 1.164f, 1.164f, 0.0f, -.391f, 2.018f, 1.596f, -.813f, 0.0f,
   };
   float yuv_to_rgb_jpeg[9] = {
       1.f, 1.f, 1.f, 0.0f, -.34414f, 1.772f, 1.402f, -.71414f, 0.0f,
   };
@@ skipping 32 matching lines @@
       yuv_to_rgb = yuv_to_rgb_jpeg;
       yuv_adjust = yuv_adjust_full;
       break;
   }
 
   // The transform and vertex data are used to figure out the extents that the
   // 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 tile_rect = quad->rect;
-  GLC(gl_, gl_->UniformMatrix3fv(yuv_matrix_location, 1, 0, yuv_to_rgb));
-  GLC(gl_, gl_->Uniform3fv(yuv_adj_location, 1, yuv_adjust));
+  gl_->UniformMatrix3fv(yuv_matrix_location, 1, 0, yuv_to_rgb);
+  gl_->Uniform3fv(yuv_adj_location, 1, yuv_adjust);
 
   SetShaderOpacity(quad->opacity(), alpha_location);
   if (!clip_region) {
     DrawQuadGeometry(frame, quad->quadTransform(), tile_rect, matrix_location);
   } else {
     float uvs[8] = {0};
     GetScaledUVs(quad->visible_rect, clip_region, uvs);
     gfx::QuadF region_quad = *clip_region;
     region_quad.Scale(1.0f / tile_rect.width(), 1.0f / tile_rect.height());
     region_quad -= gfx::Vector2dF(0.5f, 0.5f);
@@ skipping 15 matching lines @@
       gl_,
       &highp_threshold_cache_,
       highp_threshold_min_,
       quad->shared_quad_state->visible_content_rect.bottom_right());
 
   const VideoStreamTextureProgram* program =
       GetVideoStreamTextureProgram(tex_coord_precision);
   SetUseProgram(program->program());
 
   ToGLMatrix(&gl_matrix[0], quad->matrix);
-  GLC(gl_,
-      gl_->UniformMatrix4fv(
-          program->vertex_shader().tex_matrix_location(), 1, false, gl_matrix));
+  gl_->UniformMatrix4fv(program->vertex_shader().tex_matrix_location(), 1,
+                        false, gl_matrix);
 
   ResourceProvider::ScopedReadLockGL lock(resource_provider_,
                                           quad->resource_id);
   DCHECK_EQ(GL_TEXTURE0, GetActiveTextureUnit(gl_));
-  GLC(gl_, gl_->BindTexture(GL_TEXTURE_EXTERNAL_OES, lock.texture_id()));
+  gl_->BindTexture(GL_TEXTURE_EXTERNAL_OES, lock.texture_id());
 
-  GLC(gl_, gl_->Uniform1i(program->fragment_shader().sampler_location(), 0));
+  gl_->Uniform1i(program->fragment_shader().sampler_location(), 0);
 
   SetShaderOpacity(quad->opacity(),
                    program->fragment_shader().alpha_location());
   if (!clip_region) {
     DrawQuadGeometry(frame, quad->quadTransform(), quad->rect,
                      program->vertex_shader().matrix_location());
   } else {
     gfx::QuadF region_quad(*clip_region);
     region_quad.Scale(1.0f / quad->rect.width(), 1.0f / quad->rect.height());
     region_quad -= gfx::Vector2dF(0.5f, 0.5f);
@@ skipping 41 matching lines @@
 
   PrepareGeometry(flush_binding);
 
   // Set the correct blending mode.
   SetBlendEnabled(draw_cache_.needs_blending);
 
   // Bind the program to the GL state.
   SetUseProgram(draw_cache_.program_id);
 
   // Bind the correct texture sampler location.
-  GLC(gl_, gl_->Uniform1i(draw_cache_.sampler_location, 0));
+  gl_->Uniform1i(draw_cache_.sampler_location, 0);
 
   // Assume the current active textures is 0.
   ResourceProvider::ScopedSamplerGL locked_quad(
       resource_provider_,
       draw_cache_.resource_id,
       draw_cache_.nearest_neighbor ? GL_NEAREST : GL_LINEAR);
   DCHECK_EQ(GL_TEXTURE0, GetActiveTextureUnit(gl_));
-  GLC(gl_, gl_->BindTexture(GL_TEXTURE_2D, locked_quad.texture_id()));
+  gl_->BindTexture(GL_TEXTURE_2D, locked_quad.texture_id());
 
   static_assert(sizeof(Float4) == 4 * sizeof(float),
                 "Float4 struct should be densely packed");
   static_assert(sizeof(Float16) == 16 * sizeof(float),
                 "Float16 struct should be densely packed");
 
   // Upload the tranforms for both points and uvs.
-  GLC(gl_,
-      gl_->UniformMatrix4fv(
-          static_cast<int>(draw_cache_.matrix_location),
-          static_cast<int>(draw_cache_.matrix_data.size()),
-          false,
-          reinterpret_cast<float*>(&draw_cache_.matrix_data.front())));
-  GLC(gl_,
-      gl_->Uniform4fv(
-          static_cast<int>(draw_cache_.uv_xform_location),
-          static_cast<int>(draw_cache_.uv_xform_data.size()),
-          reinterpret_cast<float*>(&draw_cache_.uv_xform_data.front())));
+  gl_->UniformMatrix4fv(
+      static_cast<int>(draw_cache_.matrix_location),
+      static_cast<int>(draw_cache_.matrix_data.size()), false,
+      reinterpret_cast<float*>(&draw_cache_.matrix_data.front()));
+  gl_->Uniform4fv(static_cast<int>(draw_cache_.uv_xform_location),
+                  static_cast<int>(draw_cache_.uv_xform_data.size()),
+                  reinterpret_cast<float*>(&draw_cache_.uv_xform_data.front()));
 
   if (draw_cache_.background_color != SK_ColorTRANSPARENT) {
     Float4 background_color = PremultipliedColor(draw_cache_.background_color);
-    GLC(gl_,
-        gl_->Uniform4fv(
-            draw_cache_.background_color_location, 1, background_color.data));
+    gl_->Uniform4fv(draw_cache_.background_color_location, 1,
+                    background_color.data);
   }
 
-  GLC(gl_,
-      gl_->Uniform1fv(
-          static_cast<int>(draw_cache_.vertex_opacity_location),
-          static_cast<int>(draw_cache_.vertex_opacity_data.size()),
-          static_cast<float*>(&draw_cache_.vertex_opacity_data.front())));
+  gl_->Uniform1fv(
+      static_cast<int>(draw_cache_.vertex_opacity_location),
+      static_cast<int>(draw_cache_.vertex_opacity_data.size()),
+      static_cast<float*>(&draw_cache_.vertex_opacity_data.front()));
 
   // Draw the quads!
-  GLC(gl_,
-      gl_->DrawElements(GL_TRIANGLES,
-                        6 * draw_cache_.matrix_data.size(),
-                        GL_UNSIGNED_SHORT,
-                        0));
+  gl_->DrawElements(GL_TRIANGLES, 6 * draw_cache_.matrix_data.size(),
+                    GL_UNSIGNED_SHORT, 0);
 
   // Clear the cache.
   draw_cache_.program_id = -1;
   draw_cache_.uv_xform_data.resize(0);
   draw_cache_.vertex_opacity_data.resize(0);
   draw_cache_.matrix_data.resize(0);
 
   // If we had a clipped binding, prepare the shared binding for the
   // next inserts.
   if (flush_binding == CLIPPED_BINDING) {
@@ skipping 112 matching lines @@
   TexCoordPrecision tex_coord_precision = TexCoordPrecisionRequired(
       gl_,
       &highp_threshold_cache_,
       highp_threshold_min_,
       quad->shared_quad_state->visible_content_rect.bottom_right());
 
   TexTransformTextureProgramBinding binding;
   binding.Set(GetTextureIOSurfaceProgram(tex_coord_precision));
 
   SetUseProgram(binding.program_id);
-  GLC(gl_, gl_->Uniform1i(binding.sampler_location, 0));
+  gl_->Uniform1i(binding.sampler_location, 0);
   if (quad->orientation == IOSurfaceDrawQuad::FLIPPED) {
-    GLC(gl_,
-        gl_->Uniform4f(binding.tex_transform_location,
-                       0,
-                       quad->io_surface_size.height(),
-                       quad->io_surface_size.width(),
-                       quad->io_surface_size.height() * -1.0f));
+    gl_->Uniform4f(
+        binding.tex_transform_location, 0, quad->io_surface_size.height(),
+        quad->io_surface_size.width(), quad->io_surface_size.height() * -1.0f);
   } else {
-    GLC(gl_,
-        gl_->Uniform4f(binding.tex_transform_location,
-                       0,
-                       0,
-                       quad->io_surface_size.width(),
-                       quad->io_surface_size.height()));
+    gl_->Uniform4f(binding.tex_transform_location, 0, 0,
+                   quad->io_surface_size.width(),
+                   quad->io_surface_size.height());
   }
 
   const float vertex_opacity[] = {quad->opacity(), quad->opacity(),
                                   quad->opacity(), quad->opacity()};
-  GLC(gl_, gl_->Uniform1fv(binding.vertex_opacity_location, 4, vertex_opacity));
+  gl_->Uniform1fv(binding.vertex_opacity_location, 4, vertex_opacity);
 
   ResourceProvider::ScopedReadLockGL lock(resource_provider_,
                                           quad->io_surface_resource_id);
   DCHECK_EQ(GL_TEXTURE0, GetActiveTextureUnit(gl_));
-  GLC(gl_, gl_->BindTexture(GL_TEXTURE_RECTANGLE_ARB, lock.texture_id()));
+  gl_->BindTexture(GL_TEXTURE_RECTANGLE_ARB, lock.texture_id());
 
   if (!clip_region) {
     DrawQuadGeometry(frame, quad->quadTransform(), quad->rect,
                      binding.matrix_location);
   } else {
     float uvs[8] = {0};
     GetScaledUVs(quad->visible_rect, clip_region, uvs);
     DrawQuadGeometryClippedByQuadF(frame, quad->quadTransform(), quad->rect,
                                    *clip_region, binding.matrix_location, uvs);
   }
 
-  GLC(gl_, gl_->BindTexture(GL_TEXTURE_RECTANGLE_ARB, 0));
+  gl_->BindTexture(GL_TEXTURE_RECTANGLE_ARB, 0);
 }
 
 void GLRenderer::FinishDrawingFrame(DrawingFrame* frame) {
   if (use_sync_query_) {
     DCHECK(current_sync_query_);
     current_sync_query_->End();
     pending_sync_queries_.push_back(current_sync_query_.Pass());
   }
 
   current_framebuffer_lock_ = nullptr;
   swap_buffer_rect_.Union(gfx::ToEnclosingRect(frame->root_damage_rect));
 
-  GLC(gl_, gl_->Disable(GL_BLEND));
+  gl_->Disable(GL_BLEND);
   blend_shadow_ = false;
 
   ScheduleOverlays(frame);
 }
 
 void GLRenderer::FinishDrawingQuadList() {
   FlushTextureQuadCache(SHARED_BINDING);
 }
 
 bool GLRenderer::FlippedFramebuffer(const DrawingFrame* frame) const {
   if (frame->current_render_pass != frame->root_render_pass)
     return true;
   return FlippedRootFramebuffer();
 }
 
 bool GLRenderer::FlippedRootFramebuffer() const {
   // GL is normally flipped, so a flipped output results in an unflipping.
   return !output_surface_->capabilities().flipped_output_surface;
 }
 
 void GLRenderer::EnsureScissorTestEnabled() {
   if (is_scissor_enabled_)
     return;
 
   FlushTextureQuadCache(SHARED_BINDING);
-  GLC(gl_, gl_->Enable(GL_SCISSOR_TEST));
+  gl_->Enable(GL_SCISSOR_TEST);
   is_scissor_enabled_ = true;
 }
 
 void GLRenderer::EnsureScissorTestDisabled() {
   if (!is_scissor_enabled_)
     return;
 
   FlushTextureQuadCache(SHARED_BINDING);
-  GLC(gl_, gl_->Disable(GL_SCISSOR_TEST));
+  gl_->Disable(GL_SCISSOR_TEST);
   is_scissor_enabled_ = false;
 }
 
 void GLRenderer::CopyCurrentRenderPassToBitmap(
     DrawingFrame* frame,
     scoped_ptr<CopyOutputRequest> request) {
   TRACE_EVENT0("cc", "GLRenderer::CopyCurrentRenderPassToBitmap");
   gfx::Rect copy_rect = frame->current_render_pass->output_rect;
   if (request->has_area())
     copy_rect.Intersect(request->area());
@@ skipping 10 matching lines @@
 
   float gl_quad[8];
   gl_quad[0] = quad.p1().x();
   gl_quad[1] = quad.p1().y();
   gl_quad[2] = quad.p2().x();
   gl_quad[3] = quad.p2().y();
   gl_quad[4] = quad.p3().x();
   gl_quad[5] = quad.p3().y();
   gl_quad[6] = quad.p4().x();
   gl_quad[7] = quad.p4().y();
-  GLC(gl_, gl_->Uniform2fv(quad_location, 4, gl_quad));
+  gl_->Uniform2fv(quad_location, 4, gl_quad);
 }
 
 void GLRenderer::SetShaderOpacity(float opacity, int alpha_location) {
   if (alpha_location != -1)
-    GLC(gl_, gl_->Uniform1f(alpha_location, opacity));
+    gl_->Uniform1f(alpha_location, opacity);
 }
 
 void GLRenderer::SetStencilEnabled(bool enabled) {
   if (enabled == stencil_shadow_)
     return;
 
   if (enabled)
-    GLC(gl_, gl_->Enable(GL_STENCIL_TEST));
+    gl_->Enable(GL_STENCIL_TEST);
   else
-    GLC(gl_, gl_->Disable(GL_STENCIL_TEST));
+    gl_->Disable(GL_STENCIL_TEST);
   stencil_shadow_ = enabled;
 }
 
 void GLRenderer::SetBlendEnabled(bool enabled) {
   if (enabled == blend_shadow_)
     return;
 
   if (enabled)
-    GLC(gl_, gl_->Enable(GL_BLEND));
+    gl_->Enable(GL_BLEND);
   else
-    GLC(gl_, gl_->Disable(GL_BLEND));
+    gl_->Disable(GL_BLEND);
   blend_shadow_ = enabled;
 }
 
 void GLRenderer::SetUseProgram(unsigned program) {
   if (program == program_shadow_)
     return;
   gl_->UseProgram(program);
   program_shadow_ = program;
 }
 
 void GLRenderer::DrawQuadGeometryClippedByQuadF(
     const DrawingFrame* frame,
     const gfx::Transform& draw_transform,
     const gfx::RectF& quad_rect,
     const gfx::QuadF& clipping_region_quad,
     int matrix_location,
     const float* uvs) {
   PrepareGeometry(CLIPPED_BINDING);
   if (uvs) {
     clipped_geometry_->InitializeCustomQuadWithUVs(clipping_region_quad, uvs);
   } else {
     clipped_geometry_->InitializeCustomQuad(clipping_region_quad);
   }
   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);
-  GLC(gl_, gl_->UniformMatrix4fv(matrix_location, 1, false, &gl_matrix[0]));
+  gl_->UniformMatrix4fv(matrix_location, 1, false, &gl_matrix[0]);
 
-  GLC(gl_, gl_->DrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT,
-                             reinterpret_cast<const void*>(0)));
+  gl_->DrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT,
+                    reinterpret_cast<const void*>(0));
 }
 
 void GLRenderer::DrawQuadGeometry(const DrawingFrame* frame,
                                   const gfx::Transform& draw_transform,
                                   const gfx::RectF& quad_rect,
                                   int matrix_location) {
   PrepareGeometry(SHARED_BINDING);
   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);
-  GLC(gl_, gl_->UniformMatrix4fv(matrix_location, 1, false, &gl_matrix[0]));
+  gl_->UniformMatrix4fv(matrix_location, 1, false, &gl_matrix[0]);
 
-  GLC(gl_, gl_->DrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0));
+  gl_->DrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0);
 }
 
 void GLRenderer::Finish() {
   TRACE_EVENT0("cc", "GLRenderer::Finish");
-  GLC(gl_, gl_->Finish());
+  gl_->Finish();
 }
 
 void GLRenderer::SwapBuffers(const CompositorFrameMetadata& metadata) {
   DCHECK(!is_backbuffer_discarded_);
 
   TRACE_EVENT0("cc,benchmark", "GLRenderer::SwapBuffers");
   // We're done! Time to swapbuffers!
 
   gfx::Size surface_size = output_surface_->SurfaceSize();
 
@@ skipping 28 matching lines @@
   swap_buffer_rect_ = gfx::Rect();
 }
 
 void GLRenderer::EnforceMemoryPolicy() {
   if (!visible()) {
     TRACE_EVENT0("cc", "GLRenderer::EnforceMemoryPolicy dropping resources");
     ReleaseRenderPassTextures();
     DiscardBackbuffer();
     resource_provider_->ReleaseCachedData();
     output_surface_->context_provider()->DeleteCachedResources();
-    GLC(gl_, gl_->Flush());
+    gl_->Flush();
   }
   PrepareGeometry(NO_BINDING);
 }
 
 void GLRenderer::DiscardBackbuffer() {
   if (is_backbuffer_discarded_)
     return;
 
   output_surface_->DiscardBackbuffer();
 
@@ skipping 26 matching lines @@
   DCHECK_GE(window_rect.y(), 0);
   DCHECK_LE(window_rect.right(), current_surface_size_.width());
   DCHECK_LE(window_rect.bottom(), current_surface_size_.height());
 
   if (!request->force_bitmap_result()) {
     bool own_mailbox = !request->has_texture_mailbox();
 
     GLuint texture_id = 0;
     gpu::Mailbox mailbox;
     if (own_mailbox) {
-      GLC(gl_, gl_->GenMailboxCHROMIUM(mailbox.name));
+      gl_->GenMailboxCHROMIUM(mailbox.name);
       gl_->GenTextures(1, &texture_id);
-      GLC(gl_, gl_->BindTexture(GL_TEXTURE_2D, texture_id));
+      gl_->BindTexture(GL_TEXTURE_2D, texture_id);
 
-      GLC(gl_,
-          gl_->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
-      GLC(gl_,
-          gl_->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
-      GLC(gl_,
-          gl_->TexParameteri(
-              GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
-      GLC(gl_,
-          gl_->TexParameteri(
-              GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
-      GLC(gl_, gl_->ProduceTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name));
+      gl_->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+      gl_->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+      gl_->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+      gl_->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+      gl_->ProduceTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
     } else {
       mailbox = request->texture_mailbox().mailbox();
       DCHECK_EQ(static_cast<unsigned>(GL_TEXTURE_2D),
                 request->texture_mailbox().target());
       DCHECK(!mailbox.IsZero());
       unsigned incoming_sync_point = request->texture_mailbox().sync_point();
       if (incoming_sync_point)
-        GLC(gl_, gl_->WaitSyncPointCHROMIUM(incoming_sync_point));
+        gl_->WaitSyncPointCHROMIUM(incoming_sync_point);
 
-      texture_id = GLC(
-          gl_,
-          gl_->CreateAndConsumeTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name));
+      texture_id =
+          gl_->CreateAndConsumeTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
     }
     GetFramebufferTexture(texture_id, RGBA_8888, window_rect);
 
     unsigned sync_point = gl_->InsertSyncPointCHROMIUM();
     TextureMailbox texture_mailbox(mailbox, GL_TEXTURE_2D, sync_point);
 
     scoped_ptr<SingleReleaseCallback> release_callback;
     if (own_mailbox) {
-      GLC(gl_, gl_->BindTexture(GL_TEXTURE_2D, 0));
+      gl_->BindTexture(GL_TEXTURE_2D, 0);
       release_callback = texture_mailbox_deleter_->GetReleaseCallback(
           output_surface_->context_provider(), texture_id);
     } else {
       gl_->DeleteTextures(1, &texture_id);
     }
 
     request->SendTextureResult(
         window_rect.size(), texture_mailbox, release_callback.Pass());
     return;
   }
@@ skipping 11 matching lines @@
   unsigned temporary_fbo = 0;
 
   if (do_workaround) {
     // On Mac OS X, calling glReadPixels() against an FBO whose color attachment
     // is an IOSurface-backed texture causes corruption of future glReadPixels()
     // calls, even those on different OpenGL contexts. It is believed that this
     // is the root cause of top crasher
     // http://crbug.com/99393. <rdar://problem/10949687>
 
     gl_->GenTextures(1, &temporary_texture);
-    GLC(gl_, gl_->BindTexture(GL_TEXTURE_2D, temporary_texture));
-    GLC(gl_,
-        gl_->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
-    GLC(gl_,
-        gl_->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
-    GLC(gl_,
-        gl_->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
-    GLC(gl_,
-        gl_->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
+    gl_->BindTexture(GL_TEXTURE_2D, temporary_texture);
+    gl_->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    gl_->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    gl_->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    gl_->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
     // Copy the contents of the current (IOSurface-backed) framebuffer into a
     // temporary texture.
     GetFramebufferTexture(
         temporary_texture, RGBA_8888, gfx::Rect(current_surface_size_));
     gl_->GenFramebuffers(1, &temporary_fbo);
     // Attach this texture to an FBO, and perform the readback from that FBO.
-    GLC(gl_, gl_->BindFramebuffer(GL_FRAMEBUFFER, temporary_fbo));
-    GLC(gl_,
-        gl_->FramebufferTexture2D(GL_FRAMEBUFFER,
-                                  GL_COLOR_ATTACHMENT0,
-                                  GL_TEXTURE_2D,
-                                  temporary_texture,
-                                  0));
+    gl_->BindFramebuffer(GL_FRAMEBUFFER, temporary_fbo);
+    gl_->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
+                              GL_TEXTURE_2D, temporary_texture, 0);
 
     DCHECK_EQ(static_cast<unsigned>(GL_FRAMEBUFFER_COMPLETE),
               gl_->CheckFramebufferStatus(GL_FRAMEBUFFER));
   }
 
   GLuint buffer = 0;
   gl_->GenBuffers(1, &buffer);
-  GLC(gl_, gl_->BindBuffer(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM, buffer));
-  GLC(gl_,
-      gl_->BufferData(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM,
-                      4 * window_rect.size().GetArea(),
-                      NULL,
-                      GL_STREAM_READ));
+  gl_->BindBuffer(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM, buffer);
+  gl_->BufferData(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM,
+                  4 * window_rect.size().GetArea(), NULL, GL_STREAM_READ);
 
   GLuint query = 0;
   gl_->GenQueriesEXT(1, &query);
-  GLC(gl_, gl_->BeginQueryEXT(GL_ASYNC_PIXEL_PACK_COMPLETED_CHROMIUM, query));
+  gl_->BeginQueryEXT(GL_ASYNC_PIXEL_PACK_COMPLETED_CHROMIUM, query);
 
-  GLC(gl_,
-      gl_->ReadPixels(window_rect.x(),
-                      window_rect.y(),
-                      window_rect.width(),
-                      window_rect.height(),
-                      GL_RGBA,
-                      GL_UNSIGNED_BYTE,
-                      NULL));
+  gl_->ReadPixels(window_rect.x(), window_rect.y(), window_rect.width(),
+                  window_rect.height(), GL_RGBA, GL_UNSIGNED_BYTE, NULL);
 
-  GLC(gl_, gl_->BindBuffer(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM, 0));
+  gl_->BindBuffer(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM, 0);
 
   if (do_workaround) {
     // Clean up.
-    GLC(gl_, gl_->BindFramebuffer(GL_FRAMEBUFFER, 0));
-    GLC(gl_, gl_->BindTexture(GL_TEXTURE_2D, 0));
-    GLC(gl_, gl_->DeleteFramebuffers(1, &temporary_fbo));
-    GLC(gl_, gl_->DeleteTextures(1, &temporary_texture));
+    gl_->BindFramebuffer(GL_FRAMEBUFFER, 0);
+    gl_->BindTexture(GL_TEXTURE_2D, 0);
+    gl_->DeleteFramebuffers(1, &temporary_fbo);
+    gl_->DeleteTextures(1, &temporary_texture);
   }
 
   base::Closure finished_callback = base::Bind(&GLRenderer::FinishedReadback,
                                                base::Unretained(this),
                                                buffer,
                                                query,
                                                window_rect.size());
   // Save the finished_callback so it can be cancelled.
   pending_async_read_pixels_.front()->finished_read_pixels_callback.Reset(
       finished_callback);
   base::Closure cancelable_callback =
       pending_async_read_pixels_.front()->
           finished_read_pixels_callback.callback();
 
   // Save the buffer to verify the callbacks happen in the expected order.
   pending_async_read_pixels_.front()->buffer = buffer;
 
-  GLC(gl_, gl_->EndQueryEXT(GL_ASYNC_PIXEL_PACK_COMPLETED_CHROMIUM));
+  gl_->EndQueryEXT(GL_ASYNC_PIXEL_PACK_COMPLETED_CHROMIUM);
   context_support_->SignalQuery(query, cancelable_callback);
 
   EnforceMemoryPolicy();
 }
 
 void GLRenderer::FinishedReadback(unsigned source_buffer,
                                   unsigned query,
                                   const gfx::Size& size) {
   DCHECK(!pending_async_read_pixels_.empty());
 
   if (query != 0) {
-    GLC(gl_, gl_->DeleteQueriesEXT(1, &query));
+    gl_->DeleteQueriesEXT(1, &query);
   }
 
   PendingAsyncReadPixels* current_read = pending_async_read_pixels_.back();
   // Make sure we service the readbacks in order.
   DCHECK_EQ(source_buffer, current_read->buffer);
 
   uint8* src_pixels = NULL;
   scoped_ptr<SkBitmap> bitmap;
 
   if (source_buffer != 0) {
-    GLC(gl_,
-        gl_->BindBuffer(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM, source_buffer));
+    gl_->BindBuffer(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM, source_buffer);
     src_pixels = static_cast<uint8*>(gl_->MapBufferCHROMIUM(
         GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM, GL_READ_ONLY));
 
     if (src_pixels) {
       bitmap.reset(new SkBitmap);
       bitmap->allocN32Pixels(size.width(), size.height());
       scoped_ptr<SkAutoLockPixels> lock(new SkAutoLockPixels(*bitmap));
       uint8* dest_pixels = static_cast<uint8*>(bitmap->getPixels());
 
       size_t row_bytes = size.width() * 4;
       int num_rows = size.height();
       size_t total_bytes = num_rows * row_bytes;
       for (size_t dest_y = 0; dest_y < total_bytes; dest_y += row_bytes) {
         // Flip Y axis.
         size_t src_y = total_bytes - dest_y - row_bytes;
         // Swizzle OpenGL -> Skia byte order.
         for (size_t x = 0; x < row_bytes; x += 4) {
           dest_pixels[dest_y + x + SK_R32_SHIFT / 8] =
               src_pixels[src_y + x + 0];
           dest_pixels[dest_y + x + SK_G32_SHIFT / 8] =
               src_pixels[src_y + x + 1];
           dest_pixels[dest_y + x + SK_B32_SHIFT / 8] =
               src_pixels[src_y + x + 2];
           dest_pixels[dest_y + x + SK_A32_SHIFT / 8] =
               src_pixels[src_y + x + 3];
         }
       }
 
-      GLC(gl_,
-          gl_->UnmapBufferCHROMIUM(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM));
+      gl_->UnmapBufferCHROMIUM(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM);
     }
-    GLC(gl_, gl_->BindBuffer(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM, 0));
-    GLC(gl_, gl_->DeleteBuffers(1, &source_buffer));
+    gl_->BindBuffer(GL_PIXEL_PACK_TRANSFER_BUFFER_CHROMIUM, 0);
+    gl_->DeleteBuffers(1, &source_buffer);
   }
 
   if (bitmap)
     current_read->copy_request->SendBitmapResult(bitmap.Pass());
   pending_async_read_pixels_.pop_back();
 }
 
 void GLRenderer::GetFramebufferTexture(unsigned texture_id,
                                        ResourceFormat texture_format,
                                        const gfx::Rect& window_rect) {
   DCHECK(texture_id);
   DCHECK_GE(window_rect.x(), 0);
   DCHECK_GE(window_rect.y(), 0);
   DCHECK_LE(window_rect.right(), current_surface_size_.width());
   DCHECK_LE(window_rect.bottom(), current_surface_size_.height());
 
-  GLC(gl_, gl_->BindTexture(GL_TEXTURE_2D, texture_id));
-  GLC(gl_,
-      gl_->CopyTexImage2D(GL_TEXTURE_2D,
-                          0,
-                          GLDataFormat(texture_format),
-                          window_rect.x(),
-                          window_rect.y(),
-                          window_rect.width(),
-                          window_rect.height(),
-                          0));
-  GLC(gl_, gl_->BindTexture(GL_TEXTURE_2D, 0));
+  gl_->BindTexture(GL_TEXTURE_2D, texture_id);
+  gl_->CopyTexImage2D(GL_TEXTURE_2D, 0, GLDataFormat(texture_format),
+                      window_rect.x(), window_rect.y(), window_rect.width(),
+                      window_rect.height(), 0);
+  gl_->BindTexture(GL_TEXTURE_2D, 0);
 }
 
 bool GLRenderer::UseScopedTexture(DrawingFrame* frame,
                                   const ScopedResource* texture,
                                   const gfx::Rect& viewport_rect) {
   DCHECK(texture->id());
   frame->current_render_pass = NULL;
   frame->current_texture = texture;
 
   return BindFramebufferToTexture(frame, texture, viewport_rect);
 }
 
 void GLRenderer::BindFramebufferToOutputSurface(DrawingFrame* frame) {
   current_framebuffer_lock_ = nullptr;
   output_surface_->BindFramebuffer();
 
   if (output_surface_->HasExternalStencilTest()) {
     SetStencilEnabled(true);
-    GLC(gl_, gl_->StencilFunc(GL_EQUAL, 1, 1));
+    gl_->StencilFunc(GL_EQUAL, 1, 1);
   } else {
     SetStencilEnabled(false);
   }
 }
 
 bool GLRenderer::BindFramebufferToTexture(DrawingFrame* frame,
                                           const ScopedResource* texture,
                                           const gfx::Rect& target_rect) {
   DCHECK(texture->id());
 
   // Explicitly release lock, otherwise we can crash when try to lock
   // same texture again.
   current_framebuffer_lock_ = nullptr;
 
   SetStencilEnabled(false);
-  GLC(gl_, gl_->BindFramebuffer(GL_FRAMEBUFFER, offscreen_framebuffer_id_));
+  gl_->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();
-  GLC(gl_,
-      gl_->FramebufferTexture2D(
-          GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture_id, 0));
+  gl_->FramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
+                            texture_id, 0);
 
   DCHECK(gl_->CheckFramebufferStatus(GL_FRAMEBUFFER) ==
              GL_FRAMEBUFFER_COMPLETE ||
          IsContextLost());
   return true;
 }
 
 void GLRenderer::SetScissorTestRect(const gfx::Rect& scissor_rect) {
   EnsureScissorTestEnabled();
 
   // Don't unnecessarily ask the context to change the scissor, because it
   // may cause undesired GPU pipeline flushes.
   if (scissor_rect == scissor_rect_ && !scissor_rect_needs_reset_)
     return;
 
   scissor_rect_ = scissor_rect;
   FlushTextureQuadCache(SHARED_BINDING);
-  GLC(gl_,
-      gl_->Scissor(scissor_rect.x(),
-                   scissor_rect.y(),
-                   scissor_rect.width(),
-                   scissor_rect.height()));
+  gl_->Scissor(scissor_rect.x(), scissor_rect.y(), scissor_rect.width(),
+               scissor_rect.height());
 
   scissor_rect_needs_reset_ = false;
 }
 
 void GLRenderer::SetViewport() {
-  GLC(gl_, gl_->Viewport(current_window_space_viewport_.x(),
-                         current_window_space_viewport_.y(),
-                         current_window_space_viewport_.width(),
-                         current_window_space_viewport_.height()));
+  gl_->Viewport(current_window_space_viewport_.x(),
+                current_window_space_viewport_.y(),
+                current_window_space_viewport_.width(),
+                current_window_space_viewport_.height());
 }
 
 void GLRenderer::InitializeSharedObjects() {
   TRACE_EVENT0("cc", "GLRenderer::InitializeSharedObjects");
 
   // Create an FBO for doing offscreen rendering.
-  GLC(gl_, gl_->GenFramebuffers(1, &offscreen_framebuffer_id_));
+  gl_->GenFramebuffers(1, &offscreen_framebuffer_id_);
 
   shared_geometry_ =
       make_scoped_ptr(new StaticGeometryBinding(gl_, QuadVertexRect()));
   clipped_geometry_ = make_scoped_ptr(new DynamicGeometryBinding(gl_));
 }
 
 void GLRenderer::PrepareGeometry(BoundGeometry binding) {
   if (binding == bound_geometry_) {
     return;
   }
@@ skipping 461 matching lines @@
     video_stream_texture_program_[i].Cleanup(gl_);
   }
 
   tile_checkerboard_program_.Cleanup(gl_);
 
   debug_border_program_.Cleanup(gl_);
   solid_color_program_.Cleanup(gl_);
   solid_color_program_aa_.Cleanup(gl_);
 
   if (offscreen_framebuffer_id_)
-    GLC(gl_, gl_->DeleteFramebuffers(1, &offscreen_framebuffer_id_));
+    gl_->DeleteFramebuffers(1, &offscreen_framebuffer_id_);
 
   if (on_demand_tile_raster_resource_id_)
     resource_provider_->DeleteResource(on_demand_tile_raster_resource_id_);
 
   ReleaseRenderPassTextures();
 }
 
 void GLRenderer::ReinitializeGLState() {
   is_scissor_enabled_ = false;
   scissor_rect_needs_reset_ = true;
   stencil_shadow_ = false;
   blend_shadow_ = true;
   program_shadow_ = 0;
 
   RestoreGLState();
 }
 
 void GLRenderer::RestoreGLState() {
   // This restores the current GLRenderer state to the GL context.
   bound_geometry_ = NO_BINDING;
   PrepareGeometry(SHARED_BINDING);
 
-  GLC(gl_, gl_->Disable(GL_DEPTH_TEST));
-  GLC(gl_, gl_->Disable(GL_CULL_FACE));
-  GLC(gl_, gl_->ColorMask(true, true, true, true));
-  GLC(gl_, gl_->BlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA));
-  GLC(gl_, gl_->ActiveTexture(GL_TEXTURE0));
+  gl_->Disable(GL_DEPTH_TEST);
+  gl_->Disable(GL_CULL_FACE);
+  gl_->ColorMask(true, true, true, true);
+  gl_->BlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+  gl_->ActiveTexture(GL_TEXTURE0);
 
   if (program_shadow_)
     gl_->UseProgram(program_shadow_);
 
   if (stencil_shadow_)
-    GLC(gl_, gl_->Enable(GL_STENCIL_TEST));
+    gl_->Enable(GL_STENCIL_TEST);
   else
-    GLC(gl_, gl_->Disable(GL_STENCIL_TEST));
+    gl_->Disable(GL_STENCIL_TEST);
 
   if (blend_shadow_)
-    GLC(gl_, gl_->Enable(GL_BLEND));
+    gl_->Enable(GL_BLEND);
   else
-    GLC(gl_, gl_->Disable(GL_BLEND));
+    gl_->Disable(GL_BLEND);
 
   if (is_scissor_enabled_) {
-    GLC(gl_, gl_->Enable(GL_SCISSOR_TEST));
-    GLC(gl_,
-        gl_->Scissor(scissor_rect_.x(),
-                     scissor_rect_.y(),
-                     scissor_rect_.width(),
-                     scissor_rect_.height()));
+    gl_->Enable(GL_SCISSOR_TEST);
+    gl_->Scissor(scissor_rect_.x(), scissor_rect_.y(), scissor_rect_.width(),
+                 scissor_rect_.height());
   } else {
-    GLC(gl_, gl_->Disable(GL_SCISSOR_TEST));
+    gl_->Disable(GL_SCISSOR_TEST);
   }
 }
 
 void GLRenderer::RestoreFramebuffer(DrawingFrame* frame) {
   UseRenderPass(frame, frame->current_render_pass);
 
   // Call SetViewport directly, rather than through PrepareSurfaceForPass.
   // PrepareSurfaceForPass also clears the surface, which is not desired when
   // restoring.
   SetViewport();
@@ skipping 23 matching lines @@
     context_support_->ScheduleOverlayPlane(
         overlay.plane_z_order,
         overlay.transform,
         pending_overlay_resources_.back()->texture_id(),
         overlay.display_rect,
         overlay.uv_rect);
   }
 }
 
 }  // namespace cc