cc: Remove more uniform location caching

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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 65 matching lines @@
   gfx::PointF uv0 = quad->uv_top_left;
   gfx::PointF uv1 = quad->uv_bottom_right;
   Float4 xform = {{uv0.x(), uv0.y(), uv1.x() - uv0.x(), uv1.y() - uv0.y()}};
   if (quad->y_flipped) {
     xform.data[1] = 1.0f - xform.data[1];
     xform.data[3] = -xform.data[3];
   }
   return xform;
 }
 
-Float4 PremultipliedColor(SkColor color) {
+Float4 PremultipliedColor(SkColor color, float opacity) {
   const float factor = 1.0f / 255.0f;
-  const float alpha = SkColorGetA(color) * factor;
+  const float alpha = opacity * SkColorGetA(color) * factor;
 
   Float4 result = {
       {SkColorGetR(color) * factor * alpha, SkColorGetG(color) * factor * alpha,
        SkColorGetB(color) * factor * alpha, alpha}};
   return result;
 }
 
 SamplerType SamplerTypeFromTextureTarget(GLenum target) {
   switch (target) {
     case GL_TEXTURE_2D:
@@ skipping 273 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(SyncQuery);
 };
 
 GLRenderer::GLRenderer(const RendererSettings* settings,
                        OutputSurface* output_surface,
                        ResourceProvider* resource_provider,
                        TextureMailboxDeleter* texture_mailbox_deleter,
                        int highp_threshold_min)
     : DirectRenderer(settings, output_surface, resource_provider),
-      offscreen_framebuffer_id_(0),
       shared_geometry_quad_(QuadVertexRect()),
       gl_(output_surface->context_provider()->ContextGL()),
       context_support_(output_surface->context_provider()->ContextSupport()),
       texture_mailbox_deleter_(texture_mailbox_deleter),
-      is_scissor_enabled_(false),
-      stencil_shadow_(false),
-      blend_shadow_(false),
       highp_threshold_min_(highp_threshold_min),
-      highp_threshold_cache_(0),
-      use_sync_query_(false),
       gl_composited_texture_quad_border_(
           settings->gl_composited_texture_quad_border),
       bound_geometry_(NO_BINDING),
       color_lut_cache_(gl_,
                        output_surface_->context_provider()
                            ->ContextCapabilities()
                            .texture_half_float_linear),
       weak_ptr_factory_(this) {
   DCHECK(gl_);
   DCHECK(context_support_);
@@ skipping 209 matching lines @@
   }
 }
 
 // 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 Program* program = GetProgram(ProgramKey::DebugBorder());
-  DCHECK(program);
-  DCHECK(program->initialized() || IsContextLost());
-  SetUseProgram(program->program());
+  SetUseProgram(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->shared_quad_state->quad_to_target_transform,
                     gfx::RectF(layer_rect));
-  GLRenderer::ToGLMatrix(&gl_matrix[0],
-                         frame->projection_matrix * render_matrix);
-  gl_->UniformMatrix4fv(program->matrix_location(), 1, false, &gl_matrix[0]);
-
-  SkColor color = quad->color;
-  float alpha = SkColorGetA(color) * (1.0f / 255.0f);
-
-  gl_->Uniform4f(program->color_location(),
-                 (SkColorGetR(color) * (1.0f / 255.0f)) * alpha,
-                 (SkColorGetG(color) * (1.0f / 255.0f)) * alpha,
-                 (SkColorGetB(color) * (1.0f / 255.0f)) * alpha, alpha);
+  SetShaderMatrix(frame->projection_matrix * render_matrix);
+  SetShaderColor(quad->color, 1.f);
 
   gl_->LineWidth(quad->width);
 
   // The indices for the line are stored in the same array as the triangle
   // indices.
   gl_->DrawElements(GL_LINE_LOOP, 4, GL_UNSIGNED_SHORT, 0);
 }
 
 static sk_sp<SkImage> WrapTexture(
     const ResourceProvider::ScopedReadLockGL& lock,
@@ skipping 682 matching lines @@
   if (params->mask_resource_lock) {
     mask_mode = HAS_MASK;
     sampler_type =
         SamplerTypeFromTextureTarget(params->mask_resource_lock->target());
   }
 
   params->program = GetProgram(ProgramKey::RenderPass(
       tex_coord_precision, sampler_type, shader_blend_mode,
       params->use_aa ? USE_AA : NO_AA, mask_mode, mask_for_background,
       params->use_color_matrix));
-  SetUseProgram(params->program->program());
-  gl_->Uniform1i(params->program->sampler_location(), 0);
+  SetUseProgram(params->program);
 }
 
 void GLRenderer::UpdateRPDQUniforms(DrawRenderPassDrawQuadParams* params) {
   const Program* program = params->program;
 
   gfx::RectF tex_rect(params->src_offset.x(), params->src_offset.y(),
                       params->dst_rect.width(), params->dst_rect.height());
   gfx::Size texture_size;
   if (params->filter_image) {
     texture_size.set_width(params->filter_image->width());
@@ skipping 48 matching lines @@
                      mask_uv_rect.width() / tex_rect.width(),
                      mask_uv_rect.height() / tex_rect.height());
     }
 
     last_texture_unit = 1;
   }
 
   if (program->edge_location() != -1)
     gl_->Uniform3fv(program->edge_location(), 8, params->edge);
 
-  if (program->viewport_location() != -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()),
-    };
-    gl_->Uniform4fv(program->viewport_location(), 1, viewport);
-  }
-
   if (program->color_matrix_location() != -1) {
     float matrix[16];
     for (int i = 0; i < 4; ++i) {
       for (int j = 0; j < 4; ++j)
         matrix[i * 4 + j] = SkScalarToFloat(params->color_matrix[j * 5 + i]);
     }
     gl_->UniformMatrix4fv(program->color_matrix_location(), 1, false, matrix);
   }
   static const float kScale = 1.0f / 255.0f;
   if (program->color_offset_location() != -1) {
@@ skipping 27 matching lines @@
     if (params->background_texture) {
       params->shader_background_sampler_lock =
           base::MakeUnique<ResourceProvider::ScopedSamplerGL>(
               resource_provider_, params->background_texture->id(),
               GL_TEXTURE0 + last_texture_unit, GL_LINEAR);
       DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D),
                 params->shader_background_sampler_lock->target());
     }
   }
 
-  SetShaderOpacity(params->quad->shared_quad_state->opacity,
-                   program->alpha_location());
-  SetShaderQuadF(params->surface_quad, program->quad_location());
+  SetShaderOpacity(params->quad);
+  SetShaderQuadF(params->surface_quad);
 }
 
 void GLRenderer::DrawRPDQ(const DrawRenderPassDrawQuadParams& params) {
   DrawQuadGeometry(params.projection_matrix, params.quad_to_target_transform,
-                   params.dst_rect, params.program->matrix_location());
+                   params.dst_rect);
 
   // Flush the compositor context before the filter bitmap goes out of
   // scope, so the draw gets processed before the filter texture gets deleted.
   if (params.filter_image)
     gl_->Flush();
 
   if (!params.use_shaders_for_blending)
     RestoreBlendFuncToDefault(params.quad->shared_quad_state->blend_mode);
 }
 
@@ skipping 297 matching lines @@
     use_aa = ShouldAntialiasQuad(device_layer_quad, clipped, force_aa);
   }
 
   float edge[24];
   const gfx::QuadF* aa_quad = use_aa ? &device_layer_quad : nullptr;
   SetupQuadForClippingAndAntialiasing(device_transform, quad, aa_quad,
                                       clip_region, &local_quad, edge);
 
   const Program* program =
       GetProgram(ProgramKey::SolidColor(use_aa ? USE_AA : NO_AA));
-  SetUseProgram(program->program());
+  SetUseProgram(program);
+  SetShaderColor(color, opacity);
 
-  gl_->Uniform4f(program->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()),
-    };
-    gl_->Uniform4fv(program->viewport_location(), 1, viewport);
     gl_->Uniform3fv(program->edge_location(), 8, edge);
   }
 
   // Enable blending when the quad properties require it or if we decided
   // to use antialiasing.
   SetBlendEnabled(quad->ShouldDrawWithBlending() || use_aa);
 
   // Antialising requires a normalized quad, but this could lead to floating
   // point precision errors, so only normalize when antialising is on.
   if (use_aa) {
     // Normalize to tile_rect.
     local_quad.Scale(1.0f / tile_rect.width(), 1.0f / tile_rect.height());
 
-    SetShaderQuadF(local_quad, program->quad_location());
+    SetShaderQuadF(local_quad);
 
     // 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 centered_rect(
         gfx::PointF(-0.5f * tile_rect.width(), -0.5f * tile_rect.height()),
         gfx::SizeF(tile_rect.size()));
     DrawQuadGeometry(frame->projection_matrix,
                      quad->shared_quad_state->quad_to_target_transform,
-                     centered_rect, program->matrix_location());
+                     centered_rect);
   } else {
     PrepareGeometry(SHARED_BINDING);
-    SetShaderQuadF(local_quad, program->quad_location());
-    static float gl_matrix[16];
-    ToGLMatrix(&gl_matrix[0],
-               frame->projection_matrix *
-                   quad->shared_quad_state->quad_to_target_transform);
-    gl_->UniformMatrix4fv(program->matrix_location(), 1, false, &gl_matrix[0]);
-
+    SetShaderQuadF(local_quad);
+    SetShaderMatrix(frame->projection_matrix *
+                    quad->shared_quad_state->quad_to_target_transform);
     gl_->DrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0);
   }
 }
 
 void GLRenderer::DrawTileQuad(const DrawingFrame* frame,
                               const TileDrawQuad* quad,
                               const gfx::QuadF* clip_region) {
   DrawContentQuad(frame, quad, quad->resource_id(), clip_region);
 }
 
@@ skipping 100 matching lines @@
     fragment_tex_translate_x /= texture_size.width();
     fragment_tex_translate_y /= texture_size.height();
     fragment_tex_scale_x /= texture_size.width();
     fragment_tex_scale_y /= texture_size.height();
   }
 
   const Program* program = GetProgram(ProgramKey::Tile(
       tex_coord_precision, sampler, USE_AA,
       quad->swizzle_contents ? DO_SWIZZLE : NO_SWIZZLE, false));
 
-  SetUseProgram(program->program());
-  gl_->Uniform1i(program->sampler_location(), 0);
+  SetUseProgram(program);
 
-  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()),
-  };
-  gl_->Uniform4fv(program->viewport_location(), 1, viewport);
   gl_->Uniform3fv(program->edge_location(), 8, edge);
 
   gl_->Uniform4f(program->vertex_tex_transform_location(),
                  vertex_tex_translate_x, vertex_tex_translate_y,
                  vertex_tex_scale_x, vertex_tex_scale_y);
   gl_->Uniform4f(program->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->shared_quad_state->opacity, program->alpha_location());
-  SetShaderQuadF(local_quad, program->quad_location());
+  SetShaderOpacity(quad);
+  SetShaderQuadF(local_quad);
 
   // 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 centered_rect(
       gfx::PointF(-0.5f * tile_rect.width(), -0.5f * tile_rect.height()),
       gfx::SizeF(tile_rect.size()));
   DrawQuadGeometry(frame->projection_matrix,
                    quad->shared_quad_state->quad_to_target_transform,
-                   centered_rect, program->matrix_location());
+                   centered_rect);
 }
 
 void GLRenderer::DrawContentQuadNoAA(const DrawingFrame* frame,
                                      const ContentDrawQuadBase* quad,
                                      ResourceId resource_id,
                                      const gfx::QuadF* clip_region) {
   gfx::RectF tex_coord_rect = MathUtil::ScaleRectProportional(
       quad->tex_coord_rect, gfx::RectF(quad->rect),
       gfx::RectF(quad->visible_rect));
   float tex_to_geom_scale_x = quad->rect.width() / quad->tex_coord_rect.width();
@@ skipping 29 matching lines @@
   }
 
   TexCoordPrecision tex_coord_precision = TexCoordPrecisionRequired(
       gl_, &highp_threshold_cache_, highp_threshold_min_, quad->texture_size);
 
   const Program* program = GetProgram(
       ProgramKey::Tile(tex_coord_precision, sampler, NO_AA,
                        quad->swizzle_contents ? DO_SWIZZLE : NO_SWIZZLE,
                        !quad->ShouldDrawWithBlending()));
 
-  SetUseProgram(program->program());
-  gl_->Uniform1i(program->sampler_location(), 0);
+  SetUseProgram(program);
 
   gl_->Uniform4f(program->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->shared_quad_state->opacity, program->alpha_location());
+  SetShaderOpacity(quad);
 
   // 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.
   auto tile_quad = gfx::QuadF(gfx::RectF(quad->visible_rect));
   float width = quad->visible_rect.width();
   float height = quad->visible_rect.height();
   auto top_left = gfx::PointF(quad->visible_rect.origin());
   if (clip_region) {
@@ skipping 14 matching lines @@
   } else {
     PrepareGeometry(SHARED_BINDING);
   }
   float gl_quad[8] = {
       tile_quad.p4().x(), tile_quad.p4().y(), tile_quad.p1().x(),
       tile_quad.p1().y(), tile_quad.p2().x(), tile_quad.p2().y(),
       tile_quad.p3().x(), tile_quad.p3().y(),
   };
   gl_->Uniform2fv(program->quad_location(), 4, gl_quad);
 
-  static float gl_matrix[16];
-  ToGLMatrix(&gl_matrix[0],
-             frame->projection_matrix *
-                 quad->shared_quad_state->quad_to_target_transform);
-  gl_->UniformMatrix4fv(program->matrix_location(), 1, false, &gl_matrix[0]);
+  SetShaderMatrix(frame->projection_matrix *
+                  quad->shared_quad_state->quad_to_target_transform);
 
   gl_->DrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0);
 }
 
 // TODO(ccameron): This has been replicated in ui/gfx/color_transform.cc. Delete
 // one of the instances.
 void ComputeYUVToRGBMatrices(YUVVideoDrawQuad::ColorSpace color_space,
                              uint32_t bits_per_channel,
                              float resource_multiplier,
                              float resource_offset,
@@ skipping 88 matching lines @@
         GL_LINEAR));
     DCHECK_EQ(y_plane_lock.target(), a_plane_lock->target());
   }
 
   // All planes must have the same sampler type.
   SamplerType sampler = SamplerTypeFromTextureTarget(y_plane_lock.target());
 
   const Program* program = GetProgram(
       ProgramKey::YUVVideo(tex_coord_precision, sampler, alpha_texture_mode,
                            uv_texture_mode, color_conversion_mode));
-  DCHECK(program && (program->initialized() || IsContextLost()));
-  SetUseProgram(program->program());
+  SetUseProgram(program);
 
   gfx::SizeF ya_tex_scale(1.0f, 1.0f);
   gfx::SizeF uv_tex_scale(1.0f, 1.0f);
   if (sampler != SAMPLER_TYPE_2D_RECT) {
     DCHECK(!quad->ya_tex_size.IsEmpty());
     DCHECK(!quad->uv_tex_size.IsEmpty());
     ya_tex_scale = gfx::SizeF(1.0f / quad->ya_tex_size.width(),
                               1.0f / quad->ya_tex_size.height());
     uv_tex_scale = gfx::SizeF(1.0f / quad->uv_tex_size.width(),
                               1.0f / quad->uv_tex_size.height());
@@ skipping 67 matching lines @@
                           color_conversion_mode, yuv_to_rgb_matrix);
   gl_->UniformMatrix4fv(program->yuv_and_resource_matrix_location(), 1, 0,
                         yuv_to_rgb_matrix);
 
   // 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.
   auto tile_rect = gfx::RectF(quad->rect);
 
-  SetShaderOpacity(quad->shared_quad_state->opacity, program->alpha_location());
+  SetShaderOpacity(quad);
   if (!clip_region) {
     DrawQuadGeometry(frame->projection_matrix,
                      quad->shared_quad_state->quad_to_target_transform,
-                     tile_rect, program->matrix_location());
+                     tile_rect);
   } 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);
     DrawQuadGeometryClippedByQuadF(
         frame, quad->shared_quad_state->quad_to_target_transform, tile_rect,
-        region_quad, program->matrix_location(), uvs);
+        region_quad, uvs);
   }
 }
 
 void GLRenderer::DrawStreamVideoQuad(const DrawingFrame* frame,
                                      const StreamVideoDrawQuad* quad,
                                      const gfx::QuadF* clip_region) {
   SetBlendEnabled(quad->ShouldDrawWithBlending());
 
-  static float gl_matrix[16];
-
   DCHECK(output_surface_->context_provider()
              ->ContextCapabilities()
              .egl_image_external);
 
   TexCoordPrecision tex_coord_precision = TexCoordPrecisionRequired(
       gl_, &highp_threshold_cache_, highp_threshold_min_,
       quad->shared_quad_state->visible_quad_layer_rect.bottom_right());
 
   const Program* program =
       GetProgram(ProgramKey::VideoStream(tex_coord_precision));
-  SetUseProgram(program->program());
-
-  ToGLMatrix(&gl_matrix[0], quad->matrix);
+  SetUseProgram(program);
 
   ResourceProvider::ScopedReadLockGL lock(resource_provider_,
                                           quad->resource_id());
 
   DCHECK_EQ(GL_TEXTURE0, GetActiveTextureUnit(gl_));
   gl_->BindTexture(GL_TEXTURE_EXTERNAL_OES, lock.texture_id());
 
+  static float gl_matrix[16];
+  ToGLMatrix(&gl_matrix[0], quad->matrix);
   gl_->UniformMatrix4fvStreamTextureMatrixCHROMIUM(
       program->tex_matrix_location(), false, gl_matrix);
 
-  gl_->Uniform1i(program->sampler_location(), 0);
-
-  SetShaderOpacity(quad->shared_quad_state->opacity, program->alpha_location());
+  SetShaderOpacity(quad);
   if (!clip_region) {
     DrawQuadGeometry(frame->projection_matrix,
                      quad->shared_quad_state->quad_to_target_transform,
-                     gfx::RectF(quad->rect), program->matrix_location());
+                     gfx::RectF(quad->rect));
   } 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);
     float uvs[8] = {0};
     GetScaledUVs(quad->visible_rect, clip_region, uvs);
     DrawQuadGeometryClippedByQuadF(
         frame, quad->shared_quad_state->quad_to_target_transform,
-        gfx::RectF(quad->rect), region_quad, program->matrix_location(), uvs);
+        gfx::RectF(quad->rect), region_quad, uvs);
   }
 }
 
 void GLRenderer::FlushTextureQuadCache(BoundGeometry flush_binding) {
   // Check to see if we have anything to draw.
-  if (draw_cache_.program_id == -1)
+  if (!draw_cache_.program)
     return;
 
   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.
-  gl_->Uniform1i(draw_cache_.sampler_location, 0);
+  SetUseProgram(draw_cache_.program);
 
   // 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_));
   gl_->BindTexture(locked_quad.target(), 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.
   gl_->UniformMatrix4fv(
-      static_cast<int>(draw_cache_.matrix_location),
+      draw_cache_.program->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),
+  gl_->Uniform4fv(draw_cache_.program->vertex_tex_transform_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);
-    gl_->Uniform4fv(draw_cache_.background_color_location, 1,
+    Float4 background_color =
+        PremultipliedColor(draw_cache_.background_color, 1.f);
+    gl_->Uniform4fv(draw_cache_.program->background_color_location(), 1,
                     background_color.data);
   }
 
   gl_->Uniform1fv(
-      static_cast<int>(draw_cache_.vertex_opacity_location),
+      draw_cache_.program->vertex_opacity_location(),
       static_cast<int>(draw_cache_.vertex_opacity_data.size()),
       static_cast<float*>(&draw_cache_.vertex_opacity_data.front()));
 
   DCHECK_LE(draw_cache_.matrix_data.size(),
             static_cast<size_t>(std::numeric_limits<int>::max()) / 6u);
   // Draw the quads!
   gl_->DrawElements(GL_TRIANGLES,
                     6 * static_cast<int>(draw_cache_.matrix_data.size()),
                     GL_UNSIGNED_SHORT, 0);
 
   // Draw the border if requested.
   if (gl_composited_texture_quad_border_) {
     // When we draw the composited borders we have one flush per quad.
     DCHECK_EQ(1u, draw_cache_.matrix_data.size());
     SetBlendEnabled(false);
     const Program* program = GetProgram(ProgramKey::DebugBorder());
-    DCHECK(program);
-    DCHECK(program->initialized() || IsContextLost());
-    SetUseProgram(program->program());
+    SetUseProgram(program);
 
     gl_->UniformMatrix4fv(
         program->matrix_location(), 1, false,
         reinterpret_cast<float*>(&draw_cache_.matrix_data.front()));
 
     // Pick a random color based on the scale on X and Y.
     int colorIndex = static_cast<int>(draw_cache_.matrix_data.front().data[0] *
                                       draw_cache_.matrix_data.front().data[5]);
     SkColor color = DebugColors::GLCompositedTextureQuadBorderColor(colorIndex);
-
-    gl_->Uniform4f(program->color_location(), SkColorGetR(color),
-                   SkColorGetG(color), SkColorGetB(color), 1.0f);
+    SetShaderColor(color, 1.f);
 
     gl_->LineWidth(DebugColors::GLCompositedTextureQuadBoderWidth());
     // The indices for the line are stored in the same array as the triangle
     // indices.
     gl_->DrawElements(GL_LINE_LOOP, 4, GL_UNSIGNED_SHORT, 0);
   }
 
   // Clear the cache.
-  draw_cache_.program_id = -1;
+  draw_cache_.program = nullptr;
+  draw_cache_.resource_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) {
     PrepareGeometry(SHARED_BINDING);
   }
 }
@@ skipping 16 matching lines @@
 
   ResourceProvider::ScopedReadLockGL lock(resource_provider_,
                                           quad->resource_id());
   const SamplerType sampler = SamplerTypeFromTextureTarget(lock.target());
 
   const Program* program = GetProgram(ProgramKey::Texture(
       tex_coord_precision, sampler,
       quad->premultiplied_alpha ? PREMULTIPLIED_ALPHA : NON_PREMULTIPLIED_ALPHA,
       quad->background_color != SK_ColorTRANSPARENT));
   int resource_id = quad->resource_id();
-  int program_id = program->program();
 
   size_t max_quads = StaticGeometryBinding::NUM_QUADS;
-  if (draw_cache_.program_id != program_id ||
+  if (draw_cache_.program != program ||
       draw_cache_.resource_id != resource_id ||
       draw_cache_.needs_blending != quad->ShouldDrawWithBlending() ||
       draw_cache_.nearest_neighbor != quad->nearest_neighbor ||
       draw_cache_.background_color != quad->background_color ||
       draw_cache_.matrix_data.size() >= max_quads) {
     FlushTextureQuadCache(SHARED_BINDING);
-    draw_cache_.program_id = program_id;
+    draw_cache_.program = program;
     draw_cache_.resource_id = resource_id;
     draw_cache_.needs_blending = quad->ShouldDrawWithBlending();
     draw_cache_.nearest_neighbor = quad->nearest_neighbor;
     draw_cache_.background_color = quad->background_color;
-
-    draw_cache_.uv_xform_location = program->vertex_tex_transform_location();
-    draw_cache_.background_color_location =
-        program->background_color_location();
-    draw_cache_.vertex_opacity_location = program->vertex_opacity_location();
-    draw_cache_.matrix_location = program->matrix_location();
-    draw_cache_.sampler_location = program->sampler_location();
   }
 
   // Generate the uv-transform
   Float4 uv_transform = {{0.0f, 0.0f, 1.0f, 1.0f}};
   if (!clip_region)
     uv_transform = UVTransform(quad);
   if (sampler == SAMPLER_TYPE_2D_RECT) {
     // Un-normalize the texture coordiantes for rectangle targets.
     gfx::Size texture_size = lock.size();
     uv_transform.data[0] *= texture_size.width();
@@ skipping 107 matching lines @@
   gfx::Rect copy_rect = frame->current_render_pass->output_rect;
   if (request->has_area())
     copy_rect.Intersect(request->area());
   GetFramebufferPixelsAsync(frame, copy_rect, std::move(request));
 }
 
 void GLRenderer::ToGLMatrix(float* gl_matrix, const gfx::Transform& transform) {
   transform.matrix().asColMajorf(gl_matrix);
 }
 
-void GLRenderer::SetShaderQuadF(const gfx::QuadF& quad, int quad_location) {
-  if (quad_location == -1)
+void GLRenderer::SetShaderQuadF(const gfx::QuadF& quad) {
+  if (!program_shadow_ || program_shadow_->quad_location() == -1)
     return;
-
   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();
-  gl_->Uniform2fv(quad_location, 4, gl_quad);
+  gl_->Uniform2fv(program_shadow_->quad_location(), 4, gl_quad);
 }
 
-void GLRenderer::SetShaderOpacity(float opacity, int alpha_location) {
-  if (alpha_location != -1)
-    gl_->Uniform1f(alpha_location, opacity);
+void GLRenderer::SetShaderOpacity(const DrawQuad* quad) {
+  if (!program_shadow_ || program_shadow_->alpha_location() == -1)
+    return;
+  gl_->Uniform1f(program_shadow_->alpha_location(),
+                 quad->shared_quad_state->opacity);
+}
+
+void GLRenderer::SetShaderMatrix(const gfx::Transform& transform) {
+  if (!program_shadow_ || program_shadow_->matrix_location() == -1)
+    return;
+  float gl_matrix[16];
+  ToGLMatrix(gl_matrix, transform);
+  gl_->UniformMatrix4fv(program_shadow_->matrix_location(), 1, false,
+                        gl_matrix);
+}
+
+void GLRenderer::SetShaderColor(SkColor color, float opacity) {
+  if (!program_shadow_ || program_shadow_->color_location() == -1)
+    return;
+  Float4 float_color = PremultipliedColor(color, opacity);
+  gl_->Uniform4fv(program_shadow_->color_location(), 1, float_color.data);
 }
 
 void GLRenderer::SetStencilEnabled(bool enabled) {
   if (enabled == stencil_shadow_)
     return;
 
   if (enabled)
     gl_->Enable(GL_STENCIL_TEST);
   else
     gl_->Disable(GL_STENCIL_TEST);
   stencil_shadow_ = enabled;
 }
 
 void GLRenderer::SetBlendEnabled(bool enabled) {
   if (enabled == blend_shadow_)
     return;
 
   if (enabled)
     gl_->Enable(GL_BLEND);
   else
     gl_->Disable(GL_BLEND);
   blend_shadow_ = enabled;
 }
 
-void GLRenderer::SetUseProgram(unsigned program) {
+void GLRenderer::SetUseProgram(const Program* program) {
+  DCHECK(program);
+  DCHECK(program->initialized() || IsContextLost());
   if (program == program_shadow_)
     return;
-  gl_->UseProgram(program);
+  gl_->UseProgram(program->program());
+
+  // Set uniforms that are common to all programs.
+  if (program->sampler_location() != -1)
+    gl_->Uniform1i(program->sampler_location(), 0);
+  if (program->viewport_location() != -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()),
+    };
+    gl_->Uniform4fv(program->viewport_location(), 1, viewport);
+  }
   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);
-  gl_->UniformMatrix4fv(matrix_location, 1, false, &gl_matrix[0]);
+  SetShaderMatrix(frame->projection_matrix * quad_rect_matrix);
 
   gl_->DrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT,
                     reinterpret_cast<const void*>(0));
 }
 
 void GLRenderer::DrawQuadGeometry(const gfx::Transform& projection_matrix,
                                   const gfx::Transform& draw_transform,
-                                  const gfx::RectF& quad_rect,
-                                  int matrix_location) {
+                                  const gfx::RectF& quad_rect) {
   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], projection_matrix * quad_rect_matrix);
-  gl_->UniformMatrix4fv(matrix_location, 1, false, &gl_matrix[0]);
+  SetShaderMatrix(projection_matrix * quad_rect_matrix);
 
   gl_->DrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0);
 }
 
 void GLRenderer::SwapBuffers(std::vector<ui::LatencyInfo> latency_info) {
   DCHECK(visible_);
 
   TRACE_EVENT0("cc", "GLRenderer::SwapBuffers");
   // We're done! Time to swapbuffers!
 
@@ skipping 419 matching lines @@
     gl_->DeleteRenderbuffers(1, &offscreen_stencil_renderbuffer_id_);
 
   ReleaseRenderPassTextures();
 }
 
 void GLRenderer::ReinitializeGLState() {
   is_scissor_enabled_ = false;
   scissor_rect_ = gfx::Rect();
   stencil_shadow_ = false;
   blend_shadow_ = true;
-  program_shadow_ = 0;
+  program_shadow_ = nullptr;
 
   RestoreGLState();
 }
 
 void GLRenderer::RestoreGLState() {
   // This restores the current GLRenderer state to the GL context.
   bound_geometry_ = NO_BINDING;
   PrepareGeometry(SHARED_BINDING);
 
   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_);
+    gl_->UseProgram(program_shadow_->program());
 
   if (stencil_shadow_)
     gl_->Enable(GL_STENCIL_TEST);
   else
     gl_->Disable(GL_STENCIL_TEST);
 
   if (blend_shadow_)
     gl_->Enable(GL_BLEND);
   else
     gl_->Disable(GL_BLEND);
@@ skipping 306 matching lines @@
 
   // Test only, keep everything.
   gl_->StencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
 
   EnsureScissorTestDisabled();
   SetBlendEnabled(true);
 
   PrepareGeometry(SHARED_BINDING);
 
   const Program* program = GetProgram(ProgramKey::DebugBorder());
-  DCHECK(program);
-  DCHECK(program->initialized() || IsContextLost());
-  SetUseProgram(program->program());
+  SetUseProgram(program);
 
   gfx::Transform render_matrix;
   render_matrix.Translate(0.5 * output_rect.width() + output_rect.x(),
                           0.5 * output_rect.height() + output_rect.y());
   render_matrix.Scale(output_rect.width(), output_rect.height());
-  static float gl_matrix[16];
-  GLRenderer::ToGLMatrix(&gl_matrix[0],
-                         frame->projection_matrix * render_matrix);
-  gl_->UniformMatrix4fv(program->matrix_location(), 1, false, &gl_matrix[0]);
+  SetShaderMatrix(frame->projection_matrix * render_matrix);
 
   // Produce hinting for the amount of overdraw on screen for each pixel by
   // drawing hint colors to the framebuffer based on the current stencil value.
   struct {
     int multiplier;
     GLenum func;
     GLint ref;
     SkColor color;
   } stencil_tests[] = {
       {1, GL_EQUAL, 2, 0x2f0000ff},  // Blue: Overdrawn once.
@@ skipping 28 matching lines @@
 
   for (const auto& test : stencil_tests) {
     GLuint query = 0;
     if (tracing_enabled) {
       gl_->GenQueriesEXT(1, &query);
       gl_->BeginQueryEXT(GL_SAMPLES_PASSED_ARB, query);
     }
 
     gl_->StencilFunc(test.func, test.ref, 0xffffffff);
     // Transparent color unless color-coding of overdraw is enabled.
-    Float4 color =
-        PremultipliedColor(settings_->show_overdraw_feedback ? test.color : 0);
-    gl_->Uniform4fv(program->color_location(), 1, color.data);
+    SetShaderColor(settings_->show_overdraw_feedback ? test.color : 0, 1.f);
     gl_->DrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0);
 
     if (query) {
       gl_->EndQueryEXT(GL_SAMPLES_PASSED_ARB);
       context_support_->SignalQuery(
           query,
           base::Bind(overdraw_feedback_callback, query, test.multiplier));
     }
   }
 }
@@ skipping 17 matching lines @@
     return;
 
   // Report GPU overdraw as a percentage of |max_result|.
   TRACE_COUNTER1(
       TRACE_DISABLED_BY_DEFAULT("cc.debug.overdraw"), "GPU Overdraw",
       (std::accumulate(overdraw->begin(), overdraw->end(), 0) * 100) /
           max_result);
 }
 
 }  // namespace cc