cc: Use DrawingFrame as state, not function argument

cc/output/gl_renderer.cc

 // 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.
 
 #include "cc/output/gl_renderer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 156 matching lines @@
   const RenderPassDrawQuad* quad = nullptr;
   const Resource* contents_texture = nullptr;
   const gfx::QuadF* clip_region = nullptr;
   bool flip_texture = false;
   gfx::Transform window_matrix;
   gfx::Transform projection_matrix;
   gfx::Transform quad_to_target_transform;
   const FilterOperations* filters = nullptr;
   const FilterOperations* background_filters = nullptr;
 
-  // |frame| is only used for background effects.
-  DirectRenderer::DrawingFrame* frame = nullptr;
-
   // Whether the texture to be sampled from needs to be flipped.
   bool source_needs_flip = false;
 
   float edge[24];
   SkScalar color_matrix[20];
 
   // Blending refers to modifications to the backdrop.
   bool use_shaders_for_blending = false;
   const Program* program = nullptr;
 
@@ skipping 270 matching lines @@
   bool using_default_framebuffer =
       !current_framebuffer_lock_ &&
       output_surface_->capabilities().uses_default_gl_framebuffer;
   GLenum attachments[] = {static_cast<GLenum>(
       using_default_framebuffer ? GL_COLOR_EXT : GL_COLOR_ATTACHMENT0_EXT)};
   gl_->DiscardFramebufferEXT(
       GL_FRAMEBUFFER, arraysize(attachments), attachments);
 }
 
 void GLRenderer::PrepareSurfaceForPass(
-    DrawingFrame* frame,
     SurfaceInitializationMode initialization_mode,
     const gfx::Rect& render_pass_scissor) {
   SetViewport();
 
   switch (initialization_mode) {
     case SURFACE_INITIALIZATION_MODE_PRESERVE:
       EnsureScissorTestDisabled();
       return;
     case SURFACE_INITIALIZATION_MODE_FULL_SURFACE_CLEAR:
       EnsureScissorTestDisabled();
       DiscardPixels();
-      ClearFramebuffer(frame);
+      ClearFramebuffer();
       break;
     case SURFACE_INITIALIZATION_MODE_SCISSORED_CLEAR:
       SetScissorTestRect(render_pass_scissor);
-      ClearFramebuffer(frame);
+      ClearFramebuffer();
       break;
   }
 }
 
-void GLRenderer::ClearFramebuffer(DrawingFrame* frame) {
+void GLRenderer::ClearFramebuffer() {
   // On DEBUG builds, opaque render passes are cleared to blue to easily see
   // regions that were not drawn on the screen.
-  if (frame->current_render_pass->has_transparent_background)
+  if (current_frame()->current_render_pass->has_transparent_background)
     gl_->ClearColor(0, 0, 0, 0);
   else
     gl_->ClearColor(0, 0, 1, 1);
 
   gl_->ClearStencil(0);
 
   bool always_clear = overdraw_feedback_;
 #ifndef NDEBUG
   always_clear = true;
 #endif
-  if (always_clear || frame->current_render_pass->has_transparent_background) {
+  if (always_clear ||
+      current_frame()->current_render_pass->has_transparent_background) {
     GLbitfield clear_bits = GL_COLOR_BUFFER_BIT;
     if (always_clear)
       clear_bits |= GL_STENCIL_BUFFER_BIT;
     gl_->Clear(clear_bits);
   }
 }
 
-void GLRenderer::BeginDrawingFrame(DrawingFrame* frame) {
+void GLRenderer::BeginDrawingFrame() {
   TRACE_EVENT0("cc", "GLRenderer::BeginDrawingFrame");
 
   scoped_refptr<ResourceProvider::Fence> read_lock_fence;
   if (use_sync_query_) {
     // Block until oldest sync query has passed if the number of pending queries
     // ever reach kMaxPendingSyncQueries.
     if (pending_sync_queries_.size() >= kMaxPendingSyncQueries) {
       LOG(ERROR) << "Reached limit of pending sync queries.";
 
       pending_sync_queries_.front()->Wait();
@@ skipping 14 matching lines @@
     read_lock_fence = current_sync_query_->Begin();
   } else {
     read_lock_fence =
         make_scoped_refptr(new ResourceProvider::SynchronousFence(gl_));
   }
   resource_provider_->SetReadLockFence(read_lock_fence.get());
 
   // Insert WaitSyncTokenCHROMIUM on quad resources prior to drawing the frame,
   // so that drawing can proceed without GL context switching interruptions.
   ResourceProvider* resource_provider = resource_provider_;
-  for (const auto& pass : *frame->render_passes_in_draw_order) {
+  for (const auto& pass : *current_frame()->render_passes_in_draw_order) {
     for (auto* quad : pass->quad_list) {
       for (ResourceId resource_id : quad->resources)
         resource_provider->WaitSyncTokenIfNeeded(resource_id);
     }
   }
 
   // TODO(enne): Do we need to reinitialize all of this state per frame?
   ReinitializeGLState();
 }
 
-void GLRenderer::DoDrawQuad(DrawingFrame* frame,
-                            const DrawQuad* quad,
+void GLRenderer::DoDrawQuad(const DrawQuad* quad,
                             const gfx::QuadF* clip_region) {
   DCHECK(quad->rect.Contains(quad->visible_rect));
   if (quad->material != DrawQuad::TEXTURE_CONTENT) {
     FlushTextureQuadCache(SHARED_BINDING);
   }
 
   switch (quad->material) {
     case DrawQuad::INVALID:
       NOTREACHED();
       break;
     case DrawQuad::DEBUG_BORDER:
-      DrawDebugBorderQuad(frame, DebugBorderDrawQuad::MaterialCast(quad));
+      DrawDebugBorderQuad(DebugBorderDrawQuad::MaterialCast(quad));
       break;
     case DrawQuad::PICTURE_CONTENT:
       // PictureDrawQuad should only be used for resourceless software draws.
       NOTREACHED();
       break;
     case DrawQuad::RENDER_PASS:
-      DrawRenderPassQuad(frame, RenderPassDrawQuad::MaterialCast(quad),
-                         clip_region);
+      DrawRenderPassQuad(RenderPassDrawQuad::MaterialCast(quad), clip_region);
       break;
     case DrawQuad::SOLID_COLOR:
-      DrawSolidColorQuad(frame, SolidColorDrawQuad::MaterialCast(quad),
-                         clip_region);
+      DrawSolidColorQuad(SolidColorDrawQuad::MaterialCast(quad), clip_region);
       break;
     case DrawQuad::STREAM_VIDEO_CONTENT:
-      DrawStreamVideoQuad(frame, StreamVideoDrawQuad::MaterialCast(quad),
-                          clip_region);
+      DrawStreamVideoQuad(StreamVideoDrawQuad::MaterialCast(quad), clip_region);
       break;
     case DrawQuad::SURFACE_CONTENT:
       // Surface content should be fully resolved to other quad types before
       // reaching a direct renderer.
       NOTREACHED();
       break;
     case DrawQuad::TEXTURE_CONTENT:
-      EnqueueTextureQuad(frame, TextureDrawQuad::MaterialCast(quad),
-                         clip_region);
+      EnqueueTextureQuad(TextureDrawQuad::MaterialCast(quad), clip_region);
       break;
     case DrawQuad::TILED_CONTENT:
-      DrawTileQuad(frame, TileDrawQuad::MaterialCast(quad), clip_region);
+      DrawTileQuad(TileDrawQuad::MaterialCast(quad), clip_region);
       break;
     case DrawQuad::YUV_VIDEO_CONTENT:
-      DrawYUVVideoQuad(frame, YUVVideoDrawQuad::MaterialCast(quad),
-                       clip_region);
+      DrawYUVVideoQuad(YUVVideoDrawQuad::MaterialCast(quad), clip_region);
       break;
   }
 }
 
 // This function does not handle 3D sorting right now, since the debug border
 // quads are just drawn as their original quads and not in split pieces. This
 // results in some debug border quads drawing over foreground quads.
-void GLRenderer::DrawDebugBorderQuad(const DrawingFrame* frame,
-                                     const DebugBorderDrawQuad* quad) {
+void GLRenderer::DrawDebugBorderQuad(const DebugBorderDrawQuad* quad) {
   SetBlendEnabled(quad->ShouldDrawWithBlending());
 
   const Program* program = GetProgram(ProgramKey::DebugBorder());
   SetUseProgram(program);
 
   // Use the full quad_rect for debug quads to not move the edges based on
   // partial swaps.
   gfx::Rect layer_rect = quad->rect;
   gfx::Transform render_matrix;
   QuadRectTransform(&render_matrix,
                     quad->shared_quad_state->quad_to_target_transform,
                     gfx::RectF(layer_rect));
-  SetShaderMatrix(frame->projection_matrix * render_matrix);
+  SetShaderMatrix(current_frame()->projection_matrix * render_matrix);
   SetShaderColor(quad->color, 1.f);
 
   gl_->LineWidth(quad->width);
 
   // The indices for the line are stored in the same array as the triangle
   // indices.
   gl_->DrawElements(GL_LINE_LOOP, 4, GL_UNSIGNED_SHORT, 0);
 }
 
 static sk_sp<SkImage> WrapTexture(
@@ skipping 197 matching lines @@
   uvs[2] = ((clip->p2().x() - rect.x()) / rect.width());
   uvs[3] = ((clip->p2().y() - rect.y()) / rect.height());
   uvs[4] = ((clip->p3().x() - rect.x()) / rect.width());
   uvs[5] = ((clip->p3().y() - rect.y()) / rect.height());
   uvs[6] = ((clip->p4().x() - rect.x()) / rect.width());
   uvs[7] = ((clip->p4().y() - rect.y()) / rect.height());
   return true;
 }
 
 gfx::Rect GLRenderer::GetBackdropBoundingBoxForRenderPassQuad(
-    DrawingFrame* frame,
     const RenderPassDrawQuad* quad,
     const gfx::Transform& contents_device_transform,
     const FilterOperations* filters,
     const FilterOperations* background_filters,
     const gfx::QuadF* clip_region,
     bool use_aa,
     gfx::Rect* unclipped_rect) {
   gfx::QuadF scaled_region;
   if (!GetScaledRegion(quad->rect, clip_region, &scaled_region)) {
     scaled_region = SharedGeometryQuad().BoundingBox();
   }
 
   gfx::Rect backdrop_rect = gfx::ToEnclosingRect(MathUtil::MapClippedRect(
       contents_device_transform, scaled_region.BoundingBox()));
 
   if (ShouldApplyBackgroundFilters(quad, background_filters)) {
     SkMatrix matrix;
     matrix.setScale(quad->filters_scale.x(), quad->filters_scale.y());
-    if (FlippedFramebuffer(frame)) {
+    if (FlippedFramebuffer()) {
       // TODO(jbroman): This probably isn't the right way to account for this.
-      // Probably some combination of frame->projection_matrix,
-      // frame->window_matrix and contents_device_transform?
+      // Probably some combination of current_frame()->projection_matrix,
+      // current_frame()->window_matrix and contents_device_transform?
       matrix.postScale(1, -1);
     }
     backdrop_rect = background_filters->MapRectReverse(backdrop_rect, matrix);
   }
 
   if (!backdrop_rect.IsEmpty() && use_aa) {
     const int kOutsetForAntialiasing = 1;
     backdrop_rect.Inset(-kOutsetForAntialiasing, -kOutsetForAntialiasing);
   }
 
   if (filters) {
     DCHECK(!filters->IsEmpty());
     // If we have filters, grab an extra one-pixel border around the
     // background, so texture edge clamping gives us a transparent border
     // in case the filter expands the result.
     backdrop_rect.Inset(-1, -1, -1, -1);
   }
 
   *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;
 }
 
 std::unique_ptr<ScopedResource> GLRenderer::GetBackdropTexture(
-    DrawingFrame* frame,
     const gfx::Rect& bounding_rect) {
   std::unique_ptr<ScopedResource> device_background_texture =
       ScopedResource::Create(resource_provider_);
   // CopyTexImage2D fails when called on a texture having immutable storage.
   device_background_texture->Allocate(
       bounding_rect.size(), ResourceProvider::TEXTURE_HINT_DEFAULT,
-      BackbufferFormat(), frame->device_color_space);
+      BackbufferFormat(), current_frame()->device_color_space);
   {
     ResourceProvider::ScopedWriteLockGL lock(
         resource_provider_, device_background_texture->id(), false);
     GetFramebufferTexture(lock.texture_id(), bounding_rect);
   }
   return device_background_texture;
 }
 
 sk_sp<SkImage> GLRenderer::ApplyBackgroundFilters(
     const RenderPassDrawQuad* quad,
@@ skipping 118 matching lines @@
     return nullptr;
 #if defined(OS_MACOSX)
   // On Macs, this path can sometimes lead to all black output.
   // TODO(enne): investigate this and remove this hack.
   return nullptr;
 #endif
 
   return tile_quad;
 }
 
-void GLRenderer::DrawRenderPassQuad(DrawingFrame* frame,
-                                    const RenderPassDrawQuad* quad,
+void GLRenderer::DrawRenderPassQuad(const RenderPassDrawQuad* quad,
                                     const gfx::QuadF* clip_region) {
   auto bypass = render_pass_bypass_quads_.find(quad->render_pass_id);
   DrawRenderPassDrawQuadParams params;
   params.quad = quad;
-  params.frame = frame;
   params.clip_region = clip_region;
-  params.window_matrix = frame->window_matrix;
-  params.projection_matrix = frame->projection_matrix;
+  params.window_matrix = current_frame()->window_matrix;
+  params.projection_matrix = current_frame()->projection_matrix;
   if (bypass != render_pass_bypass_quads_.end()) {
     TileDrawQuad* tile_quad = &bypass->second;
     // RGBA_8888 here is arbitrary and unused.
     Resource tile_resource(tile_quad->resource_id(), tile_quad->texture_size,
                            ResourceFormat::RGBA_8888,
-                           frame->device_color_space);
+                           current_frame()->device_color_space);
     // The projection matrix used by GLRenderer has a flip.  As tile texture
     // inputs are oriented opposite to framebuffer outputs, don't flip via
     // texture coords and let the projection matrix naturallyd o it.
     params.flip_texture = false;
     params.contents_texture = &tile_resource;
     DrawRenderPassQuadInternal(&params);
   } else {
     ScopedResource* contents_texture =
         render_pass_textures_[quad->render_pass_id].get();
     DCHECK(contents_texture);
     DCHECK(contents_texture->id());
     // See above comments about texture flipping.  When the input is a
     // render pass, it needs to an extra flip to be oriented correctly.
     params.flip_texture = true;
     params.contents_texture = contents_texture;
     DrawRenderPassQuadInternal(&params);
   }
 }
 
 void GLRenderer::DrawRenderPassQuadInternal(
     DrawRenderPassDrawQuadParams* params) {
   params->quad_to_target_transform =
       params->quad->shared_quad_state->quad_to_target_transform;
   if (!InitializeRPDQParameters(params))
     return;
   UpdateRPDQShadersForBlending(params);
   if (!UpdateRPDQWithSkiaFilters(params))
     return;
-  UseRenderPass(params->frame, params->frame->current_render_pass);
+  UseRenderPass(current_frame()->current_render_pass);
   SetViewport();
   UpdateRPDQTexturesForSampling(params);
   UpdateRPDQBlendMode(params);
   ChooseRPDQProgram(params);
   UpdateRPDQUniforms(params);
   DrawRPDQ(*params);
 }
 
 bool GLRenderer::InitializeRPDQParameters(
     DrawRenderPassDrawQuadParams* params) {
@@ skipping 43 matching lines @@
 void GLRenderer::UpdateRPDQShadersForBlending(
     DrawRenderPassDrawQuadParams* params) {
   const RenderPassDrawQuad* quad = params->quad;
   SkBlendMode blend_mode = quad->shared_quad_state->blend_mode;
   params->use_shaders_for_blending =
       !CanApplyBlendModeUsingBlendFunc(blend_mode) ||
       ShouldApplyBackgroundFilters(quad, params->background_filters) ||
       settings_->force_blending_with_shaders;
 
   if (params->use_shaders_for_blending) {
-    DCHECK(params->frame);
     // Compute a bounding box around the pixels that will be visible through
     // the quad.
     gfx::Rect unclipped_rect;
     params->background_rect = GetBackdropBoundingBoxForRenderPassQuad(
-        params->frame, quad, params->contents_device_transform, params->filters,
+        quad, params->contents_device_transform, params->filters,
         params->background_filters, params->clip_region, params->use_aa,
         &unclipped_rect);
 
     if (!params->background_rect.IsEmpty()) {
       // The pixels from the filtered background should completely replace the
       // current pixel values.
       if (blend_enabled())
         SetBlendEnabled(false);
 
       // Read the pixels in the bounding box into a buffer R.
       // This function allocates a texture, which should contribute to the
       // amount of memory used by render surfaces:
       // LayerTreeHost::CalculateMemoryForRenderSurfaces.
-      params->background_texture =
-          GetBackdropTexture(params->frame, params->background_rect);
+      params->background_texture = GetBackdropTexture(params->background_rect);
 
       if (ShouldApplyBackgroundFilters(quad, params->background_filters) &&
           params->background_texture) {
         // Apply the background filters to R, so that it is applied in the
         // pixels' coordinate space.
         params->background_image = ApplyBackgroundFilters(
             quad, *params->background_filters, params->background_texture.get(),
             gfx::RectF(params->background_rect), gfx::RectF(unclipped_rect));
         if (params->background_image) {
           params->background_image_id =
@@ skipping 537 matching lines @@
     device_quad = GetDeviceQuadWithAntialiasingOnExteriorEdges(
         device_layer_edges, device_transform, tile_quad, local_clip_region,
         quad);
   } else {
     device_quad = device_layer_edges.ToQuadF();
   }
 
   *local_quad = MapQuadToLocalSpace(device_transform, device_quad);
 }
 
-void GLRenderer::DrawSolidColorQuad(const DrawingFrame* frame,
-                                    const SolidColorDrawQuad* quad,
+void GLRenderer::DrawSolidColorQuad(const SolidColorDrawQuad* quad,
                                     const gfx::QuadF* clip_region) {
   gfx::Rect tile_rect = quad->visible_rect;
 
   SkColor color = quad->color;
   float opacity = quad->shared_quad_state->opacity;
   float alpha = (SkColorGetA(color) * (1.0f / 255.0f)) * opacity;
 
   // Early out if alpha is small enough that quad doesn't contribute to output.
   if (alpha < std::numeric_limits<float>::epsilon() &&
       quad->ShouldDrawWithBlending())
     return;
 
   gfx::Transform device_transform =
-      frame->window_matrix * frame->projection_matrix *
+      current_frame()->window_matrix * current_frame()->projection_matrix *
       quad->shared_quad_state->quad_to_target_transform;
   device_transform.FlattenTo2d();
   if (!device_transform.IsInvertible())
     return;
 
   auto local_quad = gfx::QuadF(gfx::RectF(tile_rect));
 
   gfx::QuadF device_layer_quad;
   bool use_aa = false;
   bool allow_aa = settings_->allow_antialiasing &&
@@ skipping 37 matching lines @@
     SetShaderQuadF(local_quad);
 
     // The transform and vertex data are used to figure out the extents that the
     // un-antialiased quad should have and which vertex this is and the float
     // quad passed in via uniform is the actual geometry that gets used to draw
     // it. This is why this centered rect is used and not the original
     // quad_rect.
     gfx::RectF centered_rect(
         gfx::PointF(-0.5f * tile_rect.width(), -0.5f * tile_rect.height()),
         gfx::SizeF(tile_rect.size()));
-    DrawQuadGeometry(frame->projection_matrix,
+    DrawQuadGeometry(current_frame()->projection_matrix,
                      quad->shared_quad_state->quad_to_target_transform,
                      centered_rect);
   } else {
     PrepareGeometry(SHARED_BINDING);
     SetShaderQuadF(local_quad);
-    SetShaderMatrix(frame->projection_matrix *
+    SetShaderMatrix(current_frame()->projection_matrix *
                     quad->shared_quad_state->quad_to_target_transform);
     gl_->DrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0);
   }
 }
 
-void GLRenderer::DrawTileQuad(const DrawingFrame* frame,
-                              const TileDrawQuad* quad,
+void GLRenderer::DrawTileQuad(const TileDrawQuad* quad,
                               const gfx::QuadF* clip_region) {
-  DrawContentQuad(frame, quad, quad->resource_id(), clip_region);
+  DrawContentQuad(quad, quad->resource_id(), clip_region);
 }
 
-void GLRenderer::DrawContentQuad(const DrawingFrame* frame,
-                                 const ContentDrawQuadBase* quad,
+void GLRenderer::DrawContentQuad(const ContentDrawQuadBase* quad,
                                  ResourceId resource_id,
                                  const gfx::QuadF* clip_region) {
   gfx::Transform device_transform =
-      frame->window_matrix * frame->projection_matrix *
+      current_frame()->window_matrix * current_frame()->projection_matrix *
       quad->shared_quad_state->quad_to_target_transform;
   device_transform.FlattenTo2d();
 
   gfx::QuadF device_layer_quad;
   bool use_aa = false;
   bool allow_aa = settings_->allow_antialiasing && quad->IsEdge();
   if (allow_aa) {
     bool clipped = false;
     bool force_aa = false;
     device_layer_quad = MathUtil::MapQuad(
         device_transform,
         gfx::QuadF(
             gfx::RectF(quad->shared_quad_state->visible_quad_layer_rect)),
         &clipped);
     use_aa = ShouldAntialiasQuad(device_layer_quad, clipped, force_aa);
   }
 
   // TODO(timav): simplify coordinate transformations in DrawContentQuadAA
   // similar to the way DrawContentQuadNoAA works and then consider
   // combining DrawContentQuadAA and DrawContentQuadNoAA into one method.
   if (use_aa)
-    DrawContentQuadAA(frame, quad, resource_id, device_transform,
-                      device_layer_quad, clip_region);
+    DrawContentQuadAA(quad, resource_id, device_transform, device_layer_quad,
+                      clip_region);
   else
-    DrawContentQuadNoAA(frame, quad, resource_id, clip_region);
+    DrawContentQuadNoAA(quad, resource_id, clip_region);
 }
 
-void GLRenderer::DrawContentQuadAA(const DrawingFrame* frame,
-                                   const ContentDrawQuadBase* quad,
+void GLRenderer::DrawContentQuadAA(const ContentDrawQuadBase* quad,
                                    ResourceId resource_id,
                                    const gfx::Transform& device_transform,
                                    const gfx::QuadF& aa_quad,
                                    const gfx::QuadF* clip_region) {
   if (!device_transform.IsInvertible())
     return;
 
   gfx::Rect tile_rect = quad->visible_rect;
 
   gfx::RectF tex_coord_rect = MathUtil::ScaleRectProportional(
@@ skipping 82 matching lines @@
   SetShaderOpacity(quad);
   SetShaderQuadF(local_quad);
 
   // The transform and vertex data are used to figure out the extents that the
   // un-antialiased quad should have and which vertex this is and the float
   // quad passed in via uniform is the actual geometry that gets used to draw
   // it. This is why this centered rect is used and not the original quad_rect.
   gfx::RectF centered_rect(
       gfx::PointF(-0.5f * tile_rect.width(), -0.5f * tile_rect.height()),
       gfx::SizeF(tile_rect.size()));
-  DrawQuadGeometry(frame->projection_matrix,
+  DrawQuadGeometry(current_frame()->projection_matrix,
                    quad->shared_quad_state->quad_to_target_transform,
                    centered_rect);
 }
 
-void GLRenderer::DrawContentQuadNoAA(const DrawingFrame* frame,
-                                     const ContentDrawQuadBase* quad,
+void GLRenderer::DrawContentQuadNoAA(const ContentDrawQuadBase* quad,
                                      ResourceId resource_id,
                                      const gfx::QuadF* clip_region) {
   gfx::RectF tex_coord_rect = MathUtil::ScaleRectProportional(
       quad->tex_coord_rect, gfx::RectF(quad->rect),
       gfx::RectF(quad->visible_rect));
   float tex_to_geom_scale_x = quad->rect.width() / quad->tex_coord_rect.width();
   float tex_to_geom_scale_y =
       quad->rect.height() / quad->tex_coord_rect.height();
 
   bool scaled = (tex_to_geom_scale_x != 1.f || tex_to_geom_scale_y != 1.f);
@@ skipping 68 matching lines @@
   } else {
     PrepareGeometry(SHARED_BINDING);
   }
   float gl_quad[8] = {
       tile_quad.p4().x(), tile_quad.p4().y(), tile_quad.p1().x(),
       tile_quad.p1().y(), tile_quad.p2().x(), tile_quad.p2().y(),
       tile_quad.p3().x(), tile_quad.p3().y(),
   };
   gl_->Uniform2fv(program->quad_location(), 4, gl_quad);
 
-  SetShaderMatrix(frame->projection_matrix *
+  SetShaderMatrix(current_frame()->projection_matrix *
                   quad->shared_quad_state->quad_to_target_transform);
 
   gl_->DrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0);
 }
 
 // TODO(ccameron): This has been replicated in ui/gfx/color_transform.cc. Delete
 // one of the instances.
 void ComputeYUVToRGBMatrices(YUVVideoDrawQuad::ColorSpace color_space,
                              uint32_t bits_per_channel,
                              float resource_multiplier,
@@ skipping 42 matching lines @@
     SkMatrix44 rgb_to_yuv;
     gfx_color_space.GetTransferMatrix(&rgb_to_yuv);
     SkMatrix44 yuv_to_rgb;
     rgb_to_yuv.invert(&yuv_to_rgb);
     full_transform.postConcat(yuv_to_rgb);
   }
 
   full_transform.asColMajorf(yuv_to_rgb_matrix);
 }
 
-void GLRenderer::DrawYUVVideoQuad(const DrawingFrame* frame,
-                                  const YUVVideoDrawQuad* quad,
+void GLRenderer::DrawYUVVideoQuad(const YUVVideoDrawQuad* quad,
                                   const gfx::QuadF* clip_region) {
   SetBlendEnabled(quad->ShouldDrawWithBlending());
 
   TexCoordPrecision tex_coord_precision = TexCoordPrecisionRequired(
       gl_, &highp_threshold_cache_, highp_threshold_min_,
       quad->shared_quad_state->visible_quad_layer_rect.bottom_right());
   YUVAlphaTextureMode alpha_texture_mode = quad->a_plane_resource_id()
                                                ? YUV_HAS_ALPHA_TEXTURE
                                                : YUV_NO_ALPHA_TEXTURE;
   UVTextureMode uv_texture_mode =
@@ skipping 91 matching lines @@
   if (uv_texture_mode == UV_TEXTURE_MODE_UV) {
     gl_->Uniform1i(program->uv_texture_location(), 2);
   } else {
     gl_->Uniform1i(program->u_texture_location(), 2);
     gl_->Uniform1i(program->v_texture_location(), 3);
   }
   if (alpha_texture_mode == YUV_HAS_ALPHA_TEXTURE)
     gl_->Uniform1i(program->a_texture_location(), 4);
 
   if (color_conversion_mode == COLOR_CONVERSION_MODE_LUT) {
-    ColorLUTCache::LUT lut = color_lut_cache_.GetLUT(quad->video_color_space,
-                                                     frame->device_color_space);
+    ColorLUTCache::LUT lut = color_lut_cache_.GetLUT(
+        quad->video_color_space, current_frame()->device_color_space);
     gl_->ActiveTexture(GL_TEXTURE5);
     gl_->BindTexture(GL_TEXTURE_2D, lut.texture);
     gl_->Uniform1i(program->lut_texture_location(), 5);
     gl_->Uniform1f(program->lut_size_location(), lut.size);
     gl_->ActiveTexture(GL_TEXTURE0);
   }
   DCHECK_NE(program->yuv_and_resource_matrix_location(), -1);
   float yuv_to_rgb_matrix[16] = {0};
   ComputeYUVToRGBMatrices(quad->color_space, quad->bits_per_channel,
                           quad->resource_multiplier, quad->resource_offset,
                           color_conversion_mode, yuv_to_rgb_matrix);
   gl_->UniformMatrix4fv(program->yuv_and_resource_matrix_location(), 1, 0,
                         yuv_to_rgb_matrix);
 
   // The transform and vertex data are used to figure out the extents that the
   // un-antialiased quad should have and which vertex this is and the float
   // quad passed in via uniform is the actual geometry that gets used to draw
   // it. This is why this centered rect is used and not the original quad_rect.
   auto tile_rect = gfx::RectF(quad->rect);
 
   SetShaderOpacity(quad);
   if (!clip_region) {
-    DrawQuadGeometry(frame->projection_matrix,
+    DrawQuadGeometry(current_frame()->projection_matrix,
                      quad->shared_quad_state->quad_to_target_transform,
                      tile_rect);
   } else {
     float uvs[8] = {0};
     GetScaledUVs(quad->visible_rect, clip_region, uvs);
     gfx::QuadF region_quad = *clip_region;
     region_quad.Scale(1.0f / tile_rect.width(), 1.0f / tile_rect.height());
     region_quad -= gfx::Vector2dF(0.5f, 0.5f);
     DrawQuadGeometryClippedByQuadF(
-        frame, quad->shared_quad_state->quad_to_target_transform, tile_rect,
+        quad->shared_quad_state->quad_to_target_transform, tile_rect,
         region_quad, uvs);
   }
 }
 
-void GLRenderer::DrawStreamVideoQuad(const DrawingFrame* frame,
-                                     const StreamVideoDrawQuad* quad,
+void GLRenderer::DrawStreamVideoQuad(const StreamVideoDrawQuad* quad,
                                      const gfx::QuadF* clip_region) {
   SetBlendEnabled(quad->ShouldDrawWithBlending());
 
   DCHECK(output_surface_->context_provider()
              ->ContextCapabilities()
              .egl_image_external);
 
   TexCoordPrecision tex_coord_precision = TexCoordPrecisionRequired(
       gl_, &highp_threshold_cache_, highp_threshold_min_,
       quad->shared_quad_state->visible_quad_layer_rect.bottom_right());
 
   const Program* program =
       GetProgram(ProgramKey::VideoStream(tex_coord_precision));
   SetUseProgram(program);
 
   ResourceProvider::ScopedReadLockGL lock(resource_provider_,
                                           quad->resource_id());
 
   DCHECK_EQ(GL_TEXTURE0, GetActiveTextureUnit(gl_));
   gl_->BindTexture(GL_TEXTURE_EXTERNAL_OES, lock.texture_id());
 
   static float gl_matrix[16];
   ToGLMatrix(&gl_matrix[0], quad->matrix);
   gl_->UniformMatrix4fvStreamTextureMatrixCHROMIUM(
       program->tex_matrix_location(), false, gl_matrix);
 
   SetShaderOpacity(quad);
   if (!clip_region) {
-    DrawQuadGeometry(frame->projection_matrix,
+    DrawQuadGeometry(current_frame()->projection_matrix,
                      quad->shared_quad_state->quad_to_target_transform,
                      gfx::RectF(quad->rect));
   } else {
     gfx::QuadF region_quad(*clip_region);
     region_quad.Scale(1.0f / quad->rect.width(), 1.0f / quad->rect.height());
     region_quad -= gfx::Vector2dF(0.5f, 0.5f);
     float uvs[8] = {0};
     GetScaledUVs(quad->visible_rect, clip_region, uvs);
     DrawQuadGeometryClippedByQuadF(
-        frame, quad->shared_quad_state->quad_to_target_transform,
+        quad->shared_quad_state->quad_to_target_transform,
         gfx::RectF(quad->rect), region_quad, uvs);
   }
 }
 
 void GLRenderer::FlushTextureQuadCache(BoundGeometry flush_binding) {
   // Check to see if we have anything to draw.
   if (!draw_cache_.program)
     return;
 
   PrepareGeometry(flush_binding);
@@ skipping 76 matching lines @@
   draw_cache_.vertex_opacity_data.resize(0);
   draw_cache_.matrix_data.resize(0);
 
   // If we had a clipped binding, prepare the shared binding for the
   // next inserts.
   if (flush_binding == CLIPPED_BINDING) {
     PrepareGeometry(SHARED_BINDING);
   }
 }
 
-void GLRenderer::EnqueueTextureQuad(const DrawingFrame* frame,
-                                    const TextureDrawQuad* quad,
+void GLRenderer::EnqueueTextureQuad(const TextureDrawQuad* quad,
                                     const gfx::QuadF* clip_region) {
   // If we have a clip_region then we have to render the next quad
   // with dynamic geometry, therefore we must flush all pending
   // texture quads.
   if (clip_region) {
     // We send in false here because we want to flush what's currently in the
     // queue using the shared_geometry and not clipped_geometry
     FlushTextureQuadCache(SHARED_BINDING);
   }
 
@@ skipping 45 matching lines @@
   draw_cache_.vertex_opacity_data.push_back(quad->vertex_opacity[0] * opacity);
   draw_cache_.vertex_opacity_data.push_back(quad->vertex_opacity[1] * opacity);
   draw_cache_.vertex_opacity_data.push_back(quad->vertex_opacity[2] * opacity);
   draw_cache_.vertex_opacity_data.push_back(quad->vertex_opacity[3] * opacity);
 
   // Generate the transform matrix
   gfx::Transform quad_rect_matrix;
   QuadRectTransform(&quad_rect_matrix,
                     quad->shared_quad_state->quad_to_target_transform,
                     gfx::RectF(quad->rect));
-  quad_rect_matrix = frame->projection_matrix * quad_rect_matrix;
+  quad_rect_matrix = current_frame()->projection_matrix * quad_rect_matrix;
 
   Float16 m;
   quad_rect_matrix.matrix().asColMajorf(m.data);
   draw_cache_.matrix_data.push_back(m);
 
   if (clip_region) {
     gfx::QuadF scaled_region;
     if (!GetScaledRegion(quad->rect, clip_region, &scaled_region)) {
       scaled_region = SharedGeometryQuad().BoundingBox();
     }
     // Both the scaled region and the SharedGeomtryQuad are in the space
     // -0.5->0.5. We need to move that to the space 0->1.
     float uv[8];
     uv[0] = scaled_region.p1().x() + 0.5f;
     uv[1] = scaled_region.p1().y() + 0.5f;
     uv[2] = scaled_region.p2().x() + 0.5f;
     uv[3] = scaled_region.p2().y() + 0.5f;
     uv[4] = scaled_region.p3().x() + 0.5f;
     uv[5] = scaled_region.p3().y() + 0.5f;
     uv[6] = scaled_region.p4().x() + 0.5f;
     uv[7] = scaled_region.p4().y() + 0.5f;
     PrepareGeometry(CLIPPED_BINDING);
     clipped_geometry_->InitializeCustomQuadWithUVs(scaled_region, uv);
     FlushTextureQuadCache(CLIPPED_BINDING);
   } else if (gl_composited_texture_quad_border_) {
     FlushTextureQuadCache(SHARED_BINDING);
   }
 }
 
-void GLRenderer::FinishDrawingFrame(DrawingFrame* frame) {
+void GLRenderer::FinishDrawingFrame() {
   if (use_sync_query_) {
     DCHECK(current_sync_query_);
     current_sync_query_->End();
     pending_sync_queries_.push_back(std::move(current_sync_query_));
   }
 
-  swap_buffer_rect_.Union(frame->root_damage_rect);
+  swap_buffer_rect_.Union(current_frame()->root_damage_rect);
   if (overdraw_feedback_)
-    FlushOverdrawFeedback(frame, swap_buffer_rect_);
+    FlushOverdrawFeedback(swap_buffer_rect_);
 
   current_framebuffer_lock_ = nullptr;
 
   gl_->Disable(GL_BLEND);
   blend_shadow_ = false;
 
-  ScheduleCALayers(frame);
-  ScheduleOverlays(frame);
+  ScheduleCALayers();
+  ScheduleOverlays();
 }
 
 void GLRenderer::FinishDrawingQuadList() {
   FlushTextureQuadCache(SHARED_BINDING);
 }
 
-bool GLRenderer::FlippedFramebuffer(const DrawingFrame* frame) const {
+bool GLRenderer::FlippedFramebuffer() const {
   if (force_drawing_frame_framebuffer_unflipped_)
     return false;
-  if (frame->current_render_pass != frame->root_render_pass)
+  if (current_frame()->current_render_pass != current_frame()->root_render_pass)
     return true;
   return FlippedRootFramebuffer();
 }
 
 bool GLRenderer::FlippedRootFramebuffer() const {
   // GL is normally flipped, so a flipped output results in an unflipping.
   return !output_surface_->capabilities().flipped_output_surface;
 }
 
 void GLRenderer::EnsureScissorTestEnabled() {
   if (is_scissor_enabled_)
     return;
 
   FlushTextureQuadCache(SHARED_BINDING);
   gl_->Enable(GL_SCISSOR_TEST);
   is_scissor_enabled_ = true;
 }
 
 void GLRenderer::EnsureScissorTestDisabled() {
   if (!is_scissor_enabled_)
     return;
 
   FlushTextureQuadCache(SHARED_BINDING);
   gl_->Disable(GL_SCISSOR_TEST);
   is_scissor_enabled_ = false;
 }
 
 void GLRenderer::CopyCurrentRenderPassToBitmap(
-    DrawingFrame* frame,
     std::unique_ptr<CopyOutputRequest> request) {
   TRACE_EVENT0("cc", "GLRenderer::CopyCurrentRenderPassToBitmap");
-  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());
-  GetFramebufferPixelsAsync(frame, copy_rect, std::move(request));
+  GetFramebufferPixelsAsync(copy_rect, std::move(request));
 }
 
 void GLRenderer::ToGLMatrix(float* gl_matrix, const gfx::Transform& transform) {
   transform.matrix().asColMajorf(gl_matrix);
 }
 
 void GLRenderer::SetShaderQuadF(const gfx::QuadF& quad) {
   if (!program_shadow_ || program_shadow_->quad_location() == -1)
     return;
   float gl_quad[8];
@@ skipping 69 matching lines @@
         static_cast<float>(current_window_space_viewport_.y()),
         static_cast<float>(current_window_space_viewport_.width()),
         static_cast<float>(current_window_space_viewport_.height()),
     };
     gl_->Uniform4fv(program->viewport_location(), 1, viewport);
   }
   program_shadow_ = program;
 }
 
 void GLRenderer::DrawQuadGeometryClippedByQuadF(
-    const DrawingFrame* frame,
     const gfx::Transform& draw_transform,
     const gfx::RectF& quad_rect,
     const gfx::QuadF& clipping_region_quad,
     const float* uvs) {
   PrepareGeometry(CLIPPED_BINDING);
   if (uvs) {
     clipped_geometry_->InitializeCustomQuadWithUVs(clipping_region_quad, uvs);
   } else {
     clipped_geometry_->InitializeCustomQuad(clipping_region_quad);
   }
   gfx::Transform quad_rect_matrix;
   QuadRectTransform(&quad_rect_matrix, draw_transform, quad_rect);
-  SetShaderMatrix(frame->projection_matrix * quad_rect_matrix);
+  SetShaderMatrix(current_frame()->projection_matrix * quad_rect_matrix);
 
   gl_->DrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT,
                     reinterpret_cast<const void*>(0));
 }
 
 void GLRenderer::DrawQuadGeometry(const gfx::Transform& projection_matrix,
                                   const gfx::Transform& draw_transform,
                                   const gfx::RectF& quad_rect) {
   PrepareGeometry(SHARED_BINDING);
   gfx::Transform quad_rect_matrix;
@@ skipping 80 matching lines @@
   DCHECK(settings_->release_overlay_resources_after_gpu_query);
   for (const gpu::TextureInUseResponse& response : responses) {
     if (!response.in_use) {
       swapped_and_acked_overlay_resources_.erase(response.texture);
     }
   }
   color_lut_cache_.Swap();
 }
 
 void GLRenderer::GetFramebufferPixelsAsync(
-    const DrawingFrame* frame,
     const gfx::Rect& rect,
     std::unique_ptr<CopyOutputRequest> request) {
   DCHECK(!request->IsEmpty());
   if (request->IsEmpty())
     return;
   if (rect.IsEmpty())
     return;
 
   if (overdraw_feedback_)
-    FlushOverdrawFeedback(frame, rect);
+    FlushOverdrawFeedback(rect);
 
-  gfx::Rect window_rect = MoveFromDrawToWindowSpace(frame, rect);
+  gfx::Rect window_rect = MoveFromDrawToWindowSpace(rect);
   DCHECK_GE(window_rect.x(), 0);
   DCHECK_GE(window_rect.y(), 0);
   DCHECK_LE(window_rect.right(), current_surface_size_.width());
   DCHECK_LE(window_rect.bottom(), current_surface_size_.height());
 
   if (!request->force_bitmap_result()) {
     bool own_mailbox = !request->has_texture_mailbox();
 
     GLuint texture_id = 0;
     gpu::Mailbox mailbox;
@@ skipping 166 matching lines @@
          format == GL_LUMINANCE_ALPHA || format == GL_RGB || format == GL_RGBA)
       << format;
 
   gl_->BindTexture(GL_TEXTURE_2D, texture_id);
   gl_->CopyTexImage2D(GL_TEXTURE_2D, 0, format, window_rect.x(),
                       window_rect.y(), window_rect.width(),
                       window_rect.height(), 0);
   gl_->BindTexture(GL_TEXTURE_2D, 0);
 }
 
-void GLRenderer::BindFramebufferToOutputSurface(DrawingFrame* frame) {
+void GLRenderer::BindFramebufferToOutputSurface() {
   current_framebuffer_lock_ = nullptr;
   output_surface_->BindFramebuffer();
 
   if (overdraw_feedback_) {
     // Output surfaces that require an external stencil test should not allow
     // overdraw feedback by setting |supports_stencil| to false.
     DCHECK(!output_surface_->HasExternalStencilTest());
     SetupOverdrawFeedback();
     SetStencilEnabled(true);
   } else if (output_surface_->HasExternalStencilTest()) {
     output_surface_->ApplyExternalStencil();
     SetStencilEnabled(true);
   } else {
     SetStencilEnabled(false);
   }
 }
 
-bool GLRenderer::BindFramebufferToTexture(DrawingFrame* frame,
-                                          const ScopedResource* texture) {
+bool GLRenderer::BindFramebufferToTexture(const ScopedResource* texture) {
   DCHECK(texture->id());
 
   // Explicitly release lock, otherwise we can crash when try to lock
   // same texture again.
   current_framebuffer_lock_ = nullptr;
 
   gl_->BindFramebuffer(GL_FRAMEBUFFER, offscreen_framebuffer_id_);
   current_framebuffer_lock_ =
       base::MakeUnique<ResourceProvider::ScopedWriteLockGL>(
           resource_provider_, texture->id(), false);
@@ skipping 154 matching lines @@
     gl_->Disable(GL_SCISSOR_TEST);
 
   gl_->Scissor(scissor_rect_.x(), scissor_rect_.y(), scissor_rect_.width(),
                scissor_rect_.height());
 }
 
 bool GLRenderer::IsContextLost() {
   return gl_->GetGraphicsResetStatusKHR() != GL_NO_ERROR;
 }
 
-void GLRenderer::ScheduleCALayers(DrawingFrame* frame) {
+void GLRenderer::ScheduleCALayers() {
   if (overlay_resource_pool_) {
     overlay_resource_pool_->CheckBusyResources();
   }
 
   scoped_refptr<CALayerOverlaySharedState> shared_state;
   size_t copied_render_pass_count = 0;
-  for (const CALayerOverlay& ca_layer_overlay : frame->ca_layer_overlay_list) {
+  for (const CALayerOverlay& ca_layer_overlay :
+       current_frame()->ca_layer_overlay_list) {
     if (ca_layer_overlay.rpdq) {
-      ScheduleRenderPassDrawQuad(&ca_layer_overlay, frame);
+      ScheduleRenderPassDrawQuad(&ca_layer_overlay);
       shared_state = nullptr;
       ++copied_render_pass_count;
       continue;
     }
 
     ResourceId contents_resource_id = ca_layer_overlay.contents_resource_id;
     unsigned texture_id = 0;
     if (contents_resource_id) {
       pending_overlay_resources_.push_back(
           base::MakeUnique<ResourceProvider::ScopedReadLockGL>(
@@ skipping 33 matching lines @@
   }
 
   // Take the number of copied render passes in this frame, and use 3 times that
   // amount as the cache limit.
   if (overlay_resource_pool_) {
     overlay_resource_pool_->SetResourceUsageLimits(
         std::numeric_limits<std::size_t>::max(), copied_render_pass_count * 5);
   }
 }
 
-void GLRenderer::ScheduleOverlays(DrawingFrame* frame) {
-  if (frame->overlay_list.empty())
+void GLRenderer::ScheduleOverlays() {
+  if (current_frame()->overlay_list.empty())
     return;
 
-  OverlayCandidateList& overlays = frame->overlay_list;
+  OverlayCandidateList& overlays = current_frame()->overlay_list;
   for (const OverlayCandidate& overlay : overlays) {
     unsigned texture_id = 0;
     if (overlay.use_output_surface_for_resource) {
       texture_id = output_surface_->GetOverlayTextureId();
       DCHECK(texture_id || IsContextLost());
     } else {
       pending_overlay_resources_.push_back(
           base::MakeUnique<ResourceProvider::ScopedReadLockGL>(
               resource_provider_, overlay.resource_id));
       texture_id = pending_overlay_resources_.back()->texture_id();
@@ skipping 16 matching lines @@
 //   screen. This reuses most of the RPDQ draw logic.
 //   2. Update parameters to draw into a framebuffer only as large as needed.
 //   3. Fix shader uniforms that were broken by (2).
 //
 // Then:
 //   4. Allocate an IOSurface as the drawing destination.
 //   5. Draw the RPDQ.
 void GLRenderer::CopyRenderPassDrawQuadToOverlayResource(
     const CALayerOverlay* ca_layer_overlay,
     Resource** resource,
-    DrawingFrame* external_frame,
     gfx::RectF* new_bounds) {
   // Don't carry over any GL state from previous RenderPass draw operations.
   ReinitializeGLState();
 
   ScopedResource* contents_texture =
       render_pass_textures_[ca_layer_overlay->rpdq->render_pass_id].get();
   DCHECK(contents_texture);
 
   // Configure parameters as if drawing to a framebuffer the size of the
   // screen.
   DrawRenderPassDrawQuadParams params;
   params.quad = ca_layer_overlay->rpdq;
   params.flip_texture = true;
   params.contents_texture = contents_texture;
   params.quad_to_target_transform =
       params.quad->shared_quad_state->quad_to_target_transform;
 
   // Calculate projection and window matrices using InitializeViewport(). This
   // requires creating a dummy DrawingFrame.
   {
-    DrawingFrame frame;
-    gfx::Rect frame_rect(external_frame->device_viewport_size);
+    DrawingFrame dummy_frame;
+    gfx::Rect frame_rect(current_frame()->device_viewport_size);
     force_drawing_frame_framebuffer_unflipped_ = true;
-    InitializeViewport(&frame, frame_rect, frame_rect, frame_rect.size());
+    InitializeViewport(&dummy_frame, frame_rect, frame_rect, frame_rect.size());
     force_drawing_frame_framebuffer_unflipped_ = false;
-    params.projection_matrix = frame.projection_matrix;
-    params.window_matrix = frame.window_matrix;
+    params.projection_matrix = dummy_frame.projection_matrix;
+    params.window_matrix = dummy_frame.window_matrix;
   }
 
   // Perform basic initialization with the screen-sized viewport.
   if (!InitializeRPDQParameters(&params))
     return;
 
   if (!UpdateRPDQWithSkiaFilters(&params))
     return;
 
   // |params.dst_rect| now contain values that reflect a potentially increased
   // size quad.
   gfx::RectF updated_dst_rect = params.dst_rect;
 
   // Round the size of the IOSurface to a multiple of 64 pixels. This reduces
   // memory fragmentation. https://crbug.com/146070. This also allows IOSurfaces
   // to be more easily reused during a resize operation.
   uint32_t iosurface_multiple = 64;
   uint32_t iosurface_width = MathUtil::UncheckedRoundUp(
       static_cast<uint32_t>(updated_dst_rect.width()), iosurface_multiple);
   uint32_t iosurface_height = MathUtil::UncheckedRoundUp(
       static_cast<uint32_t>(updated_dst_rect.height()), iosurface_multiple);
 
   *resource = overlay_resource_pool_->AcquireResource(
       gfx::Size(iosurface_width, iosurface_height), ResourceFormat::RGBA_8888,
-      external_frame->device_color_space);
+      current_frame()->device_color_space);
   *new_bounds =
       gfx::RectF(updated_dst_rect.x(), updated_dst_rect.y(),
                  (*resource)->size().width(), (*resource)->size().height());
 
   // Calculate new projection and window matrices for a minimally sized viewport
   // using InitializeViewport(). This requires creating a dummy DrawingFrame.
   {
-    DrawingFrame frame;
+    DrawingFrame dummy_frame;
     force_drawing_frame_framebuffer_unflipped_ = true;
     gfx::Rect frame_rect =
         gfx::Rect(0, 0, updated_dst_rect.width(), updated_dst_rect.height());
-    InitializeViewport(&frame, frame_rect, frame_rect, frame_rect.size());
+    InitializeViewport(&dummy_frame, frame_rect, frame_rect, frame_rect.size());
     force_drawing_frame_framebuffer_unflipped_ = false;
-    params.projection_matrix = frame.projection_matrix;
-    params.window_matrix = frame.window_matrix;
+    params.projection_matrix = dummy_frame.projection_matrix;
+    params.window_matrix = dummy_frame.window_matrix;
   }
 
   // Calculate a new quad_to_target_transform.
   params.quad_to_target_transform = gfx::Transform();
   params.quad_to_target_transform.Translate(-updated_dst_rect.x(),
                                             -updated_dst_rect.y());
 
   // Antialiasing works by fading out content that is close to the edge of the
   // viewport. All of these values need to be recalculated.
   if (params.use_aa) {
@@ skipping 36 matching lines @@
 
   // Prior to drawing, set up the destination framebuffer and viewport.
   gl_->BindFramebuffer(GL_FRAMEBUFFER, temp_fbo);
   gl_->Viewport(0, 0, updated_dst_rect.width(), updated_dst_rect.height());
 
   DrawRPDQ(params);
   gl_->DeleteFramebuffers(1, &temp_fbo);
 }
 
 void GLRenderer::ScheduleRenderPassDrawQuad(
-    const CALayerOverlay* ca_layer_overlay,
-    DrawingFrame* external_frame) {
+    const CALayerOverlay* ca_layer_overlay) {
   DCHECK(ca_layer_overlay->rpdq);
 
   if (!overlay_resource_pool_) {
     overlay_resource_pool_ = ResourcePool::CreateForGpuMemoryBufferResources(
         resource_provider_, base::ThreadTaskRunnerHandle::Get().get(),
         gfx::BufferUsage::SCANOUT, base::TimeDelta::FromSeconds(3));
   }
 
   Resource* resource = nullptr;
   gfx::RectF new_bounds;
   CopyRenderPassDrawQuadToOverlayResource(ca_layer_overlay, &resource,
-                                          external_frame, &new_bounds);
+                                          &new_bounds);
   if (!resource || !resource->id())
     return;
 
   pending_overlay_resources_.push_back(
       base::MakeUnique<ResourceProvider::ScopedReadLockGL>(resource_provider_,
                                                            resource->id()));
   unsigned texture_id = pending_overlay_resources_.back()->texture_id();
 
   // Once a resource is released, it is marked as "busy". It will be
   // available for reuse after the ScopedReadLockGL is destroyed.
@@ skipping 27 matching lines @@
       ca_layer_overlay->edge_aa_mask, bounds_rect, filter);
 }
 
 void GLRenderer::SetupOverdrawFeedback() {
   gl_->StencilFunc(GL_ALWAYS, 1, 0xffffffff);
   // First two values are ignored as test always passes.
   gl_->StencilOp(GL_KEEP, GL_KEEP, GL_INCR);
   gl_->StencilMask(0xffffffff);
 }
 
-void GLRenderer::FlushOverdrawFeedback(const DrawingFrame* frame,
-                                       const gfx::Rect& output_rect) {
+void GLRenderer::FlushOverdrawFeedback(const gfx::Rect& output_rect) {
   DCHECK(stencil_shadow_);
 
   // Test only, keep everything.
   gl_->StencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
 
   EnsureScissorTestDisabled();
   SetBlendEnabled(true);
 
   PrepareGeometry(SHARED_BINDING);
 
   const Program* program = GetProgram(ProgramKey::DebugBorder());
   SetUseProgram(program);
 
   gfx::Transform render_matrix;
   render_matrix.Translate(0.5 * output_rect.width() + output_rect.x(),
                           0.5 * output_rect.height() + output_rect.y());
   render_matrix.Scale(output_rect.width(), output_rect.height());
-  SetShaderMatrix(frame->projection_matrix * render_matrix);
+  SetShaderMatrix(current_frame()->projection_matrix * render_matrix);
 
   // Produce hinting for the amount of overdraw on screen for each pixel by
   // drawing hint colors to the framebuffer based on the current stencil value.
   struct {
     int multiplier;
     GLenum func;
     GLint ref;
     SkColor color;
   } stencil_tests[] = {
       {1, GL_EQUAL, 2, 0x2f0000ff},  // Blue: Overdrawn once.
       {2, GL_EQUAL, 3, 0x2f00ff00},  // Green: Overdrawn twice.
       {3, GL_EQUAL, 4, 0x3fff0000},  // Pink: Overdrawn three times.
       {4, GL_LESS, 4, 0x7fff0000},   // Red: Overdrawn four or more times.
   };
 
   // Occlusion queries can be expensive, so only collect trace data if we select
   // cc.debug.overdraw.
   bool tracing_enabled;
   TRACE_EVENT_CATEGORY_GROUP_ENABLED(
       TRACE_DISABLED_BY_DEFAULT("cc.debug.overdraw"), &tracing_enabled);
 
   // Trace only the root render pass.
-  if (frame->current_render_pass != frame->root_render_pass)
+  if (current_frame()->current_render_pass != current_frame()->root_render_pass)
     tracing_enabled = false;
 
   // ARB_occlusion_query is required for tracing.
   if (!use_occlusion_query_)
     tracing_enabled = false;
 
   // Use the current surface area as max result. The effect is that overdraw
   // is reported as a percentage of the output surface size. ie. 2x overdraw
   // for the whole screen is reported as 200.
   int max_result = current_surface_size_.GetArea();
@@ skipping 43 matching lines @@
     return;
 
   // Report GPU overdraw as a percentage of |max_result|.
   TRACE_COUNTER1(
       TRACE_DISABLED_BY_DEFAULT("cc.debug.overdraw"), "GPU Overdraw",
       (std::accumulate(overdraw->begin(), overdraw->end(), 0) * 100) /
           max_result);
 }
 
 }  // namespace cc