cc/output/gl_renderer.h

   1 // Copyright 2010 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CC_OUTPUT_GL_RENDERER_H_
   6 #define CC_OUTPUT_GL_RENDERER_H_
   7
   8 #include "base/cancelable_callback.h"
   9 #include "cc/base/cc_export.h"
  10 #include "cc/base/scoped_ptr_deque.h"
  11 #include "cc/base/scoped_ptr_vector.h"
  12 #include "cc/output/direct_renderer.h"
  13 #include "cc/output/gl_renderer_draw_cache.h"
  14 #include "cc/output/program_binding.h"
  15 #include "cc/output/renderer.h"
  16 #include "cc/quads/debug_border_draw_quad.h"
  17 #include "cc/quads/io_surface_draw_quad.h"
  18 #include "cc/quads/render_pass_draw_quad.h"
  19 #include "cc/quads/solid_color_draw_quad.h"
  20 #include "cc/quads/tile_draw_quad.h"
  21 #include "cc/quads/yuv_video_draw_quad.h"
  22 #include "ui/gfx/geometry/quad_f.h"
  23
  24 class SkBitmap;
  25
  26 namespace gpu {
  27 namespace gles2 {
  28 class GLES2Interface;
  29 }
  30 }
  31
  32 namespace cc {
  33
  34 class GLRendererShaderTest;
  35 class OutputSurface;
  36 class PictureDrawQuad;
  37 class ScopedResource;
  38 class StreamVideoDrawQuad;
  39 class TextureDrawQuad;
  40 class TextureMailboxDeleter;
  41 class StaticGeometryBinding;
  42 class DynamicGeometryBinding;
  43 class ScopedEnsureFramebufferAllocation;
  44
  45 // Class that handles drawing of composited render layers using GL.
  46 class CC_EXPORT GLRenderer : public DirectRenderer {
  47  public:
  48   class ScopedUseGrContext;
  49
  50   static scoped_ptr<GLRenderer> Create(
  51       RendererClient* client,
  52       const RendererSettings* settings,
  53       OutputSurface* output_surface,
  54       ResourceProvider* resource_provider,
  55       TextureMailboxDeleter* texture_mailbox_deleter,
  56       int highp_threshold_min);
  57
  58   ~GLRenderer() override;
  59
  60   const RendererCapabilitiesImpl& Capabilities() const override;
  61
  62   // Waits for rendering to finish.
  63   void Finish() override;
  64
  65   void DoNoOp() override;
  66   void SwapBuffers(const CompositorFrameMetadata& metadata) override;
  67
  68   virtual bool IsContextLost();
  69
  70  protected:
  71   GLRenderer(RendererClient* client,
  72              const RendererSettings* settings,
  73              OutputSurface* output_surface,
  74              ResourceProvider* resource_provider,
  75              TextureMailboxDeleter* texture_mailbox_deleter,
  76              int highp_threshold_min);
  77
  78   void DidChangeVisibility() override;
  79
  80   bool IsBackbufferDiscarded() const { return is_backbuffer_discarded_; }
  81
  82   const gfx::QuadF& SharedGeometryQuad() const { return shared_geometry_quad_; }
  83   const StaticGeometryBinding* SharedGeometry() const {
  84     return shared_geometry_.get();
  85   }
  86
  87   void GetFramebufferPixelsAsync(const DrawingFrame* frame,
  88                                  const gfx::Rect& rect,
  89                                  scoped_ptr<CopyOutputRequest> request);
  90   void GetFramebufferTexture(unsigned texture_id,
  91                              ResourceFormat texture_format,
  92                              const gfx::Rect& device_rect);
  93   void ReleaseRenderPassTextures();
  94   enum BoundGeometry { NO_BINDING, SHARED_BINDING, CLIPPED_BINDING };
  95   void PrepareGeometry(BoundGeometry geometry_to_bind);
  96   void SetStencilEnabled(bool enabled);
  97   bool stencil_enabled() const { return stencil_shadow_; }
  98   void SetBlendEnabled(bool enabled);
  99   bool blend_enabled() const { return blend_shadow_; }
 100
 101   void BindFramebufferToOutputSurface(DrawingFrame* frame) override;
 102   bool BindFramebufferToTexture(DrawingFrame* frame,
 103                                 const ScopedResource* resource,
 104                                 const gfx::Rect& target_rect) override;
 105   void SetScissorTestRect(const gfx::Rect& scissor_rect) override;
 106   void PrepareSurfaceForPass(DrawingFrame* frame,
 107                              SurfaceInitializationMode initialization_mode,
 108                              const gfx::Rect& render_pass_scissor) override;
 109   void DoDrawQuad(DrawingFrame* frame,
 110                   const class DrawQuad*,
 111                   const gfx::QuadF* draw_region) override;
 112   void BeginDrawingFrame(DrawingFrame* frame) override;
 113   void FinishDrawingFrame(DrawingFrame* frame) override;
 114   bool FlippedFramebuffer(const DrawingFrame* frame) const override;
 115   bool FlippedRootFramebuffer() const;
 116   void EnsureScissorTestEnabled() override;
 117   void EnsureScissorTestDisabled() override;
 118   void CopyCurrentRenderPassToBitmap(
 119       DrawingFrame* frame,
 120       scoped_ptr<CopyOutputRequest> request) override;
 121   void FinishDrawingQuadList() override;
 122
 123   // Returns true if quad requires antialiasing and false otherwise.
 124   static bool ShouldAntialiasQuad(const gfx::QuadF& device_layer_quad,
 125                                   bool clipped,
 126                                   bool force_aa);
 127
 128   // Inflate the quad and fill edge array for fragment shader.
 129   // |local_quad| is set to inflated quad. |edge| array is filled with
 130   // inflated quad's edge data.
 131   static void SetupQuadForClippingAndAntialiasing(
 132       const gfx::Transform& device_transform,
 133       const DrawQuad* quad,
 134       const gfx::QuadF* device_layer_quad,
 135       const gfx::QuadF* clip_region,
 136       gfx::QuadF* local_quad,
 137       float edge[24]);
 138   static void SetupRenderPassQuadForClippingAndAntialiasing(
 139       const gfx::Transform& device_transform,
 140       const RenderPassDrawQuad* quad,
 141       const gfx::QuadF* device_layer_quad,
 142       const gfx::QuadF* clip_region,
 143       gfx::QuadF* local_quad,
 144       float edge[24]);
 145
 146  private:
 147   friend class GLRendererShaderPixelTest;
 148   friend class GLRendererShaderTest;
 149
 150   static void ToGLMatrix(float* gl_matrix, const gfx::Transform& transform);
 151
 152   void DiscardPixels();
 153   void ClearFramebuffer(DrawingFrame* frame);
 154   void SetViewport();
 155
 156   void DrawDebugBorderQuad(const DrawingFrame* frame,
 157                            const DebugBorderDrawQuad* quad);
 158   static bool IsDefaultBlendMode(SkXfermode::Mode blend_mode) {
 159     return blend_mode == SkXfermode::kSrcOver_Mode;
 160   }
 161   bool CanApplyBlendModeUsingBlendFunc(SkXfermode::Mode blend_mode);
 162   void ApplyBlendModeUsingBlendFunc(SkXfermode::Mode blend_mode);
 163   void RestoreBlendFuncToDefault(SkXfermode::Mode blend_mode);
 164
 165   gfx::Rect GetBackdropBoundingBoxForRenderPassQuad(
 166       DrawingFrame* frame,
 167       const RenderPassDrawQuad* quad,
 168       const gfx::Transform& contents_device_transform,
 169       const gfx::QuadF* clip_region,
 170       bool use_aa);
 171   scoped_ptr<ScopedResource> GetBackdropTexture(const gfx::Rect& bounding_rect);
 172
 173   static bool ShouldApplyBackgroundFilters(DrawingFrame* frame,
 174                                            const RenderPassDrawQuad* quad);
 175   skia::RefPtr<SkImage> ApplyBackgroundFilters(
 176       DrawingFrame* frame,
 177       const RenderPassDrawQuad* quad,
 178       ScopedResource* background_texture);
 179
 180   void DrawRenderPassQuad(DrawingFrame* frame,
 181                           const RenderPassDrawQuad* quadi,
 182                           const gfx::QuadF* clip_region);
 183   void DrawSolidColorQuad(const DrawingFrame* frame,
 184                           const SolidColorDrawQuad* quad,
 185                           const gfx::QuadF* clip_region);
 186   void DrawStreamVideoQuad(const DrawingFrame* frame,
 187                            const StreamVideoDrawQuad* quad,
 188                            const gfx::QuadF* clip_region);
 189   void DrawTextureQuad(const DrawingFrame* frame,
 190                        const TextureDrawQuad* quad,
 191                        const gfx::QuadF* clip_region);
 192   void EnqueueTextureQuad(const DrawingFrame* frame,
 193                           const TextureDrawQuad* quad,
 194                           const gfx::QuadF* clip_region);
 195   void FlushTextureQuadCache(BoundGeometry flush_binding);
 196   void DrawIOSurfaceQuad(const DrawingFrame* frame,
 197                          const IOSurfaceDrawQuad* quad,
 198                          const gfx::QuadF* clip_region);
 199   void DrawTileQuad(const DrawingFrame* frame,
 200                     const TileDrawQuad* quad,
 201                     const gfx::QuadF* clip_region);
 202   void DrawContentQuad(const DrawingFrame* frame,
 203                        const ContentDrawQuadBase* quad,
 204                        ResourceId resource_id,
 205                        const gfx::QuadF* clip_region);
 206   void DrawContentQuadAA(const DrawingFrame* frame,
 207                          const ContentDrawQuadBase* quad,
 208                          ResourceId resource_id,
 209                          const gfx::Transform& device_transform,
 210                          const gfx::QuadF& aa_quad,
 211                          const gfx::QuadF* clip_region);
 212   void DrawContentQuadNoAA(const DrawingFrame* frame,
 213                            const ContentDrawQuadBase* quad,
 214                            ResourceId resource_id,
 215                            const gfx::QuadF* clip_region);
 216   void DrawYUVVideoQuad(const DrawingFrame* frame,
 217                         const YUVVideoDrawQuad* quad,
 218                         const gfx::QuadF* clip_region);
 219   void DrawPictureQuad(const DrawingFrame* frame,
 220                        const PictureDrawQuad* quad,
 221                        const gfx::QuadF* clip_region);
 222
 223   void SetShaderOpacity(float opacity, int alpha_location);
 224   void SetShaderQuadF(const gfx::QuadF& quad, int quad_location);
 225   void DrawQuadGeometryClippedByQuadF(const DrawingFrame* frame,
 226                                       const gfx::Transform& draw_transform,
 227                                       const gfx::RectF& quad_rect,
 228                                       const gfx::QuadF& clipping_region_quad,
 229                                       int matrix_location,
 230                                       const float uv[8]);
 231   void DrawQuadGeometry(const DrawingFrame* frame,
 232                         const gfx::Transform& draw_transform,
 233                         const gfx::RectF& quad_rect,
 234                         int matrix_location);
 235   void SetUseProgram(unsigned program);
 236
 237   bool UseScopedTexture(DrawingFrame* frame,
 238                         const ScopedResource* resource,
 239                         const gfx::Rect& viewport_rect);
 240
 241   bool MakeContextCurrent();
 242
 243   void InitializeSharedObjects();
 244   void CleanupSharedObjects();
 245
 246   typedef base::Callback<void(scoped_ptr<CopyOutputRequest> copy_request,
 247                               bool success)>
 248       AsyncGetFramebufferPixelsCleanupCallback;
 249   void FinishedReadback(unsigned source_buffer,
 250                         unsigned query,
 251                         const gfx::Size& size);
 252
 253   void ReinitializeGLState();
 254   void RestoreGLState();
 255   void RestoreFramebuffer(DrawingFrame* frame);
 256
 257   void DiscardBackbuffer() override;
 258   void EnsureBackbuffer() override;
 259   void EnforceMemoryPolicy();
 260
 261   void ScheduleOverlays(DrawingFrame* frame);
 262
 263   typedef ScopedPtrVector<ResourceProvider::ScopedReadLockGL>
 264       OverlayResourceLockList;
 265   OverlayResourceLockList pending_overlay_resources_;
 266   OverlayResourceLockList in_use_overlay_resources_;
 267
 268   RendererCapabilitiesImpl capabilities_;
 269
 270   unsigned offscreen_framebuffer_id_;
 271
 272   scoped_ptr<StaticGeometryBinding> shared_geometry_;
 273   scoped_ptr<DynamicGeometryBinding> clipped_geometry_;
 274   gfx::QuadF shared_geometry_quad_;
 275
 276   // This block of bindings defines all of the programs used by the compositor
 277   // itself.  Add any new programs here to GLRendererShaderTest.
 278
 279   // Tiled layer shaders.
 280   typedef ProgramBinding<VertexShaderTile, FragmentShaderRGBATexAlpha>
 281       TileProgram;
 282   typedef ProgramBinding<VertexShaderTileAA, FragmentShaderRGBATexClampAlphaAA>
 283       TileProgramAA;
 284   typedef ProgramBinding<VertexShaderTileAA,
 285                          FragmentShaderRGBATexClampSwizzleAlphaAA>
 286       TileProgramSwizzleAA;
 287   typedef ProgramBinding<VertexShaderTile, FragmentShaderRGBATexOpaque>
 288       TileProgramOpaque;
 289   typedef ProgramBinding<VertexShaderTile, FragmentShaderRGBATexSwizzleAlpha>
 290       TileProgramSwizzle;
 291   typedef ProgramBinding<VertexShaderTile, FragmentShaderRGBATexSwizzleOpaque>
 292       TileProgramSwizzleOpaque;
 293
 294   // Texture shaders.
 295   typedef ProgramBinding<VertexShaderPosTexTransform,
 296                          FragmentShaderRGBATexVaryingAlpha> TextureProgram;
 297   typedef ProgramBinding<VertexShaderPosTexTransform,
 298                          FragmentShaderRGBATexPremultiplyAlpha>
 299       NonPremultipliedTextureProgram;
 300   typedef ProgramBinding<VertexShaderPosTexTransform,
 301                          FragmentShaderTexBackgroundVaryingAlpha>
 302       TextureBackgroundProgram;
 303   typedef ProgramBinding<VertexShaderPosTexTransform,
 304                          FragmentShaderTexBackgroundPremultiplyAlpha>
 305       NonPremultipliedTextureBackgroundProgram;
 306
 307   // Render surface shaders.
 308   typedef ProgramBinding<VertexShaderPosTexTransform,
 309                          FragmentShaderRGBATexAlpha> RenderPassProgram;
 310   typedef ProgramBinding<VertexShaderPosTexTransform,
 311                          FragmentShaderRGBATexAlphaMask> RenderPassMaskProgram;
 312   typedef ProgramBinding<VertexShaderQuadTexTransformAA,
 313                          FragmentShaderRGBATexAlphaAA> RenderPassProgramAA;
 314   typedef ProgramBinding<VertexShaderQuadTexTransformAA,
 315                          FragmentShaderRGBATexAlphaMaskAA>
 316       RenderPassMaskProgramAA;
 317   typedef ProgramBinding<VertexShaderPosTexTransform,
 318                          FragmentShaderRGBATexColorMatrixAlpha>
 319       RenderPassColorMatrixProgram;
 320   typedef ProgramBinding<VertexShaderQuadTexTransformAA,
 321                          FragmentShaderRGBATexAlphaMaskColorMatrixAA>
 322       RenderPassMaskColorMatrixProgramAA;
 323   typedef ProgramBinding<VertexShaderQuadTexTransformAA,
 324                          FragmentShaderRGBATexAlphaColorMatrixAA>
 325       RenderPassColorMatrixProgramAA;
 326   typedef ProgramBinding<VertexShaderPosTexTransform,
 327                          FragmentShaderRGBATexAlphaMaskColorMatrix>
 328       RenderPassMaskColorMatrixProgram;
 329
 330   // Video shaders.
 331   typedef ProgramBinding<VertexShaderVideoTransform, FragmentShaderRGBATex>
 332       VideoStreamTextureProgram;
 333   typedef ProgramBinding<VertexShaderPosTexYUVStretchOffset,
 334                          FragmentShaderYUVVideo> VideoYUVProgram;
 335   typedef ProgramBinding<VertexShaderPosTexYUVStretchOffset,
 336                          FragmentShaderYUVAVideo> VideoYUVAProgram;
 337
 338   // Special purpose / effects shaders.
 339   typedef ProgramBinding<VertexShaderPos, FragmentShaderColor>
 340       DebugBorderProgram;
 341   typedef ProgramBinding<VertexShaderQuad, FragmentShaderColor>
 342       SolidColorProgram;
 343   typedef ProgramBinding<VertexShaderQuadAA, FragmentShaderColorAA>
 344       SolidColorProgramAA;
 345
 346   const TileProgram* GetTileProgram(
 347       TexCoordPrecision precision, SamplerType sampler);
 348   const TileProgramOpaque* GetTileProgramOpaque(
 349       TexCoordPrecision precision, SamplerType sampler);
 350   const TileProgramAA* GetTileProgramAA(
 351       TexCoordPrecision precision, SamplerType sampler);
 352   const TileProgramSwizzle* GetTileProgramSwizzle(
 353       TexCoordPrecision precision, SamplerType sampler);
 354   const TileProgramSwizzleOpaque* GetTileProgramSwizzleOpaque(
 355       TexCoordPrecision precision, SamplerType sampler);
 356   const TileProgramSwizzleAA* GetTileProgramSwizzleAA(
 357       TexCoordPrecision precision, SamplerType sampler);
 358
 359   const RenderPassProgram* GetRenderPassProgram(TexCoordPrecision precision,
 360                                                 BlendMode blend_mode);
 361   const RenderPassProgramAA* GetRenderPassProgramAA(TexCoordPrecision precision,
 362                                                     BlendMode blend_mode);
 363   const RenderPassMaskProgram* GetRenderPassMaskProgram(
 364       TexCoordPrecision precision,
 365       SamplerType sampler,
 366       BlendMode blend_mode,
 367       bool mask_for_background);
 368   const RenderPassMaskProgramAA* GetRenderPassMaskProgramAA(
 369       TexCoordPrecision precision,
 370       SamplerType sampler,
 371       BlendMode blend_mode,
 372       bool mask_for_background);
 373   const RenderPassColorMatrixProgram* GetRenderPassColorMatrixProgram(
 374       TexCoordPrecision precision,
 375       BlendMode blend_mode);
 376   const RenderPassColorMatrixProgramAA* GetRenderPassColorMatrixProgramAA(
 377       TexCoordPrecision precision,
 378       BlendMode blend_mode);
 379   const RenderPassMaskColorMatrixProgram* GetRenderPassMaskColorMatrixProgram(
 380       TexCoordPrecision precision,
 381       SamplerType sampler,
 382       BlendMode blend_mode,
 383       bool mask_for_background);
 384   const RenderPassMaskColorMatrixProgramAA*
 385   GetRenderPassMaskColorMatrixProgramAA(TexCoordPrecision precision,
 386                                         SamplerType sampler,
 387                                         BlendMode blend_mode,
 388                                         bool mask_for_background);
 389
 390   const TextureProgram* GetTextureProgram(TexCoordPrecision precision,
 391                                           SamplerType sampler);
 392   const NonPremultipliedTextureProgram* GetNonPremultipliedTextureProgram(
 393       TexCoordPrecision precision,
 394       SamplerType sampler);
 395   const TextureBackgroundProgram* GetTextureBackgroundProgram(
 396       TexCoordPrecision precision,
 397       SamplerType sampler);
 398   const NonPremultipliedTextureBackgroundProgram*
 399   GetNonPremultipliedTextureBackgroundProgram(TexCoordPrecision precision,
 400                                               SamplerType sampler);
 401   const TextureProgram* GetTextureIOSurfaceProgram(
 402       TexCoordPrecision precision);
 403
 404   const VideoYUVProgram* GetVideoYUVProgram(TexCoordPrecision precision,
 405                                             SamplerType sampler);
 406   const VideoYUVAProgram* GetVideoYUVAProgram(TexCoordPrecision precision,
 407                                               SamplerType sampler);
 408   const VideoStreamTextureProgram* GetVideoStreamTextureProgram(
 409       TexCoordPrecision precision);
 410
 411   const DebugBorderProgram* GetDebugBorderProgram();
 412   const SolidColorProgram* GetSolidColorProgram();
 413   const SolidColorProgramAA* GetSolidColorProgramAA();
 414
 415   TileProgram
 416       tile_program_[LAST_TEX_COORD_PRECISION + 1][LAST_SAMPLER_TYPE + 1];
 417   TileProgramOpaque
 418       tile_program_opaque_[LAST_TEX_COORD_PRECISION + 1][LAST_SAMPLER_TYPE + 1];
 419   TileProgramAA
 420       tile_program_aa_[LAST_TEX_COORD_PRECISION + 1][LAST_SAMPLER_TYPE + 1];
 421   TileProgramSwizzle tile_program_swizzle_[LAST_TEX_COORD_PRECISION +
 422                                            1][LAST_SAMPLER_TYPE + 1];
 423   TileProgramSwizzleOpaque
 424       tile_program_swizzle_opaque_[LAST_TEX_COORD_PRECISION +
 425                                    1][LAST_SAMPLER_TYPE + 1];
 426   TileProgramSwizzleAA tile_program_swizzle_aa_[LAST_TEX_COORD_PRECISION +
 427                                                 1][LAST_SAMPLER_TYPE + 1];
 428
 429   TextureProgram
 430       texture_program_[LAST_TEX_COORD_PRECISION + 1][LAST_SAMPLER_TYPE + 1];
 431   NonPremultipliedTextureProgram
 432       nonpremultiplied_texture_program_[LAST_TEX_COORD_PRECISION +
 433                                         1][LAST_SAMPLER_TYPE + 1];
 434   TextureBackgroundProgram
 435       texture_background_program_[LAST_TEX_COORD_PRECISION +
 436                                   1][LAST_SAMPLER_TYPE + 1];
 437   NonPremultipliedTextureBackgroundProgram
 438       nonpremultiplied_texture_background_program_[LAST_TEX_COORD_PRECISION +
 439                                                    1][LAST_SAMPLER_TYPE + 1];
 440   TextureProgram texture_io_surface_program_[LAST_TEX_COORD_PRECISION + 1];
 441
 442   RenderPassProgram
 443       render_pass_program_[LAST_TEX_COORD_PRECISION + 1][LAST_BLEND_MODE + 1];
 444   RenderPassProgramAA render_pass_program_aa_[LAST_TEX_COORD_PRECISION +
 445                                               1][LAST_BLEND_MODE + 1];
 446   RenderPassMaskProgram
 447       render_pass_mask_program_[LAST_TEX_COORD_PRECISION + 1]
 448                                [LAST_SAMPLER_TYPE + 1]
 449                                [LAST_BLEND_MODE + 1]
 450                                [LAST_MASK_VALUE + 1];
 451   RenderPassMaskProgramAA
 452       render_pass_mask_program_aa_[LAST_TEX_COORD_PRECISION + 1]
 453                                   [LAST_SAMPLER_TYPE + 1]
 454                                   [LAST_BLEND_MODE + 1]
 455                                   [LAST_MASK_VALUE + 1];
 456   RenderPassColorMatrixProgram
 457       render_pass_color_matrix_program_[LAST_TEX_COORD_PRECISION +
 458                                         1][LAST_BLEND_MODE + 1];
 459   RenderPassColorMatrixProgramAA
 460       render_pass_color_matrix_program_aa_[LAST_TEX_COORD_PRECISION +
 461                                            1][LAST_BLEND_MODE + 1];
 462   RenderPassMaskColorMatrixProgram
 463       render_pass_mask_color_matrix_program_[LAST_TEX_COORD_PRECISION + 1]
 464                                             [LAST_SAMPLER_TYPE + 1]
 465                                             [LAST_BLEND_MODE + 1]
 466                                             [LAST_MASK_VALUE + 1];
 467   RenderPassMaskColorMatrixProgramAA
 468       render_pass_mask_color_matrix_program_aa_[LAST_TEX_COORD_PRECISION + 1]
 469                                                [LAST_SAMPLER_TYPE + 1]
 470                                                [LAST_BLEND_MODE + 1]
 471                                                [LAST_MASK_VALUE + 1];
 472
 473   VideoYUVProgram
 474       video_yuv_program_[LAST_TEX_COORD_PRECISION + 1][LAST_SAMPLER_TYPE + 1];
 475   VideoYUVAProgram
 476       video_yuva_program_[LAST_TEX_COORD_PRECISION + 1][LAST_SAMPLER_TYPE + 1];
 477   VideoStreamTextureProgram
 478       video_stream_texture_program_[LAST_TEX_COORD_PRECISION + 1];
 479
 480   DebugBorderProgram debug_border_program_;
 481   SolidColorProgram solid_color_program_;
 482   SolidColorProgramAA solid_color_program_aa_;
 483
 484   gpu::gles2::GLES2Interface* gl_;
 485   gpu::ContextSupport* context_support_;
 486
 487   TextureMailboxDeleter* texture_mailbox_deleter_;
 488
 489   gfx::Rect swap_buffer_rect_;
 490   gfx::Rect scissor_rect_;
 491   bool is_backbuffer_discarded_;
 492   bool is_using_bind_uniform_;
 493   bool is_scissor_enabled_;
 494   bool scissor_rect_needs_reset_;
 495   bool stencil_shadow_;
 496   bool blend_shadow_;
 497   unsigned program_shadow_;
 498   TexturedQuadDrawCache draw_cache_;
 499   int highp_threshold_min_;
 500   int highp_threshold_cache_;
 501
 502   struct PendingAsyncReadPixels;
 503   ScopedPtrVector<PendingAsyncReadPixels> pending_async_read_pixels_;
 504
 505   scoped_ptr<ResourceProvider::ScopedWriteLockGL> current_framebuffer_lock_;
 506
 507   class SyncQuery;
 508   ScopedPtrDeque<SyncQuery> pending_sync_queries_;
 509   ScopedPtrDeque<SyncQuery> available_sync_queries_;
 510   scoped_ptr<SyncQuery> current_sync_query_;
 511   bool use_sync_query_;
 512   bool use_blend_equation_advanced_;
 513   bool use_blend_equation_advanced_coherent_;
 514
 515   SkBitmap on_demand_tile_raster_bitmap_;
 516   ResourceId on_demand_tile_raster_resource_id_;
 517   BoundGeometry bound_geometry_;
 518   DISALLOW_COPY_AND_ASSIGN(GLRenderer);
 519 };
 520
 521 }  // namespace cc
 522
 523 #endif  // CC_OUTPUT_GL_RENDERER_H_