cc: Use DrawingFrame as state, not function argument

cc/output/software_renderer.cc

Index: cc/output/software_renderer.cc
diff --git a/cc/output/software_renderer.cc b/cc/output/software_renderer.cc
index ff3c6fd473fe7dc0df5bb4613ee5fe725b34b53a..6ce1405416e515b4fdd22739823c6055b9112e6b 100644
--- a/cc/output/software_renderer.cc
+++ b/cc/output/software_renderer.cc
@@ -69,12 +69,12 @@ ResourceFormat SoftwareRenderer::BackbufferFormat() const {
   return resource_provider_->best_texture_format();
 }
 
-void SoftwareRenderer::BeginDrawingFrame(DrawingFrame* frame) {
+void SoftwareRenderer::BeginDrawingFrame() {
   TRACE_EVENT0("cc", "SoftwareRenderer::BeginDrawingFrame");
-  root_canvas_ = output_device_->BeginPaint(frame->root_damage_rect);
+  root_canvas_ = output_device_->BeginPaint(current_frame()->root_damage_rect);
 }
 
-void SoftwareRenderer::FinishDrawingFrame(DrawingFrame* frame) {
+void SoftwareRenderer::FinishDrawingFrame() {
   TRACE_EVENT0("cc", "SoftwareRenderer::FinishDrawingFrame");
   current_framebuffer_lock_ = nullptr;
   current_framebuffer_canvas_.reset();
@@ -92,7 +92,7 @@ void SoftwareRenderer::SwapBuffers(std::vector<ui::LatencyInfo> latency_info) {
   output_surface_->SwapBuffers(std::move(output_frame));
 }
 
-bool SoftwareRenderer::FlippedFramebuffer(const DrawingFrame* frame) const {
+bool SoftwareRenderer::FlippedFramebuffer() const {
   return false;
 }
 
@@ -113,7 +113,7 @@ void SoftwareRenderer::EnsureScissorTestDisabled() {
   SetClipRect(gfx::Rect(size.width(), size.height()));
 }
 
-void SoftwareRenderer::BindFramebufferToOutputSurface(DrawingFrame* frame) {
+void SoftwareRenderer::BindFramebufferToOutputSurface() {
   DCHECK(!output_surface_->HasExternalStencilTest());
   current_framebuffer_lock_ = nullptr;
   current_framebuffer_canvas_.reset();
@@ -121,7 +121,6 @@ void SoftwareRenderer::BindFramebufferToOutputSurface(DrawingFrame* frame) {
 }
 
 bool SoftwareRenderer::BindFramebufferToTexture(
-    DrawingFrame* frame,
     const ScopedResource* texture) {
   DCHECK(texture->id());
 
@@ -161,8 +160,8 @@ void SoftwareRenderer::ClearCanvas(SkColor color) {
   current_canvas_->clear(color);
 }
 
-void SoftwareRenderer::ClearFramebuffer(DrawingFrame* frame) {
-  if (frame->current_render_pass->has_transparent_background) {
+void SoftwareRenderer::ClearFramebuffer() {
+  if (current_frame()->current_render_pass->has_transparent_background) {
     ClearCanvas(SkColorSetARGB(0, 0, 0, 0));
   } else {
 #ifndef NDEBUG
@@ -174,7 +173,6 @@ void SoftwareRenderer::ClearFramebuffer(DrawingFrame* frame) {
 }
 
 void SoftwareRenderer::PrepareSurfaceForPass(
-    DrawingFrame* frame,
     SurfaceInitializationMode initialization_mode,
     const gfx::Rect& render_pass_scissor) {
   switch (initialization_mode) {
@@ -183,11 +181,11 @@ void SoftwareRenderer::PrepareSurfaceForPass(
       return;
     case SURFACE_INITIALIZATION_MODE_FULL_SURFACE_CLEAR:
       EnsureScissorTestDisabled();
-      ClearFramebuffer(frame);
+      ClearFramebuffer();
       break;
     case SURFACE_INITIALIZATION_MODE_SCISSORED_CLEAR:
       SetScissorTestRect(render_pass_scissor);
-      ClearFramebuffer(frame);
+      ClearFramebuffer();
       break;
   }
 }
@@ -205,8 +203,7 @@ bool SoftwareRenderer::IsSoftwareResource(ResourceId resource_id) const {
   return false;
 }
 
-void SoftwareRenderer::DoDrawQuad(DrawingFrame* frame,
-                                  const DrawQuad* quad,
+void SoftwareRenderer::DoDrawQuad(const DrawQuad* quad,
                                   const gfx::QuadF* draw_region) {
   if (!current_canvas_)
     return;
@@ -220,7 +217,8 @@ void SoftwareRenderer::DoDrawQuad(DrawingFrame* frame,
                     quad->shared_quad_state->quad_to_target_transform,
                     gfx::RectF(quad->rect));
   gfx::Transform contents_device_transform =
-      frame->window_matrix * frame->projection_matrix * quad_rect_matrix;
+      current_frame()->window_matrix * current_frame()->projection_matrix *
+      quad_rect_matrix;
   contents_device_transform.FlattenTo2d();
   SkMatrix sk_device_matrix;
   gfx::TransformToFlattenedSkMatrix(contents_device_transform,
@@ -268,22 +266,22 @@ void SoftwareRenderer::DoDrawQuad(DrawingFrame* frame,
 
   switch (quad->material) {
     case DrawQuad::DEBUG_BORDER:
-      DrawDebugBorderQuad(frame, DebugBorderDrawQuad::MaterialCast(quad));
+      DrawDebugBorderQuad(DebugBorderDrawQuad::MaterialCast(quad));
       break;
     case DrawQuad::PICTURE_CONTENT:
-      DrawPictureQuad(frame, PictureDrawQuad::MaterialCast(quad));
+      DrawPictureQuad(PictureDrawQuad::MaterialCast(quad));
       break;
     case DrawQuad::RENDER_PASS:
-      DrawRenderPassQuad(frame, RenderPassDrawQuad::MaterialCast(quad));
+      DrawRenderPassQuad(RenderPassDrawQuad::MaterialCast(quad));
       break;
     case DrawQuad::SOLID_COLOR:
-      DrawSolidColorQuad(frame, SolidColorDrawQuad::MaterialCast(quad));
+      DrawSolidColorQuad(SolidColorDrawQuad::MaterialCast(quad));
       break;
     case DrawQuad::TEXTURE_CONTENT:
-      DrawTextureQuad(frame, TextureDrawQuad::MaterialCast(quad));
+      DrawTextureQuad(TextureDrawQuad::MaterialCast(quad));
       break;
     case DrawQuad::TILED_CONTENT:
-      DrawTileQuad(frame, TileDrawQuad::MaterialCast(quad));
+      DrawTileQuad(TileDrawQuad::MaterialCast(quad));
       break;
     case DrawQuad::SURFACE_CONTENT:
       // Surface content should be fully resolved to other quad types before
@@ -293,7 +291,7 @@ void SoftwareRenderer::DoDrawQuad(DrawingFrame* frame,
     case DrawQuad::INVALID:
     case DrawQuad::YUV_VIDEO_CONTENT:
     case DrawQuad::STREAM_VIDEO_CONTENT:
-      DrawUnsupportedQuad(frame, quad);
+      DrawUnsupportedQuad(quad);
       NOTREACHED();
       break;
   }
@@ -304,8 +302,7 @@ void SoftwareRenderer::DoDrawQuad(DrawingFrame* frame,
   }
 }
 
-void SoftwareRenderer::DrawDebugBorderQuad(const DrawingFrame* frame,
-                                           const DebugBorderDrawQuad* quad) {
+void SoftwareRenderer::DrawDebugBorderQuad(const DebugBorderDrawQuad* quad) {
   // We need to apply the matrix manually to have pixel-sized stroke width.
   SkPoint vertices[4];
   gfx::RectFToSkRect(QuadVertexRect()).toQuad(vertices);
@@ -324,8 +321,7 @@ void SoftwareRenderer::DrawDebugBorderQuad(const DrawingFrame* frame,
                               4, transformed_vertices, current_paint_);
 }
 
-void SoftwareRenderer::DrawPictureQuad(const DrawingFrame* frame,
-                                       const PictureDrawQuad* quad) {
+void SoftwareRenderer::DrawPictureQuad(const PictureDrawQuad* quad) {
   SkMatrix content_matrix;
   content_matrix.setRectToRect(
       gfx::RectFToSkRect(quad->tex_coord_rect),
@@ -369,8 +365,7 @@ void SoftwareRenderer::DrawPictureQuad(const DrawingFrame* frame,
   }
 }
 
-void SoftwareRenderer::DrawSolidColorQuad(const DrawingFrame* frame,
-                                          const SolidColorDrawQuad* quad) {
+void SoftwareRenderer::DrawSolidColorQuad(const SolidColorDrawQuad* quad) {
   gfx::RectF visible_quad_vertex_rect = MathUtil::ScaleRectProportional(
       QuadVertexRect(), gfx::RectF(quad->rect), gfx::RectF(quad->visible_rect));
   current_paint_.setColor(quad->color);
@@ -380,10 +375,9 @@ void SoftwareRenderer::DrawSolidColorQuad(const DrawingFrame* frame,
                             current_paint_);
 }
 
-void SoftwareRenderer::DrawTextureQuad(const DrawingFrame* frame,
-                                       const TextureDrawQuad* quad) {
+void SoftwareRenderer::DrawTextureQuad(const TextureDrawQuad* quad) {
   if (!IsSoftwareResource(quad->resource_id())) {
-    DrawUnsupportedQuad(frame, quad);
+    DrawUnsupportedQuad(quad);
     return;
   }
 
@@ -425,8 +419,7 @@ void SoftwareRenderer::DrawTextureQuad(const DrawingFrame* frame,
     current_canvas_->restore();
 }
 
-void SoftwareRenderer::DrawTileQuad(const DrawingFrame* frame,
-                                    const TileDrawQuad* quad) {
+void SoftwareRenderer::DrawTileQuad(const TileDrawQuad* quad) {
   // |resource_provider_| can be NULL in resourceless software draws, which
   // should never produce tile quads in the first place.
   DCHECK(resource_provider_);
@@ -451,8 +444,7 @@ void SoftwareRenderer::DrawTileQuad(const DrawingFrame* frame,
                                  &current_paint_);
 }
 
-void SoftwareRenderer::DrawRenderPassQuad(const DrawingFrame* frame,
-                                          const RenderPassDrawQuad* quad) {
+void SoftwareRenderer::DrawRenderPassQuad(const RenderPassDrawQuad* quad) {
   ScopedResource* content_texture =
       render_pass_textures_[quad->render_pass_id].get();
   DCHECK(content_texture);
@@ -545,7 +537,7 @@ void SoftwareRenderer::DrawRenderPassQuad(const DrawingFrame* frame,
 
   // If we have a background filter shader, render its results first.
   sk_sp<SkShader> background_filter_shader =
-      GetBackgroundFilterShader(frame, quad, SkShader::kClamp_TileMode);
+      GetBackgroundFilterShader(quad, SkShader::kClamp_TileMode);
   if (background_filter_shader) {
     SkPaint paint;
     paint.setShader(std::move(background_filter_shader));
@@ -556,8 +548,7 @@ void SoftwareRenderer::DrawRenderPassQuad(const DrawingFrame* frame,
   current_canvas_->drawRect(dest_visible_rect, current_paint_);
 }
 
-void SoftwareRenderer::DrawUnsupportedQuad(const DrawingFrame* frame,
-                                           const DrawQuad* quad) {
+void SoftwareRenderer::DrawUnsupportedQuad(const DrawQuad* quad) {
 #ifdef NDEBUG
   current_paint_.setColor(SK_ColorWHITE);
 #else
@@ -569,12 +560,11 @@ void SoftwareRenderer::DrawUnsupportedQuad(const DrawingFrame* frame,
 }
 
 void SoftwareRenderer::CopyCurrentRenderPassToBitmap(
-    DrawingFrame* frame,
     std::unique_ptr<CopyOutputRequest> request) {
-  gfx::Rect copy_rect = frame->current_render_pass->output_rect;
+  gfx::Rect copy_rect = current_frame()->current_render_pass->output_rect;
   if (request->has_area())
     copy_rect.Intersect(request->area());
-  gfx::Rect window_copy_rect = MoveFromDrawToWindowSpace(frame, copy_rect);
+  gfx::Rect window_copy_rect = MoveFromDrawToWindowSpace(copy_rect);
 
   std::unique_ptr<SkBitmap> bitmap(new SkBitmap);
   bitmap->setInfo(SkImageInfo::MakeN32Premul(window_copy_rect.width(),
@@ -658,7 +648,6 @@ SkBitmap SoftwareRenderer::GetBackdropBitmap(
 }
 
 gfx::Rect SoftwareRenderer::GetBackdropBoundingBoxForRenderPassQuad(
-    const DrawingFrame* frame,
     const RenderPassDrawQuad* quad,
     const gfx::Transform& contents_device_transform,
     const FilterOperations* background_filters,
@@ -673,13 +662,12 @@ gfx::Rect SoftwareRenderer::GetBackdropBoundingBoxForRenderPassQuad(
 
   *unclipped_rect = backdrop_rect;
   backdrop_rect.Intersect(MoveFromDrawToWindowSpace(
-      frame, frame->current_render_pass->output_rect));
+      current_frame()->current_render_pass->output_rect));
 
   return backdrop_rect;
 }
 
 sk_sp<SkShader> SoftwareRenderer::GetBackgroundFilterShader(
-    const DrawingFrame* frame,
     const RenderPassDrawQuad* quad,
     SkShader::TileMode content_tile_mode) const {
   const FilterOperations* background_filters =
@@ -692,13 +680,13 @@ sk_sp<SkShader> SoftwareRenderer::GetBackgroundFilterShader(
                     quad->shared_quad_state->quad_to_target_transform,
                     gfx::RectF(quad->rect));
   gfx::Transform contents_device_transform =
-      frame->window_matrix * frame->projection_matrix * quad_rect_matrix;
+      current_frame()->window_matrix * current_frame()->projection_matrix *
+      quad_rect_matrix;
   contents_device_transform.FlattenTo2d();
 
   gfx::Rect unclipped_rect;
   gfx::Rect backdrop_rect = GetBackdropBoundingBoxForRenderPassQuad(
-      frame, quad, contents_device_transform, background_filters,
-      &unclipped_rect);
+      quad, contents_device_transform, background_filters, &unclipped_rect);
 
   // Figure out the transformations to move it back to pixel space.
   gfx::Transform contents_device_transform_inverse;