Remove references to DrawingFrame from RenderPassDrawQuad drawing.

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 169 matching lines @@
   gfx::Rect GetBackdropBoundingBoxForRenderPassQuad(
       DrawingFrame* frame,
       const RenderPassDrawQuad* quad,
       const gfx::Transform& contents_device_transform,
       const gfx::QuadF* clip_region,
       bool use_aa);
   std::unique_ptr<ScopedResource> GetBackdropTexture(
       const gfx::Rect& bounding_rect);
 
   static bool ShouldApplyBackgroundFilters(const RenderPassDrawQuad* quad);
-  sk_sp<SkImage> ApplyBackgroundFilters(DrawingFrame* frame,
-                                        const RenderPassDrawQuad* quad,
+  sk_sp<SkImage> ApplyBackgroundFilters(const RenderPassDrawQuad* quad,
                                         ScopedResource* background_texture,
                                         const gfx::RectF& rect);
 
   const TileDrawQuad* CanPassBeDrawnDirectly(const RenderPass* pass) override;
 
   void DrawRenderPassQuad(DrawingFrame* frame,
                           const RenderPassDrawQuad* quadi,
                           const gfx::QuadF* clip_region);
   void DrawRenderPassQuadInternal(DrawRenderPassDrawQuadParams* params);
   void DrawSolidColorQuad(const DrawingFrame* frame,
@@ skipping 34 matching lines @@
                        const gfx::QuadF* clip_region);
 
   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,
+  void DrawQuadGeometry(const gfx::Transform& projection_matrix,
                         const gfx::Transform& draw_transform,
                         const gfx::RectF& quad_rect,
                         int matrix_location);
   void SetUseProgram(unsigned program);
 
   bool MakeContextCurrent();
 
   void InitializeSharedObjects();
   void CleanupSharedObjects();
 
   typedef base::Callback<void(std::unique_ptr<CopyOutputRequest> copy_request,
                               bool success)>
       AsyncGetFramebufferPixelsCleanupCallback;
   void FinishedReadback(unsigned source_buffer,
                         unsigned query,
                         const gfx::Size& size);
 
   void ReinitializeGLState();
   void RestoreGLState();
-  void RestoreFramebuffer(DrawingFrame* frame);
 
   void DiscardBackbuffer() override;
   void EnsureBackbuffer() override;
   void EnforceMemoryPolicy();
 
   void ScheduleCALayers(DrawingFrame* frame);
   void ScheduleOverlays(DrawingFrame* frame);
 
   // Copies the contents of the render pass to an overlay resource, returned in
   // |resource|. The resource is allocated from |overlay_resource_pool_|.
@@ skipping 262 matching lines @@
   // overlay resource. This means the GLRenderer needs its own ResourcePool.
   std::unique_ptr<ResourcePool> overlay_resource_pool_;
 
   BoundGeometry bound_geometry_;
   DISALLOW_COPY_AND_ASSIGN(GLRenderer);
 };
 
 }  // namespace cc
 
 #endif  // CC_OUTPUT_GL_RENDERER_H_