Revert of Splitting of layers for correct intersections

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 "base/cancelable_callback.h"
 #include "cc/base/cc_export.h"
 #include "cc/base/scoped_ptr_deque.h"
@@ skipping 21 matching lines @@
 
 namespace cc {
 
 class GLRendererShaderTest;
 class OutputSurface;
 class PictureDrawQuad;
 class ScopedResource;
 class StreamVideoDrawQuad;
 class TextureDrawQuad;
 class TextureMailboxDeleter;
-class StaticGeometryBinding;
-class DynamicGeometryBinding;
+class GeometryBinding;
 class ScopedEnsureFramebufferAllocation;
 
 // Class that handles drawing of composited render layers using GL.
 class CC_EXPORT GLRenderer : public DirectRenderer {
  public:
   class ScopedUseGrContext;
 
   static scoped_ptr<GLRenderer> Create(
       RendererClient* client,
       const RendererSettings* settings,
@@ skipping 25 matching lines @@
              OutputSurface* output_surface,
              ResourceProvider* resource_provider,
              TextureMailboxDeleter* texture_mailbox_deleter,
              int highp_threshold_min);
 
   void DidChangeVisibility() override;
 
   bool IsBackbufferDiscarded() const { return is_backbuffer_discarded_; }
 
   const gfx::QuadF& SharedGeometryQuad() const { return shared_geometry_quad_; }
-  const StaticGeometryBinding* SharedGeometry() const {
+  const GeometryBinding* SharedGeometry() const {
     return shared_geometry_.get();
   }
 
   void GetFramebufferPixelsAsync(const DrawingFrame* frame,
                                  const gfx::Rect& rect,
                                  scoped_ptr<CopyOutputRequest> request);
   void GetFramebufferTexture(unsigned texture_id,
                              ResourceFormat texture_format,
                              const gfx::Rect& device_rect);
   void ReleaseRenderPassTextures();
-  enum BoundGeometry { NO_BINDING, SHARED_BINDING, CLIPPED_BINDING };
-  void PrepareGeometry(BoundGeometry geometry_to_bind);
+
   void SetStencilEnabled(bool enabled);
   bool stencil_enabled() const { return stencil_shadow_; }
   void SetBlendEnabled(bool enabled);
   bool blend_enabled() const { return blend_shadow_; }
 
   void BindFramebufferToOutputSurface(DrawingFrame* frame) override;
   bool BindFramebufferToTexture(DrawingFrame* frame,
                                 const ScopedResource* resource,
                                 const gfx::Rect& target_rect) override;
   void SetDrawViewport(const gfx::Rect& window_space_viewport) override;
   void SetScissorTestRect(const gfx::Rect& scissor_rect) override;
   void DiscardPixels(bool has_external_stencil_test,
                      bool draw_rect_covers_full_surface) override;
   void ClearFramebuffer(DrawingFrame* frame,
                         bool has_external_stencil_test) override;
-  void DoDrawQuad(DrawingFrame* frame,
-                  const class DrawQuad*,
-                  const gfx::QuadF* draw_region) override;
+  void DoDrawQuad(DrawingFrame* frame, const class DrawQuad*) override;
   void BeginDrawingFrame(DrawingFrame* frame) override;
   void FinishDrawingFrame(DrawingFrame* frame) override;
   bool FlippedFramebuffer(const DrawingFrame* frame) const override;
   bool FlippedRootFramebuffer() const;
   void EnsureScissorTestEnabled() override;
   void EnsureScissorTestDisabled() override;
   void CopyCurrentRenderPassToBitmap(
       DrawingFrame* frame,
       scoped_ptr<CopyOutputRequest> request) override;
   void FinishDrawingQuadList() override;
 
   // Returns true if quad requires antialiasing and false otherwise.
   static bool ShouldAntialiasQuad(const gfx::Transform& device_transform,
                                   const DrawQuad* quad,
                                   bool force_antialiasing);
 
   // Inflate the quad and fill edge array for fragment shader.
   // |local_quad| is set to inflated quad. |edge| array is filled with
   // inflated quad's edge data.
-  static void SetupQuadForClippingAndAntialiasing(
-      const gfx::Transform& device_transform,
-      const DrawQuad* quad,
-      bool use_aa,
-      const gfx::QuadF* clip_region,
-      gfx::QuadF* local_quad,
-      float edge[24]);
+  static void SetupQuadForAntialiasing(const gfx::Transform& device_transform,
+                                       const DrawQuad* quad,
+                                       gfx::QuadF* local_quad,
+                                       float edge[24]);
 
  private:
   friend class GLRendererShaderPixelTest;
   friend class GLRendererShaderTest;
 
   static void ToGLMatrix(float* gl_matrix, const gfx::Transform& transform);
 
   void DrawCheckerboardQuad(const DrawingFrame* frame,
-                            const CheckerboardDrawQuad* quad,
-                            const gfx::QuadF* clip_region);
+                            const CheckerboardDrawQuad* quad);
   void DrawDebugBorderQuad(const DrawingFrame* frame,
                            const DebugBorderDrawQuad* quad);
   static bool IsDefaultBlendMode(SkXfermode::Mode blend_mode) {
     return blend_mode == SkXfermode::kSrcOver_Mode;
   }
   bool CanApplyBlendModeUsingBlendFunc(SkXfermode::Mode blend_mode);
   void ApplyBlendModeUsingBlendFunc(SkXfermode::Mode blend_mode);
   void RestoreBlendFuncToDefault(SkXfermode::Mode blend_mode);
 
   gfx::Rect GetBackdropBoundingBoxForRenderPassQuad(
       DrawingFrame* frame,
       const RenderPassDrawQuad* quad,
       const gfx::Transform& contents_device_transform,
-      const gfx::QuadF* clip_region,
       bool use_aa);
   scoped_ptr<ScopedResource> GetBackdropTexture(const gfx::Rect& bounding_rect);
 
   static bool ShouldApplyBackgroundFilters(DrawingFrame* frame,
                                            const RenderPassDrawQuad* quad);
   skia::RefPtr<SkImage> ApplyBackgroundFilters(
       DrawingFrame* frame,
       const RenderPassDrawQuad* quad,
       ScopedResource* background_texture);
 
-  void DrawRenderPassQuad(DrawingFrame* frame,
-                          const RenderPassDrawQuad* quadi,
-                          const gfx::QuadF* clip_region);
+  void DrawRenderPassQuad(DrawingFrame* frame, const RenderPassDrawQuad* quad);
   void DrawSolidColorQuad(const DrawingFrame* frame,
-                          const SolidColorDrawQuad* quad,
-                          const gfx::QuadF* clip_region);
+                          const SolidColorDrawQuad* quad);
   void DrawStreamVideoQuad(const DrawingFrame* frame,
-                           const StreamVideoDrawQuad* quad,
-                           const gfx::QuadF* clip_region);
-  void DrawTextureQuad(const DrawingFrame* frame,
-                       const TextureDrawQuad* quad,
-                       const gfx::QuadF* clip_region);
+                           const StreamVideoDrawQuad* quad);
   void EnqueueTextureQuad(const DrawingFrame* frame,
-                          const TextureDrawQuad* quad,
-                          const gfx::QuadF* clip_region);
-  void FlushTextureQuadCache(BoundGeometry flush_binding);
+                          const TextureDrawQuad* quad);
+  void FlushTextureQuadCache();
   void DrawIOSurfaceQuad(const DrawingFrame* frame,
-                         const IOSurfaceDrawQuad* quad,
-                         const gfx::QuadF* clip_region);
-  void DrawTileQuad(const DrawingFrame* frame,
-                    const TileDrawQuad* quad,
-                    const gfx::QuadF* clip_region);
+                         const IOSurfaceDrawQuad* quad);
+  void DrawTileQuad(const DrawingFrame* frame, const TileDrawQuad* quad);
   void DrawContentQuad(const DrawingFrame* frame,
                        const ContentDrawQuadBase* quad,
-                       ResourceProvider::ResourceId resource_id,
-                       const gfx::QuadF* clip_region);
+                       ResourceProvider::ResourceId resource_id);
   void DrawContentQuadAA(const DrawingFrame* frame,
                          const ContentDrawQuadBase* quad,
                          ResourceProvider::ResourceId resource_id,
-                         const gfx::Transform& device_transform,
-                         const gfx::QuadF* clip_region);
+                         const gfx::Transform& device_transform);
   void DrawContentQuadNoAA(const DrawingFrame* frame,
                            const ContentDrawQuadBase* quad,
-                           ResourceProvider::ResourceId resource_id,
-                           const gfx::QuadF* clip_region);
+                           ResourceProvider::ResourceId resource_id);
   void DrawYUVVideoQuad(const DrawingFrame* frame,
-                        const YUVVideoDrawQuad* quad,
-                        const gfx::QuadF* clip_region);
+                        const YUVVideoDrawQuad* quad);
   void DrawPictureQuad(const DrawingFrame* frame,
-                       const PictureDrawQuad* quad,
-                       const gfx::QuadF* clip_region);
+                       const PictureDrawQuad* quad);
 
   void SetShaderOpacity(float opacity, int alpha_location);
   void SetShaderQuadF(const gfx::QuadF& quad, int quad_location);
-  void DrawQuadGeometryClippedByQuadF(const DrawingFrame* frame,
-                                      const gfx::Transform& draw_transform,
-                                      const gfx::RectF& quad_rect,
-                                      const gfx::QuadF& clipping_region_quad,
-                                      int matrix_location,
-                                      const float uv[8]);
   void DrawQuadGeometry(const DrawingFrame* frame,
                         const gfx::Transform& draw_transform,
                         const gfx::RectF& quad_rect,
                         int matrix_location);
   void SetUseProgram(unsigned program);
 
   bool UseScopedTexture(DrawingFrame* frame,
                         const ScopedResource* resource,
                         const gfx::Rect& viewport_rect);
 
@@ skipping 21 matching lines @@
 
   typedef ScopedPtrVector<ResourceProvider::ScopedReadLockGL>
       OverlayResourceLockList;
   OverlayResourceLockList pending_overlay_resources_;
   OverlayResourceLockList in_use_overlay_resources_;
 
   RendererCapabilitiesImpl capabilities_;
 
   unsigned offscreen_framebuffer_id_;
 
-  scoped_ptr<StaticGeometryBinding> shared_geometry_;
-  scoped_ptr<DynamicGeometryBinding> clipped_geometry_;
+  scoped_ptr<GeometryBinding> shared_geometry_;
   gfx::QuadF shared_geometry_quad_;
 
   // This block of bindings defines all of the programs used by the compositor
   // itself.  Add any new programs here to GLRendererShaderTest.
 
   // Tiled layer shaders.
   typedef ProgramBinding<VertexShaderTile, FragmentShaderRGBATexAlpha>
       TileProgram;
   typedef ProgramBinding<VertexShaderTileAA, FragmentShaderRGBATexClampAlphaAA>
       TileProgramAA;
@@ skipping 213 matching lines @@
   class SyncQuery;
   ScopedPtrDeque<SyncQuery> pending_sync_queries_;
   ScopedPtrDeque<SyncQuery> available_sync_queries_;
   scoped_ptr<SyncQuery> current_sync_query_;
   bool use_sync_query_;
   bool use_blend_equation_advanced_;
   bool use_blend_equation_advanced_coherent_;
 
   SkBitmap on_demand_tile_raster_bitmap_;
   ResourceProvider::ResourceId on_demand_tile_raster_resource_id_;
-  BoundGeometry bound_geometry_;
+
   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
 
 }  // namespace cc
 
 #endif  // CC_OUTPUT_GL_RENDERER_H_