Implement on demand quad rasterization for PicturePiles.

cc/output/gl_renderer.cc

 // Copyright 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/output/gl_renderer.h"
 
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/strings/string_split.h"
 #include "build/build_config.h"
 #include "cc/base/math_util.h"
 #include "cc/layers/video_layer_impl.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/compositor_frame_metadata.h"
 #include "cc/output/context_provider.h"
 #include "cc/output/geometry_binding.h"
 #include "cc/output/gl_frame_data.h"
 #include "cc/output/output_surface.h"
 #include "cc/output/render_surface_filters.h"
+#include "cc/quads/picture_draw_quad.h"
 #include "cc/quads/render_pass.h"
 #include "cc/quads/stream_video_draw_quad.h"
 #include "cc/quads/texture_draw_quad.h"
 #include "cc/resources/layer_quad.h"
 #include "cc/resources/priority_calculator.h"
 #include "cc/resources/scoped_resource.h"
 #include "cc/trees/damage_tracker.h"
 #include "cc/trees/proxy.h"
 #include "cc/trees/single_thread_proxy.h"
 #include "gpu/GLES2/gl2extchromium.h"
@@ skipping 62 matching lines @@
     : DirectRenderer(client, resource_provider),
       offscreen_framebuffer_id_(0),
       shared_geometry_quad_(gfx::RectF(-0.5f, -0.5f, 1.0f, 1.0f)),
       output_surface_(output_surface),
       context_(output_surface->context3d()),
       is_viewport_changed_(false),
       is_backbuffer_discarded_(false),
       discard_backbuffer_when_not_visible_(false),
       is_using_bind_uniform_(false),
       visible_(true),
-      is_scissor_enabled_(false) {
+      is_scissor_enabled_(false),
+      on_demand_tile_raster_resource_id_(0) {
   DCHECK(context_);
 }
 
 bool GLRenderer::Initialize() {
   if (!context_->makeContextCurrent())
     return false;
 
   context_->setContextLostCallback(this);
   context_->pushGroupMarkerEXT("CompositorContext");
 
@@ skipping 178 matching lines @@
       break;
     case DrawQuad::CHECKERBOARD:
       DrawCheckerboardQuad(frame, CheckerboardDrawQuad::MaterialCast(quad));
       break;
     case DrawQuad::DEBUG_BORDER:
       DrawDebugBorderQuad(frame, DebugBorderDrawQuad::MaterialCast(quad));
       break;
     case DrawQuad::IO_SURFACE_CONTENT:
       DrawIOSurfaceQuad(frame, IOSurfaceDrawQuad::MaterialCast(quad));
       break;
+    case DrawQuad::PICTURE_CONTENT:
+      DrawPictureQuad(frame, PictureDrawQuad::MaterialCast(quad));
+      break;
     case DrawQuad::RENDER_PASS:
       DrawRenderPassQuad(frame, RenderPassDrawQuad::MaterialCast(quad));
       break;
     case DrawQuad::SOLID_COLOR:
       DrawSolidColorQuad(frame, SolidColorDrawQuad::MaterialCast(quad));
       break;
     case DrawQuad::STREAM_VIDEO_CONTENT:
       DrawStreamVideoQuad(frame, StreamVideoDrawQuad::MaterialCast(quad));
       break;
     case DrawQuad::TEXTURE_CONTENT:
@@ skipping 715 matching lines @@
 
   uniforms->sampler_location = program->fragment_shader().sampler_location();
   uniforms->alpha_location = program->fragment_shader().alpha_location();
   uniforms->fragment_tex_transform_location =
       program->fragment_shader().fragment_tex_transform_location();
   uniforms->edge_location = program->fragment_shader().edge_location();
 }
 
 void GLRenderer::DrawTileQuad(const DrawingFrame* frame,
                               const TileDrawQuad* quad) {
+  DrawContentQuad(frame, quad, quad->resource_id);
+}
+
+void GLRenderer::DrawContentQuad(const DrawingFrame* frame,
+                                 const ContentDrawQuadBase* quad,
+                                 ResourceProvider::ResourceId resource_id) {
   gfx::Rect tile_rect = quad->visible_rect;
 
   gfx::RectF tex_coord_rect = quad->tex_coord_rect;
   float tex_to_geom_scale_x = quad->rect.width() / tex_coord_rect.width();
   float tex_to_geom_scale_y = quad->rect.height() / tex_coord_rect.height();
 
   // tex_coord_rect corresponds to quad_rect, but quad_visible_rect may be
   // smaller than quad_rect due to occlusion or clipping. Adjust
   // tex_coord_rect to match.
   gfx::Vector2d top_left_diff = tile_rect.origin() - quad->rect.origin();
@@ skipping 68 matching lines @@
   }
 
   SetUseProgram(uniforms.program);
   GLC(Context(), Context()->uniform1i(uniforms.sampler_location, 0));
   bool scaled = (tex_to_geom_scale_x != 1.f || tex_to_geom_scale_y != 1.f);
   GLenum filter = (use_aa || scaled ||
                    !quad->quadTransform().IsIdentityOrIntegerTranslation())
                   ? GL_LINEAR
                   : GL_NEAREST;
   ResourceProvider::ScopedSamplerGL quad_resource_lock(
-      resource_provider_, quad->resource_id, GL_TEXTURE_2D, filter);
+      resource_provider_, resource_id, GL_TEXTURE_2D, filter);
 
   if (use_aa) {
     GLC(Context(), Context()->uniform3fv(uniforms.edge_location, 8, edge));
 
     GLC(Context(),
         Context()->uniform4f(uniforms.vertex_tex_transform_location,
                              vertex_tex_translate_x,
                              vertex_tex_translate_y,
                              vertex_tex_scale_x,
                              vertex_tex_scale_y));
@@ skipping 135 matching lines @@
       Context()->uniform1i(program->fragment_shader().sampler_location(), 0));
 
   SetShaderOpacity(quad->opacity(),
                    program->fragment_shader().alpha_location());
   DrawQuadGeometry(frame,
                    quad->quadTransform(),
                    quad->rect,
                    program->vertex_shader().matrix_location());
 }
 
+void GLRenderer::DrawPictureQuad(const DrawingFrame* frame,
+                                 const PictureDrawQuad* quad) {
+  if (on_demand_tile_raster_bitmap_.width() != quad->texture_size.width() ||
+      on_demand_tile_raster_bitmap_.height() != quad->texture_size.height()) {
+    on_demand_tile_raster_bitmap_.setConfig(
+        SkBitmap::kARGB_8888_Config,
+        quad->texture_size.width(),
+        quad->texture_size.height());
+    on_demand_tile_raster_bitmap_.allocPixels();
+
+    if (on_demand_tile_raster_resource_id_)
+      resource_provider_->DeleteResource(on_demand_tile_raster_resource_id_);
+
+    on_demand_tile_raster_resource_id_ = resource_provider_->CreateGLTexture(
+        quad->texture_size,
+        GL_RGBA,
+        GL_TEXTURE_POOL_UNMANAGED_CHROMIUM,
+        ResourceProvider::TextureUsageAny);
+  }
+
+  SkDevice device(on_demand_tile_raster_bitmap_);
+  SkCanvas canvas(&device);
+
+  quad->picture_pile->Raster(&canvas, quad->content_rect, quad->contents_scale);
+
+  resource_provider_->SetPixels(
+      on_demand_tile_raster_resource_id_,
+      reinterpret_cast<uint8_t*>(on_demand_tile_raster_bitmap_.getPixels()),
+      gfx::Rect(quad->texture_size),
+      gfx::Rect(quad->texture_size),
+      gfx::Vector2d());
+
+  DrawContentQuad(frame, quad, on_demand_tile_raster_resource_id_);
+}
+
 struct TextureProgramBinding {
   template <class Program>
   void Set(Program* program, WebKit::WebGraphicsContext3D* context) {
     DCHECK(program && (program->initialized() || context->isContextLost()));
     program_id = program->program();
     sampler_location = program->fragment_shader().sampler_location();
     matrix_location = program->vertex_shader().matrix_location();
     alpha_location = program->fragment_shader().alpha_location();
   }
   int program_id;
@@ skipping 926 matching lines @@
   if (debug_border_program_)
     debug_border_program_->Cleanup(context_);
   if (solid_color_program_)
     solid_color_program_->Cleanup(context_);
   if (solid_color_program_aa_)
     solid_color_program_aa_->Cleanup(context_);
 
   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();
 }
 
 bool GLRenderer::IsContextLost() {
   return (context_->getGraphicsResetStatusARB() != GL_NO_ERROR);
 }
 
 }  // namespace cc