Implement new RPDQ copy logic for CALayer promotion.

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 <deque>
 #include <vector>
 
@@ skipping 252 matching lines @@
   void ReinitializeGLState();
   void RestoreGLState();
 
   void DiscardBackbuffer() override;
   void EnsureBackbuffer() override;
   void EnforceMemoryPolicy();
 
   void ScheduleCALayers(DrawingFrame* frame);
   void ScheduleOverlays(DrawingFrame* frame);
 
+  // Copies the contents of the render pass draw quad, including filter effects,
+  // to an overlay resource, returned in |resource|. The resource is allocated
+  // from |overlay_resource_pool_|.
+  // The resulting Resource may be larger than the original quad. The new size
+  // and position is placed in |new_bounds|.
+  void CopyRenderPassDrawQuadToOverlayResource(
+      const CALayerOverlay* ca_layer_overlay,
+      Resource** resource,
+      DrawingFrame* frame,
+      gfx::RectF* new_bounds);
+
+  // Schedules the |ca_layer_overlay|, which is guaranteed to have a non-null
+  // |rpdq| parameter.
+  void ScheduleRenderPassDrawQuad(const CALayerOverlay* ca_layer_overlay,
+                                  DrawingFrame* external_frame);
+
   using OverlayResourceLock =
       std::unique_ptr<ResourceProvider::ScopedReadLockGL>;
   using OverlayResourceLockList = std::vector<OverlayResourceLock>;
 
   // Resources that have been sent to the GPU process, but not yet swapped.
   OverlayResourceLockList pending_overlay_resources_;
 
   // Resources that should be shortly swapped by the GPU process.
   std::deque<OverlayResourceLockList> swapping_overlay_resources_;
 
@@ skipping 244 matching lines @@
   bool use_sync_query_;
   bool use_blend_equation_advanced_;
   bool use_blend_equation_advanced_coherent_;
 
   // Some overlays require that content is copied from a render pass into an
   // overlay resource. This means the GLRenderer needs its own ResourcePool.
   std::unique_ptr<ResourcePool> overlay_resource_pool_;
 
   // If true, draw a green border after compositing a texture quad using GL.
   bool gl_composited_texture_quad_border_;
+
+  // The method FlippedFramebuffer determines whether the framebuffer associated
+  // with a DrawingFrame is flipped. It makes the assumption that the
+  // DrawingFrame is being used as part of a render pass. If a DrawingFrame is
+  // not being used as part of a render pass, setting it here forces
+  // FlippedFramebuffer to return |true|.
+  const DrawingFrame* force_drawing_frame_framebuffer_flipped_;
+
   BoundGeometry bound_geometry_;
   DISALLOW_COPY_AND_ASSIGN(GLRenderer);
 };
 
 }  // namespace cc
 
 #endif  // CC_OUTPUT_GL_RENDERER_H_