Use GLES2Interface for shaders and programs

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 20 matching lines @@
 #include "cc/quads/stream_video_draw_quad.h"
 #include "cc/quads/texture_draw_quad.h"
 #include "cc/resources/layer_quad.h"
 #include "cc/resources/scoped_resource.h"
 #include "cc/resources/texture_mailbox_deleter.h"
 #include "cc/trees/damage_tracker.h"
 #include "cc/trees/proxy.h"
 #include "cc/trees/single_thread_proxy.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/context_support.h"
+#include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/command_buffer/common/gpu_memory_allocation.h"
 #include "third_party/WebKit/public/platform/WebGraphicsContext3D.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkColorFilter.h"
 #include "third_party/skia/include/core/SkSurface.h"
 #include "third_party/skia/include/gpu/GrContext.h"
 #include "third_party/skia/include/gpu/GrTexture.h"
@@ skipping 112 matching lines @@
 GLRenderer::GLRenderer(RendererClient* client,
                        const LayerTreeSettings* settings,
                        OutputSurface* output_surface,
                        ResourceProvider* resource_provider,
                        TextureMailboxDeleter* texture_mailbox_deleter,
                        int highp_threshold_min)
     : DirectRenderer(client, settings, output_surface, resource_provider),
       offscreen_framebuffer_id_(0),
       shared_geometry_quad_(gfx::RectF(-0.5f, -0.5f, 1.0f, 1.0f)),
       context_(output_surface->context_provider()->Context3d()),
+      gl_(output_surface->context_provider()->ContextGL()),
       context_support_(output_surface->context_provider()->ContextSupport()),
       texture_mailbox_deleter_(texture_mailbox_deleter),
       is_backbuffer_discarded_(false),
       visible_(true),
       is_scissor_enabled_(false),
       scissor_rect_needs_reset_(true),
       stencil_shadow_(false),
       blend_shadow_(false),
       highp_threshold_min_(highp_threshold_min),
       highp_threshold_cache_(0),
@@ skipping 769 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());
   }
 
   TexCoordPrecision tex_coord_precision = TexCoordPrecisionRequired(
-      context_, &highp_threshold_cache_, highp_threshold_min_,
+      gl_, &highp_threshold_cache_, highp_threshold_min_,
       quad->shared_quad_state->visible_content_rect.bottom_right());
 
   int shader_quad_location = -1;
   int shader_edge_location = -1;
   int shader_viewport_location = -1;
   int shader_mask_sampler_location = -1;
   int shader_mask_tex_coord_scale_location = -1;
   int shader_mask_tex_coord_offset_location = -1;
   int shader_matrix_location = -1;
   int shader_alpha_location = -1;
@@ skipping 485 matching lines @@
   clamp_tex_rect.Inset(tex_clamp_x, tex_clamp_y, tex_clamp_x, tex_clamp_y);
 
   // Map clamping rectangle to unit square.
   float vertex_tex_translate_x = -clamp_geom_rect.x() / clamp_geom_rect.width();
   float vertex_tex_translate_y =
       -clamp_geom_rect.y() / clamp_geom_rect.height();
   float vertex_tex_scale_x = tile_rect.width() / clamp_geom_rect.width();
   float vertex_tex_scale_y = tile_rect.height() / clamp_geom_rect.height();
 
   TexCoordPrecision tex_coord_precision = TexCoordPrecisionRequired(
-      context_, &highp_threshold_cache_, highp_threshold_min_,
+      gl_, &highp_threshold_cache_, highp_threshold_min_,
       quad->texture_size);
 
   gfx::Transform device_transform =
       frame->window_matrix * frame->projection_matrix * quad->quadTransform();
   device_transform.FlattenTo2d();
   if (!device_transform.IsInvertible())
     return;
 
   gfx::QuadF local_quad = gfx::QuadF(gfx::RectF(tile_rect));
   float edge[24];
@@ skipping 122 matching lines @@
       tile_rect.size());
   DrawQuadGeometry(
       frame, quad->quadTransform(), centered_rect, uniforms.matrix_location);
 }
 
 void GLRenderer::DrawYUVVideoQuad(const DrawingFrame* frame,
                                   const YUVVideoDrawQuad* quad) {
   SetBlendEnabled(quad->ShouldDrawWithBlending());
 
   TexCoordPrecision tex_coord_precision = TexCoordPrecisionRequired(
-      context_, &highp_threshold_cache_, highp_threshold_min_,
+      gl_, &highp_threshold_cache_, highp_threshold_min_,
       quad->shared_quad_state->visible_content_rect.bottom_right());
 
   bool use_alpha_plane = quad->a_plane_resource_id != 0;
 
   ResourceProvider::ScopedSamplerGL y_plane_lock(
       resource_provider_,
       quad->y_plane_resource_id,
       GL_TEXTURE1,
       GL_LINEAR);
   DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D), y_plane_lock.target());
@@ skipping 92 matching lines @@
 
 void GLRenderer::DrawStreamVideoQuad(const DrawingFrame* frame,
                                      const StreamVideoDrawQuad* quad) {
   SetBlendEnabled(quad->ShouldDrawWithBlending());
 
   static float gl_matrix[16];
 
   DCHECK(capabilities_.using_egl_image);
 
   TexCoordPrecision tex_coord_precision = TexCoordPrecisionRequired(
-      context_, &highp_threshold_cache_, highp_threshold_min_,
+      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(Context(),
       Context()->uniformMatrix4fv(
           program->vertex_shader().tex_matrix_location(), 1, false, gl_matrix));
@@ skipping 161 matching lines @@
   // Clear the cache.
   draw_cache_.program_id = 0;
   draw_cache_.uv_xform_data.resize(0);
   draw_cache_.vertex_opacity_data.resize(0);
   draw_cache_.matrix_data.resize(0);
 }
 
 void GLRenderer::EnqueueTextureQuad(const DrawingFrame* frame,
                                     const TextureDrawQuad* quad) {
   TexCoordPrecision tex_coord_precision = TexCoordPrecisionRequired(
-      context_, &highp_threshold_cache_, highp_threshold_min_,
+      gl_, &highp_threshold_cache_, highp_threshold_min_,
       quad->shared_quad_state->visible_content_rect.bottom_right());
 
   // Choose the correct texture program binding
   TexTransformTextureProgramBinding binding;
   if (quad->premultiplied_alpha) {
     if (quad->background_color == SK_ColorTRANSPARENT) {
       binding.Set(GetTextureProgram(tex_coord_precision));
     } else {
       binding.Set(GetTextureBackgroundProgram(tex_coord_precision));
     }
@@ skipping 44 matching lines @@
   Float16 m;
   quad_rect_matrix.matrix().asColMajorf(m.data);
   draw_cache_.matrix_data.push_back(m);
 }
 
 void GLRenderer::DrawIOSurfaceQuad(const DrawingFrame* frame,
                                    const IOSurfaceDrawQuad* quad) {
   SetBlendEnabled(quad->ShouldDrawWithBlending());
 
   TexCoordPrecision tex_coord_precision = TexCoordPrecisionRequired(
-      context_,  &highp_threshold_cache_, highp_threshold_min_,
+      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(Context(), Context()->uniform1i(binding.sampler_location, 0));
   if (quad->orientation == IOSurfaceDrawQuad::FLIPPED) {
     GLC(Context(),
         Context()->uniform4f(binding.tex_transform_location,
@@ skipping 111 matching lines @@
   if (enabled)
     GLC(context_, context_->enable(GL_BLEND));
   else
     GLC(context_, context_->disable(GL_BLEND));
   blend_shadow_ = enabled;
 }
 
 void GLRenderer::SetUseProgram(unsigned program) {
   if (program == program_shadow_)
     return;
-  GLC(context_, context_->useProgram(program));
+  gl_->UseProgram(program);
   program_shadow_ = program;
 }
 
 void GLRenderer::DrawQuadGeometry(const DrawingFrame* frame,
                                   const gfx::Transform& draw_transform,
                                   const gfx::RectF& quad_rect,
                                   int matrix_location) {
   gfx::Transform quad_rect_matrix;
   QuadRectTransform(&quad_rect_matrix, draw_transform, quad_rect);
   static float gl_matrix[16];
   ToGLMatrix(&gl_matrix[0], frame->projection_matrix * quad_rect_matrix);
   GLC(context_,
       context_->uniformMatrix4fv(matrix_location, 1, false, &gl_matrix[0]));
 
   GLC(context_, context_->drawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0));
 }
 
 void GLRenderer::CopyTextureToFramebuffer(const DrawingFrame* frame,
                                           int texture_id,
                                           gfx::Rect rect,
                                           const gfx::Transform& draw_matrix,
                                           bool flip_vertically) {
   TexCoordPrecision tex_coord_precision = TexCoordPrecisionRequired(
-      context_, &highp_threshold_cache_, highp_threshold_min_,
+      gl_, &highp_threshold_cache_, highp_threshold_min_,
       rect.bottom_right());
 
   const RenderPassProgram* program = GetRenderPassProgram(tex_coord_precision);
   SetUseProgram(program->program());
 
   GLC(Context(), Context()->uniform1i(
       program->fragment_shader().sampler_location(), 0));
 
   if (flip_vertically) {
     GLC(Context(), Context()->uniform4f(
@@ skipping 874 matching lines @@
   return program;
 }
 
 void GLRenderer::CleanupSharedObjects() {
   MakeContextCurrent();
 
   shared_geometry_.reset();
 
   for (int i = 0; i < NumTexCoordPrecisions; ++i) {
     for (int j = 0; j < NumSamplerTypes; ++j) {
-      tile_program_[i][j].Cleanup(context_);
-      tile_program_opaque_[i][j].Cleanup(context_);
-      tile_program_swizzle_[i][j].Cleanup(context_);
-      tile_program_swizzle_opaque_[i][j].Cleanup(context_);
-      tile_program_aa_[i][j].Cleanup(context_);
-      tile_program_swizzle_aa_[i][j].Cleanup(context_);
+      tile_program_[i][j].Cleanup(gl_);
+      tile_program_opaque_[i][j].Cleanup(gl_);
+      tile_program_swizzle_[i][j].Cleanup(gl_);
+      tile_program_swizzle_opaque_[i][j].Cleanup(gl_);
+      tile_program_aa_[i][j].Cleanup(gl_);
+      tile_program_swizzle_aa_[i][j].Cleanup(gl_);
     }
 
-    render_pass_mask_program_[i].Cleanup(context_);
-    render_pass_program_[i].Cleanup(context_);
-    render_pass_mask_program_aa_[i].Cleanup(context_);
-    render_pass_program_aa_[i].Cleanup(context_);
-    render_pass_color_matrix_program_[i].Cleanup(context_);
-    render_pass_mask_color_matrix_program_aa_[i].Cleanup(context_);
-    render_pass_color_matrix_program_aa_[i].Cleanup(context_);
-    render_pass_mask_color_matrix_program_[i].Cleanup(context_);
+    render_pass_mask_program_[i].Cleanup(gl_);
+    render_pass_program_[i].Cleanup(gl_);
+    render_pass_mask_program_aa_[i].Cleanup(gl_);
+    render_pass_program_aa_[i].Cleanup(gl_);
+    render_pass_color_matrix_program_[i].Cleanup(gl_);
+    render_pass_mask_color_matrix_program_aa_[i].Cleanup(gl_);
+    render_pass_color_matrix_program_aa_[i].Cleanup(gl_);
+    render_pass_mask_color_matrix_program_[i].Cleanup(gl_);
 
-    texture_program_[i].Cleanup(context_);
-    nonpremultiplied_texture_program_[i].Cleanup(context_);
-    texture_background_program_[i].Cleanup(context_);
-    nonpremultiplied_texture_background_program_[i].Cleanup(context_);
-    texture_io_surface_program_[i].Cleanup(context_);
+    texture_program_[i].Cleanup(gl_);
+    nonpremultiplied_texture_program_[i].Cleanup(gl_);
+    texture_background_program_[i].Cleanup(gl_);
+    nonpremultiplied_texture_background_program_[i].Cleanup(gl_);
+    texture_io_surface_program_[i].Cleanup(gl_);
 
-    video_yuv_program_[i].Cleanup(context_);
-    video_yuva_program_[i].Cleanup(context_);
-    video_stream_texture_program_[i].Cleanup(context_);
+    video_yuv_program_[i].Cleanup(gl_);
+    video_yuva_program_[i].Cleanup(gl_);
+    video_stream_texture_program_[i].Cleanup(gl_);
   }
 
-  tile_checkerboard_program_.Cleanup(context_);
+  tile_checkerboard_program_.Cleanup(gl_);
 
-  debug_border_program_.Cleanup(context_);
-  solid_color_program_.Cleanup(context_);
-  solid_color_program_aa_.Cleanup(context_);
+  debug_border_program_.Cleanup(gl_);
+  solid_color_program_.Cleanup(gl_);
+  solid_color_program_aa_.Cleanup(gl_);
 
   if (offscreen_framebuffer_id_)
     GLC(context_, context_->deleteFramebuffer(offscreen_framebuffer_id_));
 
   if (on_demand_tile_raster_resource_id_)
     resource_provider_->DeleteResource(on_demand_tile_raster_resource_id_);
 
   ReleaseRenderPassTextures();
 }
 
@@ skipping 16 matching lines @@
   is_scissor_enabled_ = false;
   GLC(context_, context_->disable(GL_SCISSOR_TEST));
   scissor_rect_needs_reset_ = true;
 }
 
 bool GLRenderer::IsContextLost() {
   return output_surface_->context_provider()->IsContextLost();
 }
 
 }  // namespace cc