Implement on demand quad rasterization for PicturePiles.

cc/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/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/compositor_frame.h"
 #include "cc/compositor_frame_metadata.h"
 #include "cc/context_provider.h"
 #include "cc/damage_tracker.h"
 #include "cc/geometry_binding.h"
 #include "cc/gl_frame_data.h"
 #include "cc/layer_quad.h"
 #include "cc/math_util.h"
 #include "cc/output_surface.h"
+#include "cc/picture_draw_quad.h"
 #include "cc/priority_calculator.h"
 #include "cc/proxy.h"
 #include "cc/render_pass.h"
 #include "cc/render_surface_filters.h"
 #include "cc/scoped_resource.h"
 #include "cc/single_thread_proxy.h"
 #include "cc/stream_video_draw_quad.h"
 #include "cc/texture_draw_quad.h"
 #include "cc/video_layer_impl.h"
 #include "gpu/GLES2/gl2extchromium.h"
@@ skipping 60 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_texture_(0),
+      on_demand_tile_raster_resource_id_(0) {
   DCHECK(context_);
 }
 
 bool GLRenderer::Initialize() {
   if (!context_->makeContextCurrent())
     return false;
 
   context_->setContextLostCallback(this);
   context_->pushGroupMarkerEXT("CompositorContext");
 
@@ skipping 196 matching lines @@
       break;
     case DrawQuad::TEXTURE_CONTENT:
       EnqueueTextureQuad(frame, TextureDrawQuad::MaterialCast(quad));
       break;
     case DrawQuad::TILED_CONTENT:
       DrawTileQuad(frame, TileDrawQuad::MaterialCast(quad));
       break;
     case DrawQuad::YUV_VIDEO_CONTENT:
       DrawYUVVideoQuad(frame, YUVVideoDrawQuad::MaterialCast(quad));
       break;
+    case DrawQuad::PICTURE_CONTENT:

[danakj, 2013/03/14 18:00:56]

alphabetical please

[Leandro Graciá Gil, 2013/03/19 17:30:07]

Done.

+      DrawPictureQuad(frame, PictureDrawQuad::MaterialCast(quad));
+      break;
   }
 }
 
 void GLRenderer::DrawCheckerboardQuad(const DrawingFrame& frame,
                                       const CheckerboardDrawQuad* quad) {
   SetBlendEnabled(quad->ShouldDrawWithBlending());
 
   const TileCheckerboardProgram* program = GetTileCheckerboardProgram();
   DCHECK(program && (program->initialized() || IsContextLost()));
   SetUseProgram(program->program());
@@ skipping 646 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::ResourceId resource_id = quad->IsPictureQuad() ?

[danakj, 2013/03/14 18:00:56]

How would you ever get here with IsPictureQuad() true? If it's true, the
material is PICTURE_CONTENT, and you'd be in DrawPictureQuad().

[danakj, 2013/03/14 18:01:21]

Sorry, ignore this, I answered this myself later.

[enne (OOO), 2013/03/15 03:29:28]

I'd prefer if you just passed drawTileQuad the resource you wanted to draw with
rather than interrogating the quad.

I agree with Dana that this design of inheriting from TileDrawQuad is a little
bit fishy.  I don't know if it'd be better to either have both TileDrawQuad and
PictureDrawQuad inherit from a base class that has everything on it but the
resource id, or if it'd be better to have TileDrawQuad and PictureDrawQuad not
related at all and just have a DrawTileQuad() helper function that took a dozen
parameters so you didn't have to make the types related just to share code.  In
any case, I think the current approach has some design smell to it.

[Leandro Graciá Gil, 2013/03/19 17:30:07]

I agree. I'm going with the base class. Seems a cleaner solution than adding a
dozen of params or using templates.

+      on_demand_tile_raster_resource_id_ : quad->resource_id;
   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) {
     LayerQuad deviceLayerBounds(gfx::QuadF(device_layer_quad.BoundingBox()));
     deviceLayerBounds.InflateAntiAliasingDistance();
 
     LayerQuad device_layer_edges(device_layer_quad);
     device_layer_edges.InflateAntiAliasingDistance();
 
     float edge[24];
     device_layer_edges.ToFloatArray(edge);
@@ skipping 198 matching lines @@
   GLC(Context(),
       Context()->uniform1i(program->fragmentShader().samplerLocation(), 0));
 
   SetShaderOpacity(quad->opacity(), program->fragmentShader().alphaLocation());
   DrawQuadGeometry(frame,
                    quad->quadTransform(),
                    quad->rect,
                    program->vertexShader().matrixLocation());
 }
 
+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();
+  }
+
+  SkDevice device(on_demand_tile_raster_bitmap_);
+  SkCanvas canvas(&device);
+
+  int64 total_pixels_rasterized = 0;
+  quad->picture_pile->Raster(
+      &canvas,
+      quad->content_rect,
+      quad->contents_scale,
+      &total_pixels_rasterized);
+
+  GLC(Context(), Context()->bindTexture(
+      GL_TEXTURE_2D,
+      on_demand_tile_raster_texture_));
+
+  GLC(Context(), Context()->texImage2D(
+      GL_TEXTURE_2D,
+      0,
+      GL_RGBA,
+      quad->texture_size.width(),
+      quad->texture_size.height(),
+      0,
+      GL_RGBA,
+      GL_UNSIGNED_BYTE,
+      on_demand_tile_raster_bitmap_.getPixels()));
+
+  DrawTileQuad(frame, quad);
+}
+
 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->fragmentShader().samplerLocation();
     matrix_location = program->vertexShader().matrixLocation();
     alpha_location = program->fragmentShader().alphaLocation();
   }
   int program_id;
@@ skipping 663 matching lines @@
 
   // We will always need these programs to render, so create the programs
   // eagerly so that the shader compilation can start while we do other work.
   // Other programs are created lazily on first access.
   shared_geometry_ =
       make_scoped_ptr(new GeometryBinding(context_, QuadVertexRect()));
   render_pass_program_ = make_scoped_ptr(new RenderPassProgram(context_));
   tile_program_ = make_scoped_ptr(new TileProgram(context_));
   tile_program_opaque_ = make_scoped_ptr(new TileProgramOpaque(context_));
 
+  on_demand_tile_raster_texture_ = Context()->createTexture();

[vmpstr, 2013/03/13 21:03:08]

Should this be cleaned up in CleanupSharedObjects?

[Leandro Graciá Gil, 2013/03/19 17:30:07]

Yes. This was accidentally missed while rebasing over
https://codereview.chromium.org/12353003/. Fixed.

+  on_demand_tile_raster_resource_id_ =
+      resource_provider_->CreateResourceFromExternalTexture(
+          on_demand_tile_raster_texture_);
+
   GLC(context_, context_->flush());
 
   return true;
 }
 
 const GLRenderer::TileCheckerboardProgram*
 GLRenderer::GetTileCheckerboardProgram() {
   if (!tile_checkerboard_program_)
     tile_checkerboard_program_ =
         make_scoped_ptr(new TileCheckerboardProgram(context_));
@@ skipping 221 matching lines @@
     GLC(context_, context_->deleteFramebuffer(offscreen_framebuffer_id_));
 
   ReleaseRenderPassTextures();
 }
 
 bool GLRenderer::IsContextLost() {
   return (context_->getGraphicsResetStatusARB() != GL_NO_ERROR);
 }
 
 }  // namespace cc