Remove references to DrawingFrame from RenderPassDrawQuad drawing.

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 138 matching lines @@
 // Block or crash if the number of pending sync queries reach this high as
 // something is seriously wrong on the service side if this happens.
 const size_t kMaxPendingSyncQueries = 16;
 }  // anonymous namespace
 
 // Parameters needed to draw a RenderPassDrawQuad.
 struct DrawRenderPassDrawQuadParams {
   DrawRenderPassDrawQuadParams() {}
   ~DrawRenderPassDrawQuadParams() {}
 
-  // Inputs.
+  // Required Inputs.
   const RenderPassDrawQuad* quad = nullptr;
   const Resource* contents_texture = nullptr;
-  DirectRenderer::DrawingFrame* frame = nullptr;
   const gfx::QuadF* clip_region = nullptr;
   bool flip_texture = false;
 
+  gfx::Transform window_matrix;
+  gfx::Transform projection_matrix;
+
+  // |frame| is needed 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;
   ShaderLocations locations;
 
@@ skipping 39 matching lines @@
 };
 
 static GLint GetActiveTextureUnit(GLES2Interface* gl) {
   GLint active_unit = 0;
   gl->GetIntegerv(GL_ACTIVE_TEXTURE, &active_unit);
   return active_unit;
 }
 
 class GLRenderer::ScopedUseGrContext {
  public:
-  static std::unique_ptr<ScopedUseGrContext> Create(GLRenderer* renderer,
-                                                    DrawingFrame* frame) {
+  static std::unique_ptr<ScopedUseGrContext> Create(GLRenderer* renderer) {
     // GrContext for filters is created lazily, and may fail if the context
     // is lost.
     // TODO(vmiura,bsalomon): crbug.com/487850 Ensure that
     // ContextProvider::GrContext() does not return NULL.
     if (renderer->output_surface_->context_provider()->GrContext())
-      return base::WrapUnique(new ScopedUseGrContext(renderer, frame));
+      return base::WrapUnique(new ScopedUseGrContext(renderer));
     return nullptr;
   }
 
   ~ScopedUseGrContext() {
     // Pass context control back to GLrenderer.
     scoped_gpu_raster_ = nullptr;
     renderer_->RestoreGLState();
-    renderer_->RestoreFramebuffer(frame_);
   }
 
   GrContext* context() const {
     return renderer_->output_surface_->context_provider()->GrContext();
   }
 
  private:
-  ScopedUseGrContext(GLRenderer* renderer, DrawingFrame* frame)
+  explicit ScopedUseGrContext(GLRenderer* renderer)
       : scoped_gpu_raster_(
             new ScopedGpuRaster(renderer->output_surface_->context_provider())),
-        renderer_(renderer),
-        frame_(frame) {
+        renderer_(renderer) {
     // scoped_gpu_raster_ passes context control to Skia.
   }
 
   std::unique_ptr<ScopedGpuRaster> scoped_gpu_raster_;
   GLRenderer* renderer_;
-  DrawingFrame* frame_;
 
   DISALLOW_COPY_AND_ASSIGN(ScopedUseGrContext);
 };
 
 struct GLRenderer::PendingAsyncReadPixels {
   PendingAsyncReadPixels() : buffer(0) {}
 
   std::unique_ptr<CopyOutputRequest> copy_request;
   base::CancelableClosure finished_read_pixels_callback;
   unsigned buffer;
@@ skipping 634 matching lines @@
       resource_provider_->best_texture_format());
   {
     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(
-    DrawingFrame* frame,
     const RenderPassDrawQuad* quad,
     ScopedResource* background_texture,
     const gfx::RectF& rect) {
   DCHECK(ShouldApplyBackgroundFilters(quad));
-  auto use_gr_context = ScopedUseGrContext::Create(this, frame);
+  auto use_gr_context = ScopedUseGrContext::Create(this);
   sk_sp<SkImageFilter> filter = RenderSurfaceFilters::BuildImageFilter(
       quad->background_filters, gfx::SizeF(background_texture->size()));
 
   // TODO(senorblanco): background filters should be moved to the
   // makeWithFilter fast-path, and go back to calling ApplyImageFilter().
   // See http://crbug.com/613233.
   if (!filter || !use_gr_context)
     return nullptr;
 
   ResourceProvider::ScopedReadLockGL lock(resource_provider_,
@@ skipping 103 matching lines @@
 }
 
 void GLRenderer::DrawRenderPassQuad(DrawingFrame* frame,
                                     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;
   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);
     // 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;
@@ skipping 11 matching lines @@
   }
 }
 
 void GLRenderer::DrawRenderPassQuadInternal(
     DrawRenderPassDrawQuadParams* params) {
   if (!InitializeRPDQParameters(params))
     return;
   UpdateRPDQShadersForBlending(params);
   if (!UpdateRPDQWithSkiaFilters(params))
     return;
+  UseRenderPass(params->frame, params->frame->current_render_pass);
+  SetViewport();
   UpdateRPDQTexturesForSampling(params);
   UpdateRPDQBlendMode(params);
   ChooseRPDQProgram(params);
   UpdateRPDQUniforms(params);
   DrawRPDQ(*params);
 }
 
 bool GLRenderer::InitializeRPDQParameters(
     DrawRenderPassDrawQuadParams* params) {
   const RenderPassDrawQuad* quad = params->quad;
   SkMatrix scale_matrix;
   scale_matrix.setScale(quad->filters_scale.x(), quad->filters_scale.y());
   gfx::Rect dst_rect = quad->filters.MapRect(quad->rect, scale_matrix);
   params->dst_rect.SetRect(static_cast<float>(dst_rect.x()),
                            static_cast<float>(dst_rect.y()),
                            static_cast<float>(dst_rect.width()),
                            static_cast<float>(dst_rect.height()));
   gfx::Transform quad_rect_matrix;
   QuadRectTransform(&quad_rect_matrix,
                     quad->shared_quad_state->quad_to_target_transform,
                     params->dst_rect);
-  params->contents_device_transform = params->frame->window_matrix *
-                                      params->frame->projection_matrix *
-                                      quad_rect_matrix;
+  params->contents_device_transform =
+      params->window_matrix * params->projection_matrix * quad_rect_matrix;
   params->contents_device_transform.FlattenTo2d();
 
   // Can only draw surface if device matrix is invertible.
   if (!params->contents_device_transform.IsInvertible())
     return false;
 
   params->surface_quad = SharedGeometryQuad();
 
   gfx::QuadF device_layer_quad;
   if (settings_->allow_antialiasing) {
@@ skipping 15 matching lines @@
 void GLRenderer::UpdateRPDQShadersForBlending(
     DrawRenderPassDrawQuadParams* params) {
   const RenderPassDrawQuad* quad = params->quad;
   SkXfermode::Mode blend_mode = quad->shared_quad_state->blend_mode;
   params->use_shaders_for_blending =
       !CanApplyBlendModeUsingBlendFunc(blend_mode) ||
       ShouldApplyBackgroundFilters(quad) ||
       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.
     params->background_rect = GetBackdropBoundingBoxForRenderPassQuad(
         params->frame, quad, params->contents_device_transform,
         params->clip_region, params->use_aa);
 
     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->background_rect);
 
       if (ShouldApplyBackgroundFilters(quad) && params->background_texture) {
         // Apply the background filters to R, so that it is applied in the
         // pixels' coordinate space.
-        params->background_image = ApplyBackgroundFilters(
-            params->frame, quad, params->background_texture.get(),
-            gfx::RectF(params->background_rect));
+        params->background_image =
+            ApplyBackgroundFilters(quad, params->background_texture.get(),
+                                   gfx::RectF(params->background_rect));
         if (params->background_image) {
           params->background_image_id =
               skia::GrBackendObjectToGrGLTextureInfo(
                   params->background_image->getTextureHandle(true))
                   ->fID;
           DCHECK(params->background_image_id);
         }
       }
     }
 
@@ skipping 53 matching lines @@
         params->dst_rect.Intersect(local_clip.BoundingBox());
         // If we've been fully clipped out (by crop rect or clipping), there's
         // nothing to draw.
         if (params->dst_rect.IsEmpty()) {
           return false;
         }
         SkIPoint offset;
         SkIRect subset;
         gfx::RectF src_rect(quad->rect);
         params->filter_image = ApplyImageFilter(
-            ScopedUseGrContext::Create(this, params->frame), resource_provider_,
-            src_rect, params->dst_rect, quad->filters_scale, std::move(filter),
+            ScopedUseGrContext::Create(this), resource_provider_, src_rect,
+            params->dst_rect, quad->filters_scale, std::move(filter),
             params->contents_texture, &offset, &subset, params->flip_texture);
         if (!params->filter_image)
           return false;
         params->dst_rect =
             gfx::RectF(src_rect.x() + offset.fX, src_rect.y() + offset.fY,
                        subset.width(), subset.height());
         params->src_offset.SetPoint(subset.x(), subset.y());
       }
     }
   }
@@ skipping 246 matching lines @@
       DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D),
                 params->shader_background_sampler_lock->target());
     }
   }
 
   SetShaderOpacity(params->quad->shared_quad_state->opacity, locations.alpha);
   SetShaderQuadF(params->surface_quad, locations.quad);
 }
 
 void GLRenderer::DrawRPDQ(const DrawRenderPassDrawQuadParams& params) {
-  DrawQuadGeometry(params.frame,
+  DrawQuadGeometry(params.projection_matrix,
                    params.quad->shared_quad_state->quad_to_target_transform,
                    params.dst_rect, params.locations.matrix);
 
   // Flush the compositor context before the filter bitmap goes out of
   // scope, so the draw gets processed before the filter texture gets deleted.
   if (params.filter_image)
     gl_->Flush();
 
   if (!params.use_shaders_for_blending)
     RestoreBlendFuncToDefault(params.quad->shared_quad_state->blend_mode);
@@ skipping 360 matching lines @@
     SetShaderQuadF(local_quad, uniforms.quad_location);
 
     // 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, quad->shared_quad_state->quad_to_target_transform,
+    DrawQuadGeometry(frame->projection_matrix,
+                     quad->shared_quad_state->quad_to_target_transform,
                      centered_rect, uniforms.matrix_location);
   } else {
     PrepareGeometry(SHARED_BINDING);
     SetShaderQuadF(local_quad, uniforms.quad_location);
     static float gl_matrix[16];
     ToGLMatrix(&gl_matrix[0],
                frame->projection_matrix *
                    quad->shared_quad_state->quad_to_target_transform);
     gl_->UniformMatrix4fv(uniforms.matrix_location, 1, false, &gl_matrix[0]);
 
@@ skipping 178 matching lines @@
   SetShaderOpacity(quad->shared_quad_state->opacity, uniforms.alpha_location);
   SetShaderQuadF(local_quad, uniforms.quad_location);
 
   // 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, quad->shared_quad_state->quad_to_target_transform,
+  DrawQuadGeometry(frame->projection_matrix,
+                   quad->shared_quad_state->quad_to_target_transform,
                    centered_rect, uniforms.matrix_location);
 }
 
 void GLRenderer::DrawContentQuadNoAA(const DrawingFrame* frame,
                                      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));
@@ skipping 297 matching lines @@
   // 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);
   gl_->UniformMatrix3fv(yuv_matrix_location, 1, 0, yuv_to_rgb_multiplied);
   gl_->Uniform3fv(yuv_adj_location, 1, yuv_adjust_with_offset);
 
   SetShaderOpacity(quad->shared_quad_state->opacity, alpha_location);
   if (!clip_region) {
-    DrawQuadGeometry(frame, quad->shared_quad_state->quad_to_target_transform,
+    DrawQuadGeometry(frame->projection_matrix,
+                     quad->shared_quad_state->quad_to_target_transform,
                      tile_rect, matrix_location);
   } 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,
         region_quad, matrix_location, uvs);
@@ skipping 26 matching lines @@
   gl_->BindTexture(GL_TEXTURE_EXTERNAL_OES, lock.texture_id());
 
   gl_->UniformMatrix4fvStreamTextureMatrixCHROMIUM(
       program->vertex_shader().tex_matrix_location(), false, gl_matrix);
 
   gl_->Uniform1i(program->fragment_shader().sampler_location(), 0);
 
   SetShaderOpacity(quad->shared_quad_state->opacity,
                    program->fragment_shader().alpha_location());
   if (!clip_region) {
-    DrawQuadGeometry(frame, quad->shared_quad_state->quad_to_target_transform,
+    DrawQuadGeometry(frame->projection_matrix,
+                     quad->shared_quad_state->quad_to_target_transform,
                      gfx::RectF(quad->rect),
                      program->vertex_shader().matrix_location());
   } 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,
@@ skipping 344 matching lines @@
   gfx::Transform quad_rect_matrix;
   QuadRectTransform(&quad_rect_matrix, draw_transform, quad_rect);
   static float gl_matrix[16];
   ToGLMatrix(&gl_matrix[0], frame->projection_matrix * quad_rect_matrix);
   gl_->UniformMatrix4fv(matrix_location, 1, false, &gl_matrix[0]);
 
   gl_->DrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT,
                     reinterpret_cast<const void*>(0));
 }
 
-void GLRenderer::DrawQuadGeometry(const DrawingFrame* frame,
+void GLRenderer::DrawQuadGeometry(const gfx::Transform& projection_matrix,
                                   const gfx::Transform& draw_transform,
                                   const gfx::RectF& quad_rect,
                                   int matrix_location) {
   PrepareGeometry(SHARED_BINDING);
   gfx::Transform quad_rect_matrix;
   QuadRectTransform(&quad_rect_matrix, draw_transform, quad_rect);
   static float gl_matrix[16];
-  ToGLMatrix(&gl_matrix[0], frame->projection_matrix * quad_rect_matrix);
+  ToGLMatrix(&gl_matrix[0], projection_matrix * quad_rect_matrix);
   gl_->UniformMatrix4fv(matrix_location, 1, false, &gl_matrix[0]);
 
   gl_->DrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0);
 }
 
 void GLRenderer::Finish() {
   TRACE_EVENT0("cc", "GLRenderer::Finish");
   gl_->Finish();
 }
 
@@ skipping 897 matching lines @@
 
   if (is_scissor_enabled_) {
     gl_->Enable(GL_SCISSOR_TEST);
     gl_->Scissor(scissor_rect_.x(), scissor_rect_.y(), scissor_rect_.width(),
                  scissor_rect_.height());
   } else {
     gl_->Disable(GL_SCISSOR_TEST);
   }
 }
 
-void GLRenderer::RestoreFramebuffer(DrawingFrame* frame) {
-  UseRenderPass(frame, frame->current_render_pass);
-
-  // Call SetViewport directly, rather than through PrepareSurfaceForPass.
-  // PrepareSurfaceForPass also clears the surface, which is not desired when
-  // restoring.
-  SetViewport();
-}
-
 bool GLRenderer::IsContextLost() {
   return gl_->GetGraphicsResetStatusKHR() != GL_NO_ERROR;
 }
 
 void GLRenderer::ScheduleCALayers(DrawingFrame* frame) {
   scoped_refptr<CALayerOverlaySharedState> shared_state;
   size_t copied_render_pass_count = 0;
   for (const CALayerOverlay& ca_layer_overlay : frame->ca_layer_overlay_list) {
     if (!overlay_resource_pool_) {
       overlay_resource_pool_ = ResourcePool::CreateForGpuMemoryBufferResources(
@@ skipping 129 matching lines @@
         resource_provider_, contents_texture->id()));
     source_texture = source->texture_id();
   }
   gl_->CopySubTextureCHROMIUM(source_texture, destination.texture_id(), 0, 0, 0,
                               0, contents_texture->size().width(),
                               contents_texture->size().height(), GL_TRUE,
                               GL_FALSE, GL_FALSE);
 }
 
 }  // namespace cc