cc: Remove calls to owning_layer_->DrawTransform in RenderSurfaceImpl

cc/layers/render_surface_impl.cc

 // Copyright 2011 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/layers/render_surface_impl.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
@@ skipping 14 matching lines @@
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/occlusion.h"
 #include "cc/trees/transform_node.h"
 #include "third_party/skia/include/core/SkImageFilter.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/transform.h"
 
 namespace cc {
 
 RenderSurfaceImpl::RenderSurfaceImpl(LayerImpl* owning_layer)
-    : owning_layer_(owning_layer),
-      layer_tree_impl_(owning_layer->layer_tree_impl()),
+    : layer_tree_impl_(owning_layer->layer_tree_impl()),
       stable_effect_id_(owning_layer->id()),
       effect_tree_index_(EffectTree::kInvalidNodeId),
       surface_property_changed_(false),
       ancestor_property_changed_(false),
       contributes_to_drawn_surface_(false),
       nearest_occlusion_immune_ancestor_(nullptr),
       target_render_surface_layer_index_history_(0),
       current_layer_index_history_(0) {
   damage_tracker_ = DamageTracker::Create();
 }
@@ skipping 28 matching lines @@
 
 RenderSurfaceImpl::DrawProperties::~DrawProperties() {}
 
 gfx::RectF RenderSurfaceImpl::DrawableContentRect() const {
   if (content_rect().IsEmpty())
     return gfx::RectF();
 
   gfx::Rect surface_content_rect = content_rect();
   const FilterOperations& filters = Filters();
   if (!filters.IsEmpty()) {
-    const gfx::Transform& owning_layer_draw_transform =
-        owning_layer_->DrawTransform();
-    DCHECK(owning_layer_draw_transform.IsScale2d());
-    surface_content_rect = filters.MapRect(
-        surface_content_rect, owning_layer_draw_transform.matrix());
+    surface_content_rect =
+        filters.MapRect(surface_content_rect, FiltersTransform().matrix());
   }
   gfx::RectF drawable_content_rect = MathUtil::MapClippedRect(
       draw_transform(), gfx::RectF(surface_content_rect));
   if (!filters.IsEmpty() && is_clipped()) {
     // Filter could move pixels around, but still need to be clipped.
     drawable_content_rect.Intersect(gfx::RectF(clip_rect()));
   }
 
   // If the rect has a NaN coordinate, we return empty rect to avoid crashes in
   // functions (for example, gfx::ToEnclosedRect) that are called on this rect.
@@ skipping 33 matching lines @@
 
 const FilterOperations& RenderSurfaceImpl::Filters() const {
   return OwningEffectNode()->filters;
 }
 
 gfx::PointF RenderSurfaceImpl::FiltersOrigin() const {
   return OwningEffectNode()->filters_origin;
 }
 
 gfx::Transform RenderSurfaceImpl::FiltersTransform() const {
-  return owning_layer_->DrawTransform();
+  gfx::Transform filters_transform;
+  filters_transform.Scale(OwningEffectNode()->surface_contents_scale.x(),
+                          OwningEffectNode()->surface_contents_scale.y());
+  return filters_transform;
 }
 
 const FilterOperations& RenderSurfaceImpl::BackgroundFilters() const {
   return OwningEffectNode()->background_filters;
 }
 
 bool RenderSurfaceImpl::HasCopyRequest() const {
   return OwningEffectNode()->has_copy_request;
 }
 
@@ skipping 158 matching lines @@
 bool RenderSurfaceImpl::SurfacePropertyChanged() const {
   // Surface property changes are tracked as follows:
   //
   // - surface_property_changed_ is flagged when the clip_rect or content_rect
   //   change. As of now, these are the only two properties that can be affected
   //   by descendant layers.
   //
   // - all other property changes come from the surface's property tree nodes
   //   (or some ancestor node that propagates its change to one of these nodes).
   //
-  DCHECK(owning_layer_);
   return surface_property_changed_ || AncestorPropertyChanged();
 }
 
 bool RenderSurfaceImpl::SurfacePropertyChangedOnlyFromDescendant() const {
   return surface_property_changed_ && !AncestorPropertyChanged();
 }
 
 bool RenderSurfaceImpl::AncestorPropertyChanged() const {
   const PropertyTrees* property_trees = layer_tree_impl_->property_trees();
   return ancestor_property_changed_ || property_trees->full_tree_damaged ||
@@ skipping 52 matching lines @@
     DebugBorderDrawQuad* debug_border_quad =
         render_pass->CreateAndAppendDrawQuad<DebugBorderDrawQuad>();
     debug_border_quad->SetNew(shared_quad_state, content_rect(),
                               visible_layer_rect, GetDebugBorderColor(),
                               GetDebugBorderWidth());
   }
 
   ResourceId mask_resource_id = 0;
   gfx::Size mask_texture_size;
   gfx::Vector2dF mask_uv_scale;
-  gfx::Transform owning_layer_draw_transform = owning_layer_->DrawTransform();
+  gfx::Vector2dF surface_contents_scale =
+      OwningEffectNode()->surface_contents_scale;
   LayerImpl* mask_layer = MaskLayer();
   if (mask_layer && mask_layer->DrawsContent() &&
       !mask_layer->bounds().IsEmpty()) {
     mask_layer->GetContentsResourceId(&mask_resource_id, &mask_texture_size);
-    gfx::Vector2dF owning_layer_draw_scale =
-        MathUtil::ComputeTransform2dScaleComponents(owning_layer_draw_transform,
-                                                    1.f);
     gfx::SizeF unclipped_mask_target_size = gfx::ScaleSize(
         gfx::SizeF(OwningEffectNode()->unscaled_mask_target_size),
-        owning_layer_draw_scale.x(), owning_layer_draw_scale.y());
+        surface_contents_scale.x(), surface_contents_scale.y());
     mask_uv_scale = gfx::Vector2dF(1.0f / unclipped_mask_target_size.width(),
                                    1.0f / unclipped_mask_target_size.height());
   }
 
-  DCHECK(owning_layer_draw_transform.IsScale2d());
-  gfx::Vector2dF owning_layer_to_target_scale =
-      owning_layer_draw_transform.Scale2d();
-
   RenderPassDrawQuad* quad =
       render_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
   quad->SetNew(shared_quad_state, content_rect(), visible_layer_rect,
                GetRenderPassId(), mask_resource_id, mask_uv_scale,
-               mask_texture_size, owning_layer_to_target_scale,
-               FiltersOrigin());
+               mask_texture_size, surface_contents_scale, FiltersOrigin());
 }
 
 }  // namespace cc