cc: Use DrawingFrame as state, not function argument

cc/output/software_renderer.cc

 // Copyright 2012 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.
 
 #include "cc/output/software_renderer.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/base/math_util.h"
 #include "cc/output/copy_output_request.h"
@@ skipping 51 matching lines @@
 SoftwareRenderer::~SoftwareRenderer() {}
 
 bool SoftwareRenderer::CanPartialSwap() {
   return true;
 }
 
 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();
   current_canvas_ = nullptr;
   root_canvas_ = nullptr;
 
   output_device_->EndPaint();
 }
 
 void SoftwareRenderer::SwapBuffers(std::vector<ui::LatencyInfo> latency_info) {
   DCHECK(visible_);
   TRACE_EVENT0("cc", "SoftwareRenderer::SwapBuffers");
   OutputSurfaceFrame output_frame;
   output_frame.latency_info = std::move(latency_info);
   output_surface_->SwapBuffers(std::move(output_frame));
 }
 
-bool SoftwareRenderer::FlippedFramebuffer(const DrawingFrame* frame) const {
+bool SoftwareRenderer::FlippedFramebuffer() const {
   return false;
 }
 
 void SoftwareRenderer::EnsureScissorTestEnabled() {
   is_scissor_enabled_ = true;
   SetClipRect(scissor_rect_);
 }
 
 void SoftwareRenderer::EnsureScissorTestDisabled() {
   // There is no explicit notion of enabling/disabling scissoring in software
   // rendering, but the underlying effect we want is to clear any existing
   // clipRect on the current SkCanvas. This is done by setting clipRect to
   // the viewport's dimensions.
   if (!current_canvas_)
     return;
   is_scissor_enabled_ = false;
   SkISize size = current_canvas_->getBaseLayerSize();
   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();
   current_canvas_ = root_canvas_;
 }
 
 bool SoftwareRenderer::BindFramebufferToTexture(
-    DrawingFrame* frame,
     const ScopedResource* texture) {
   DCHECK(texture->id());
 
   // Explicitly release lock, otherwise we can crash when try to lock
   // same texture again.
   current_framebuffer_lock_ = nullptr;
   current_framebuffer_lock_ =
       base::MakeUnique<ResourceProvider::ScopedWriteLockSoftware>(
           resource_provider_, texture->id());
   current_framebuffer_canvas_ =
@@ skipping 19 matching lines @@
                             SkClipOp::kReplace_private_internal_do_not_use);
   current_canvas_->setMatrix(current_matrix);
 }
 
 void SoftwareRenderer::ClearCanvas(SkColor color) {
   if (!current_canvas_)
     return;
   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
     // On DEBUG builds, opaque render passes are cleared to blue
     // to easily see regions that were not drawn on the screen.
     ClearCanvas(SkColorSetARGB(255, 0, 0, 255));
 #endif
   }
 }
 
 void SoftwareRenderer::PrepareSurfaceForPass(
-    DrawingFrame* frame,
     SurfaceInitializationMode initialization_mode,
     const gfx::Rect& render_pass_scissor) {
   switch (initialization_mode) {
     case SURFACE_INITIALIZATION_MODE_PRESERVE:
       EnsureScissorTestDisabled();
       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;
   }
 }
 
 bool SoftwareRenderer::IsSoftwareResource(ResourceId resource_id) const {
   switch (resource_provider_->GetResourceType(resource_id)) {
     case ResourceProvider::RESOURCE_TYPE_GPU_MEMORY_BUFFER:
     case ResourceProvider::RESOURCE_TYPE_GL_TEXTURE:
       return false;
     case ResourceProvider::RESOURCE_TYPE_BITMAP:
       return true;
   }
 
   LOG(FATAL) << "Invalid resource type.";
   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;
   if (draw_region) {
     current_canvas_->save();
   }
 
   TRACE_EVENT0("cc", "SoftwareRenderer::DoDrawQuad");
   gfx::Transform quad_rect_matrix;
   QuadRectTransform(&quad_rect_matrix,
                     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,
                                     &sk_device_matrix);
   current_canvas_->setMatrix(sk_device_matrix);
 
   current_paint_.reset();
   if (settings_->force_antialiasing ||
       !IsScaleAndIntegerTranslate(sk_device_matrix)) {
     // TODO(danakj): Until we can enable AA only on exterior edges of the
@@ skipping 27 matching lines @@
 
     SkPoint clip_points[4];
     QuadFToSkPoints(local_draw_region, clip_points);
     draw_region_clip_path.addPoly(clip_points, 4, true);
 
     current_canvas_->clipPath(draw_region_clip_path);
   }
 
   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
       // reaching a direct renderer.
       NOTREACHED();
       break;
     case DrawQuad::INVALID:
     case DrawQuad::YUV_VIDEO_CONTENT:
     case DrawQuad::STREAM_VIDEO_CONTENT:
-      DrawUnsupportedQuad(frame, quad);
+      DrawUnsupportedQuad(quad);
       NOTREACHED();
       break;
   }
 
   current_canvas_->resetMatrix();
   if (draw_region) {
     current_canvas_->restore();
   }
 }
 
-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);
   SkPoint transformed_vertices[4];
   current_canvas_->getTotalMatrix().mapPoints(transformed_vertices,
                                               vertices,
                                               4);
   current_canvas_->resetMatrix();
 
   current_paint_.setColor(quad->color);
   current_paint_.setAlpha(quad->shared_quad_state->opacity *
                           SkColorGetA(quad->color));
   current_paint_.setStyle(SkPaint::kStroke_Style);
   current_paint_.setStrokeWidth(quad->width);
   current_canvas_->drawPoints(SkCanvas::kPolygon_PointMode,
                               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),
       gfx::RectFToSkRect(QuadVertexRect()),
       SkMatrix::kFill_ScaleToFit);
   current_canvas_->concat(content_matrix);
 
   const bool needs_transparency =
       SkScalarRoundToInt(quad->shared_quad_state->opacity * 255) < 255;
   const bool disable_image_filtering =
@@ skipping 23 matching lines @@
     quad->raster_source->PlaybackToCanvas(
         &filtered_canvas, quad->content_rect, quad->content_rect,
         quad->contents_scale, playback_settings);
   } else {
     quad->raster_source->PlaybackToCanvas(
         current_canvas_, quad->content_rect, quad->content_rect,
         quad->contents_scale, playback_settings);
   }
 }
 
-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);
   current_paint_.setAlpha(quad->shared_quad_state->opacity *
                           SkColorGetA(quad->color));
   current_canvas_->drawRect(gfx::RectFToSkRect(visible_quad_vertex_rect),
                             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;
   }
 
   // TODO(skaslev): Add support for non-premultiplied alpha.
   ResourceProvider::ScopedReadLockSkImage lock(resource_provider_,
                                                quad->resource_id());
   if (!lock.valid())
     return;
   const SkImage* image = lock.sk_image();
   gfx::RectF uv_rect = gfx::ScaleRect(
@@ skipping 21 matching lines @@
     background_paint.setColor(quad->background_color);
     current_canvas_->drawRect(quad_rect, background_paint);
   }
   current_paint_.setFilterQuality(
       quad->nearest_neighbor ? kNone_SkFilterQuality : kLow_SkFilterQuality);
   current_canvas_->drawImageRect(image, sk_uv_rect, quad_rect, &current_paint_);
   if (needs_layer)
     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_);
   DCHECK(IsSoftwareResource(quad->resource_id()));
 
   ResourceProvider::ScopedReadLockSkImage lock(resource_provider_,
                                                quad->resource_id());
   if (!lock.valid())
     return;
 
   gfx::RectF visible_tex_coord_rect = MathUtil::ScaleRectProportional(
       quad->tex_coord_rect, gfx::RectF(quad->rect),
       gfx::RectF(quad->visible_rect));
   gfx::RectF visible_quad_vertex_rect = MathUtil::ScaleRectProportional(
       QuadVertexRect(), gfx::RectF(quad->rect), gfx::RectF(quad->visible_rect));
 
   SkRect uv_rect = gfx::RectFToSkRect(visible_tex_coord_rect);
   current_paint_.setFilterQuality(
       quad->nearest_neighbor ? kNone_SkFilterQuality : kLow_SkFilterQuality);
   current_canvas_->drawImageRect(lock.sk_image(), uv_rect,
                                  gfx::RectFToSkRect(visible_quad_vertex_rect),
                                  &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);
   DCHECK(content_texture->id());
   DCHECK(IsSoftwareResource(content_texture->id()));
 
   ResourceProvider::ScopedReadLockSoftware lock(resource_provider_,
                                                 content_texture->id());
   if (!lock.valid())
     return;
@@ skipping 72 matching lines @@
                                    SkShader::kClamp_TileMode, &mask_mat));
 
     SkLayerRasterizer::Builder builder;
     builder.addLayer(mask_paint);
 
     current_paint_.setRasterizer(builder.detach());
   }
 
   // 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));
     paint.setRasterizer(current_paint_.refRasterizer());
     current_canvas_->drawRect(dest_visible_rect, paint);
   }
   current_paint_.setShader(std::move(shader));
   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
   current_paint_.setColor(SK_ColorMAGENTA);
 #endif
   current_paint_.setAlpha(quad->shared_quad_state->opacity * 255);
   current_canvas_->drawRect(gfx::RectFToSkRect(QuadVertexRect()),
                             current_paint_);
 }
 
 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(),
                                              window_copy_rect.height()));
   current_canvas_->readPixels(
       bitmap.get(), window_copy_rect.x(), window_copy_rect.y());
 
   request->SendBitmapResult(std::move(bitmap));
 }
 
@@ skipping 63 matching lines @@
 SkBitmap SoftwareRenderer::GetBackdropBitmap(
     const gfx::Rect& bounding_rect) const {
   SkBitmap bitmap;
   bitmap.setInfo(SkImageInfo::MakeN32Premul(bounding_rect.width(),
                                             bounding_rect.height()));
   current_canvas_->readPixels(&bitmap, bounding_rect.x(), bounding_rect.y());
   return bitmap;
 }
 
 gfx::Rect SoftwareRenderer::GetBackdropBoundingBoxForRenderPassQuad(
-    const DrawingFrame* frame,
     const RenderPassDrawQuad* quad,
     const gfx::Transform& contents_device_transform,
     const FilterOperations* background_filters,
     gfx::Rect* unclipped_rect) const {
   DCHECK(ShouldApplyBackgroundFilters(quad, background_filters));
   gfx::Rect backdrop_rect = gfx::ToEnclosingRect(
       MathUtil::MapClippedRect(contents_device_transform, QuadVertexRect()));
 
   SkMatrix matrix;
   matrix.setScale(quad->filters_scale.x(), quad->filters_scale.y());
   backdrop_rect = background_filters->MapRectReverse(backdrop_rect, matrix);
 
   *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 =
       BackgroundFiltersForPass(quad->render_pass_id);
   if (!ShouldApplyBackgroundFilters(quad, background_filters))
     return nullptr;
 
   gfx::Transform quad_rect_matrix;
   QuadRectTransform(&quad_rect_matrix,
                     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;
   if (!contents_device_transform.GetInverse(&contents_device_transform_inverse))
     return nullptr;
 
   SkMatrix filter_backdrop_transform =
       contents_device_transform_inverse.matrix();
   filter_backdrop_transform.preTranslate(backdrop_rect.x(), backdrop_rect.y());
 
@@ skipping 11 matching lines @@
       ApplyImageFilter(filter.get(), quad, backdrop_bitmap, nullptr);
 
   if (!filter_backdrop_image)
     return nullptr;
 
   return filter_backdrop_image->makeShader(content_tile_mode, content_tile_mode,
                                            &filter_backdrop_transform);
 }
 
 }  // namespace cc