Implement on demand quad rasterization for PicturePiles.

cc/output/gl_renderer.h

 // 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.
 
 #ifndef CC_OUTPUT_GL_RENDERER_H_
 #define CC_OUTPUT_GL_RENDERER_H_
 
 #include "cc/base/cc_export.h"
 #include "cc/output/direct_renderer.h"
 #include "cc/output/gl_renderer_draw_cache.h"
 #include "cc/output/renderer.h"
 #include "cc/quads/checkerboard_draw_quad.h"
 #include "cc/quads/debug_border_draw_quad.h"
 #include "cc/quads/io_surface_draw_quad.h"
 #include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/solid_color_draw_quad.h"
 #include "cc/quads/tile_draw_quad.h"
 #include "cc/quads/yuv_video_draw_quad.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebGraphicsContext3D.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebGraphicsMemoryAllocation.h"
 #include "ui/gfx/quad_f.h"
 
 namespace cc {
 
 class GLRendererShaderTest;
 class OutputSurface;
+class PictureDrawQuad;
 class ScopedResource;
 class StreamVideoDrawQuad;
 class TextureDrawQuad;
 class GeometryBinding;
 class ScopedEnsureFramebufferAllocation;
 
 // Class that handles drawing of composited render layers using GL.
 class CC_EXPORT GLRenderer :
     public DirectRenderer,
     public NON_EXPORTED_BASE(
@@ skipping 94 matching lines @@
                           const SolidColorDrawQuad* quad);
   void DrawStreamVideoQuad(const DrawingFrame& frame,
                            const StreamVideoDrawQuad* quad);
   void DrawTextureQuad(const DrawingFrame& frame, const TextureDrawQuad* quad);
   void EnqueueTextureQuad(const DrawingFrame& frame,
                           const TextureDrawQuad* quad);
   void FlushTextureQuadCache();
   void DrawIOSurfaceQuad(const DrawingFrame& frame,
                          const IOSurfaceDrawQuad* quad);
   void DrawTileQuad(const DrawingFrame& frame, const TileDrawQuad* quad);
+  void DrawContentQuad(const DrawingFrame& frame,
+                       const ContentDrawQuadBase* quad,
+                       ResourceProvider::ResourceId resource_id);
   void DrawYUVVideoQuad(const DrawingFrame& frame,
                         const YUVVideoDrawQuad* quad);
+  void DrawPictureQuad(const DrawingFrame& frame,
+                       const PictureDrawQuad* quad);
 
   void SetShaderOpacity(float opacity, int alpha_location);
   void SetShaderQuadF(const gfx::QuadF& quad, int quad_location);
   void DrawQuadGeometry(const DrawingFrame& frame,
                         const gfx::Transform& draw_transform,
                         const gfx::RectF& quad_rect,
                         int matrix_location);
   void SetBlendEnabled(bool enabled);
   void SetUseProgram(unsigned program);
 
@@ skipping 160 matching lines @@
   bool visible_;
   bool is_scissor_enabled_;
   bool blend_shadow_;
   unsigned program_shadow_;
   TexturedQuadDrawCache draw_cache_;
 
   scoped_ptr<ResourceProvider::ScopedWriteLockGL> current_framebuffer_lock_;
 
   scoped_refptr<ResourceProvider::Fence> last_swap_fence_;
 
+  SkBitmap on_demand_tile_raster_bitmap_;
+  ResourceProvider::ResourceId on_demand_tile_raster_resource_id_;
+
   DISALLOW_COPY_AND_ASSIGN(GLRenderer);
 };
 
 // Setting DEBUG_GL_CALLS to 1 will call glGetError() after almost every GL
 // call made by the compositor. Useful for debugging rendering issues but
 // will significantly degrade performance.
 #define DEBUG_GL_CALLS 0
 
 #if DEBUG_GL_CALLS && !defined(NDEBUG)
 #define GLC(context, x)                                                        \
   (x, GLRenderer::DebugGLCall (&* context, #x, __FILE__, __LINE__))
 #else
 #define GLC(context, x) (x)
 #endif
 
 }
 
 #endif  // CC_OUTPUT_GL_RENDERER_H_