cc : Stop pushing transform origin from Layer and LayerImpl.

cc/layers/layer_impl.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/layers/layer_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 35 matching lines @@
 LayerImpl::LayerImpl(LayerTreeImpl* tree_impl, int id)
     : parent_(nullptr),
       scroll_parent_(nullptr),
       clip_parent_(nullptr),
       mask_layer_id_(-1),
       mask_layer_(nullptr),
       replica_layer_id_(-1),
       replica_layer_(nullptr),
       layer_id_(id),
       layer_tree_impl_(tree_impl),
+      test_properties_(nullptr),
       scroll_clip_layer_id_(Layer::INVALID_ID),
       main_thread_scrolling_reasons_(
           MainThreadScrollingReason::kNotScrollingOnMain),
       user_scrollable_horizontal_(true),
       user_scrollable_vertical_(true),
       double_sided_(true),
       should_flatten_transform_(true),
       should_flatten_transform_from_property_tree_(false),
       layer_property_changed_(false),
       masks_to_bounds_(false),
@@ skipping 412 matching lines @@
     if (layer_tree_impl()->ScrollOffsetIsAnimatingOnImplOnly(this)) {
       const bool needs_completion = true;
       layer_tree_impl()->ScrollAnimationAbort(needs_completion);
     }
   }
 
   main_thread_scrolling_reasons_ = main_thread_scrolling_reasons;
 }
 
 void LayerImpl::PushPropertiesTo(LayerImpl* layer) {
-  layer->SetTransformOrigin(transform_origin_);
   layer->SetBackgroundColor(background_color_);
   layer->SetSafeOpaqueBackgroundColor(safe_opaque_background_color_);
   layer->SetBounds(bounds_);
   layer->SetDoubleSided(double_sided_);
   layer->SetDrawsContent(DrawsContent());
   layer->SetHideLayerAndSubtree(hide_layer_and_subtree_);
   // If whether layer has render surface changes, we need to update draw
   // properties.
   // TODO(weiliangc): Should be safely removed after impl side is able to
   // update render surfaces without rebuilding property trees.
@@ skipping 545 matching lines @@
   NoteLayerPropertyChanged();
 }
 
 void LayerImpl::SetHideLayerAndSubtree(bool hide) {
   if (hide_layer_and_subtree_ == hide)
     return;
 
   hide_layer_and_subtree_ = hide;
 }
 
-void LayerImpl::SetTransformOrigin(const gfx::Point3F& transform_origin) {
-  if (transform_origin_ == transform_origin)
-    return;
-  transform_origin_ = transform_origin;
+void LayerImpl::SetTransformOriginForTesting(
+    const gfx::Point3F& transform_origin) {
+  if (!test_properties_)
+    test_properties_ = new LayerImplTestProperties();
+  test_properties_->transform_origin = transform_origin;
 }
 
 void LayerImpl::SetBackgroundColor(SkColor background_color) {
   if (background_color_ == background_color)
     return;
 
   background_color_ = background_color;
   NoteLayerPropertyChanged();
 }
 
@@ skipping 319 matching lines @@
   state->SetInteger("gpu_memory_usage",
                     base::saturated_cast<int>(GPUMemoryUsageInBytes()));
 
   if (mutable_properties_ != MutableProperty::kNone) {
     state->SetInteger("element_id", base::saturated_cast<int>(element_id_));
     state->SetInteger("mutable_properties", mutable_properties_);
   }
 
   MathUtil::AddToTracedValue("scroll_offset", CurrentScrollOffset(), state);
 
-  MathUtil::AddToTracedValue("transform_origin", transform_origin_, state);
-
   if (!transform().IsIdentity())
     MathUtil::AddToTracedValue("transform", transform(), state);
 
   state->SetBoolean("should_flatten", should_flatten_transform_);
 
   bool clipped;
   gfx::QuadF layer_quad =
       MathUtil::MapQuad(ScreenSpaceTransform(),
                         gfx::QuadF(gfx::RectF(gfx::Rect(bounds()))), &clipped);
   MathUtil::AddToTracedValue("layer_quad", layer_quad, state);
@@ skipping 195 matching lines @@
            .layer_transforms_should_scale_layer_contents) {
     return default_scale;
   }
 
   gfx::Vector2dF transform_scales = MathUtil::ComputeTransform2dScaleComponents(
       DrawTransform(), default_scale);
   return std::max(transform_scales.x(), transform_scales.y());
 }
 
 }  // namespace cc