cc: Remove code for drawing checkerboard quads, it's not used.

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 500 matching lines @@
                             const gfx::QuadF* clip_region) {
   DCHECK(quad->rect.Contains(quad->visible_rect));
   if (quad->material != DrawQuad::TEXTURE_CONTENT) {
     FlushTextureQuadCache(SHARED_BINDING);
   }
 
   switch (quad->material) {
     case DrawQuad::INVALID:
       NOTREACHED();
       break;
-    case DrawQuad::CHECKERBOARD:
-      DrawCheckerboardQuad(frame, CheckerboardDrawQuad::MaterialCast(quad),
-                           clip_region);
-      break;
     case DrawQuad::DEBUG_BORDER:
       DrawDebugBorderQuad(frame, DebugBorderDrawQuad::MaterialCast(quad));
       break;
     case DrawQuad::IO_SURFACE_CONTENT:
       DrawIOSurfaceQuad(frame, IOSurfaceDrawQuad::MaterialCast(quad),
                         clip_region);
       break;
     case DrawQuad::PICTURE_CONTENT:
       // PictureDrawQuad should only be used for resourceless software draws.
       NOTREACHED();
@@ skipping 22 matching lines @@
     case DrawQuad::TILED_CONTENT:
       DrawTileQuad(frame, TileDrawQuad::MaterialCast(quad), clip_region);
       break;
     case DrawQuad::YUV_VIDEO_CONTENT:
       DrawYUVVideoQuad(frame, YUVVideoDrawQuad::MaterialCast(quad),
                        clip_region);
       break;
   }
 }
 
-void GLRenderer::DrawCheckerboardQuad(const DrawingFrame* frame,
-                                      const CheckerboardDrawQuad* quad,
-                                      const gfx::QuadF* clip_region) {
-  // TODO(enne) For now since checkerboards shouldn't be part of a 3D
-  // context, clipping regions aren't supported so we skip drawing them
-  // if this becomes the case.
-  if (clip_region) {
-    return;
-  }
-  SetBlendEnabled(quad->ShouldDrawWithBlending());
-
-  const TileCheckerboardProgram* program = GetTileCheckerboardProgram();
-  DCHECK(program && (program->initialized() || IsContextLost()));
-  SetUseProgram(program->program());
-
-  SkColor color = quad->color;
-  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;
-  gl_->Uniform4f(program->fragment_shader().tex_transform_location(),
-                 tex_offset_x, tex_offset_y, tex_scale_x, tex_scale_y);
-
-  gl_->Uniform1f(program->fragment_shader().frequency_location(), frequency);
-
-  SetShaderOpacity(quad->shared_quad_state->opacity,
-                   program->fragment_shader().alpha_location());
-  DrawQuadGeometry(frame, quad->shared_quad_state->quad_to_target_transform,
-                   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()));
@@ skipping 2401 matching lines @@
       break;
     case CLIPPED_BINDING:
       clipped_geometry_->PrepareForDraw();
       break;
     case NO_BINDING:
       break;
   }
   bound_geometry_ = binding;
 }
 
-const GLRenderer::TileCheckerboardProgram*
-GLRenderer::GetTileCheckerboardProgram() {
-  if (!tile_checkerboard_program_.initialized()) {
-    TRACE_EVENT0("cc", "GLRenderer::checkerboardProgram::initalize");
-    tile_checkerboard_program_.Initialize(output_surface_->context_provider(),
-                                          TEX_COORD_PRECISION_NA,
-                                          SAMPLER_TYPE_NA);
-  }
-  return &tile_checkerboard_program_;
-}
-
 const GLRenderer::DebugBorderProgram* GLRenderer::GetDebugBorderProgram() {
   if (!debug_border_program_.initialized()) {
     TRACE_EVENT0("cc", "GLRenderer::debugBorderProgram::initialize");
     debug_border_program_.Initialize(output_surface_->context_provider(),
                                      TEX_COORD_PRECISION_NA, SAMPLER_TYPE_NA);
   }
   return &debug_border_program_;
 }
 
 const GLRenderer::SolidColorProgram* GLRenderer::GetSolidColorProgram() {
@@ skipping 441 matching lines @@
       texture_program_[i][j].Cleanup(gl_);
       nonpremultiplied_texture_program_[i][j].Cleanup(gl_);
       texture_background_program_[i][j].Cleanup(gl_);
       nonpremultiplied_texture_background_program_[i][j].Cleanup(gl_);
     }
     texture_io_surface_program_[i].Cleanup(gl_);
 
     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_)
     gl_->DeleteFramebuffers(1, &offscreen_framebuffer_id_);
 
   if (on_demand_tile_raster_resource_id_)
     resource_provider_->DeleteResource(on_demand_tile_raster_resource_id_);
 
@@ skipping 74 matching lines @@
     context_support_->ScheduleOverlayPlane(
         overlay.plane_z_order,
         overlay.transform,
         pending_overlay_resources_.back()->texture_id(),
         ToNearestRect(overlay.display_rect),
         overlay.uv_rect);
   }
 }
 
 }  // namespace cc