cc : Delete LayerImpl::transform

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 322 matching lines @@
   layer->use_local_transform_for_backface_visibility_ =
       use_local_transform_for_backface_visibility_;
   layer->should_check_backface_visibility_ = should_check_backface_visibility_;
   layer->draws_content_ = draws_content_;
   layer->non_fast_scrollable_region_ = non_fast_scrollable_region_;
   layer->touch_event_handler_region_ = touch_event_handler_region_;
   layer->background_color_ = background_color_;
   layer->safe_opaque_background_color_ = safe_opaque_background_color_;
   layer->draw_blend_mode_ = draw_blend_mode_;
   layer->position_ = position_;
-  layer->transform_ = transform_;
   layer->transform_tree_index_ = transform_tree_index_;
   layer->effect_tree_index_ = effect_tree_index_;
   layer->clip_tree_index_ = clip_tree_index_;
   layer->scroll_tree_index_ = scroll_tree_index_;
   layer->sorting_context_id_ = sorting_context_id_;
   layer->has_will_change_transform_hint_ = has_will_change_transform_hint_;
 
   if (layer_property_changed_) {
     layer->layer_tree_impl()->set_needs_update_draw_properties();
     layer->layer_property_changed_ = true;
@@ skipping 51 matching lines @@
   base::ListValue* list = new base::ListValue;
   list->AppendInteger(bounds().width());
   list->AppendInteger(bounds().height());
   result->Set("Bounds", list);
 
   list = new base::ListValue;
   list->AppendDouble(position_.x());
   list->AppendDouble(position_.y());
   result->Set("Position", list);
 
-  const gfx::Transform& gfx_transform = transform();
-  double transform[16];
-  gfx_transform.matrix().asColMajord(transform);
-  list = new base::ListValue;
-  for (int i = 0; i < 16; ++i)
-    list->AppendDouble(transform[i]);
-  result->Set("Transform", list);
-
   result->SetBoolean("DrawsContent", draws_content_);
   result->SetBoolean("Is3dSorted", Is3dSorted());
   result->SetDouble("OPACITY", Opacity());
   result->SetBoolean("ContentsOpaque", contents_opaque_);
 
   if (scrollable())
     result->SetBoolean("Scrollable", true);
 
   if (!touch_event_handler_region_.IsEmpty()) {
     std::unique_ptr<base::Value> region = touch_event_handler_region_.AsValue();
@@ skipping 60 matching lines @@
     render_surface_->ResetPropertyChangedFlag();
 }
 
 int LayerImpl::num_copy_requests_in_target_subtree() {
   return layer_tree_impl()
       ->property_trees()
       ->effect_tree.Node(effect_tree_index())
       ->num_copy_requests_in_subtree;
 }
 
-void LayerImpl::UpdatePropertyTreeTransform() {
+void LayerImpl::UpdatePropertyTreeTransform(const gfx::Transform& transform) {
   PropertyTrees* property_trees = layer_tree_impl()->property_trees();
   if (property_trees->IsInIdToIndexMap(PropertyTrees::TreeType::TRANSFORM,
                                        id())) {
     // A LayerImpl's own current state is insufficient for determining whether
     // it owns a TransformNode, since this depends on the state of the
     // corresponding Layer at the time of the last commit. For example, a
     // transform animation might have been in progress at the time the last
     // commit started, but might have finished since then on the compositor
     // thread.
     TransformNode* node = property_trees->transform_tree.Node(
         property_trees->transform_id_to_index_map[id()]);
-    if (node->local != transform_) {
-      node->local = transform_;
+    if (node->local != transform) {
+      node->local = transform;
       node->needs_local_transform_update = true;
       node->transform_changed = true;
       property_trees->changed = true;
       property_trees->transform_tree.set_needs_update(true);
+      layer_tree_impl()->set_needs_update_draw_properties();
       // TODO(ajuma): The current criteria for creating clip nodes means that
       // property trees may need to be rebuilt when the new transform isn't
       // axis-aligned wrt the old transform (see Layer::SetTransform). Since
       // rebuilding property trees every frame of a transform animation is
       // something we should try to avoid, change property tree-building so that
       // it doesn't depend on axis aliginment.
     }
   }
 }
 
@@ skipping 76 matching lines @@
 }
 
 void LayerImpl::OnOpacityAnimated(float opacity) {
   UpdatePropertyTreeOpacity(opacity);
   SetNeedsPushProperties();
   layer_tree_impl()->set_needs_update_draw_properties();
   layer_tree_impl()->AddToOpacityAnimationsMap(id(), opacity);
 }
 
 void LayerImpl::OnTransformAnimated(const gfx::Transform& transform) {
-  gfx::Transform old_transform = transform_;
-  SetTransform(transform);
-  UpdatePropertyTreeTransform();
+  UpdatePropertyTreeTransform(transform);
   was_ever_ready_since_last_transform_animation_ = false;
   layer_tree_impl()->AddToTransformAnimationsMap(id(), transform);
-  if (old_transform != transform) {
-    SetNeedsPushProperties();
-    layer_tree_impl()->set_needs_update_draw_properties();
-  }
 }
 
 void LayerImpl::OnScrollOffsetAnimated(const gfx::ScrollOffset& scroll_offset) {
   // Only layers in the active tree should need to do anything here, since
   // layers in the pending tree will find out about these changes as a
   // result of the shared SyncedProperty.
   if (!IsActive())
     return;
 
   SetCurrentScrollOffset(ClampScrollOffsetToLimits(scroll_offset));
@@ skipping 179 matching lines @@
 
 float LayerImpl::Opacity() const {
   PropertyTrees* property_trees = layer_tree_impl()->property_trees();
   if (!property_trees->IsInIdToIndexMap(PropertyTrees::TreeType::EFFECT, id()))
     return 1.f;
   EffectNode* node = property_trees->effect_tree.Node(
       property_trees->effect_id_to_index_map[id()]);
   return node->opacity;
 }
 
+const gfx::Transform& LayerImpl::Transform() const {
+  PropertyTrees* property_trees = layer_tree_impl()->property_trees();
+  DCHECK(property_trees->IsInIdToIndexMap(PropertyTrees::TreeType::TRANSFORM,
+                                          id()));
+  TransformNode* node = property_trees->transform_tree.Node(
+      property_trees->transform_id_to_index_map[id()]);
+  return node->local;
+}
+
 void LayerImpl::SetElementId(ElementId element_id) {
   if (element_id == element_id_)
     return;
 
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("compositor-worker"),
                "LayerImpl::SetElementId", "element",
                element_id.AsValue().release());
 
   layer_tree_impl_->RemoveFromElementMap(this);
   element_id_ = element_id;
@@ skipping 15 matching lines @@
 }
 
 void LayerImpl::SetPosition(const gfx::PointF& position) {
   position_ = position;
 }
 
 void LayerImpl::Set3dSortingContextId(int id) {
   sorting_context_id_ = id;
 }
 
-void LayerImpl::SetTransform(const gfx::Transform& transform) {
-  transform_ = transform;
-}
-
 bool LayerImpl::TransformIsAnimating() const {
   return GetAnimationHost()->IsAnimatingTransformProperty(
       element_id(), GetElementTypeForAnimation());
 }
 
 bool LayerImpl::HasPotentiallyRunningTransformAnimation() const {
   return GetAnimationHost()->HasPotentiallyRunningTransformAnimation(
       element_id(), GetElementTypeForAnimation());
 }
 
@@ skipping 132 matching lines @@
                     base::saturated_cast<int>(GPUMemoryUsageInBytes()));
 
   if (element_id_)
     element_id_.AddToTracedValue(state);
 
   if (mutable_properties_ != MutableProperty::kNone)
     state->SetInteger("mutable_properties", mutable_properties_);
 
   MathUtil::AddToTracedValue("scroll_offset", CurrentScrollOffset(), state);
 
-  if (!transform().IsIdentity())
-    MathUtil::AddToTracedValue("transform", transform(), state);
+  if (!ScreenSpaceTransform().IsIdentity())
+    MathUtil::AddToTracedValue("screen_space_transform", ScreenSpaceTransform(),
+                               state);
 
   bool clipped;
   gfx::QuadF layer_quad =
       MathUtil::MapQuad(ScreenSpaceTransform(),
                         gfx::QuadF(gfx::RectF(gfx::Rect(bounds()))), &clipped);
   MathUtil::AddToTracedValue("layer_quad", layer_quad, state);
   if (!touch_event_handler_region_.IsEmpty()) {
     state->BeginArray("touch_event_handler_region");
     touch_event_handler_region_.AsValueInto(state);
     state->EndArray();
@@ skipping 168 matching lines @@
            .layer_transforms_should_scale_layer_contents) {
     return default_scale;
   }
 
   gfx::Vector2dF transform_scales = MathUtil::ComputeTransform2dScaleComponents(
       ScreenSpaceTransform(), default_scale);
   return std::max(transform_scales.x(), transform_scales.y());
 }
 
 }  // namespace cc