cc: Move tracking of layer_property_changed to main thread (3)

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 <utility>
@@ skipping 44 matching lines @@
       mask_layer_id_(-1),
       replica_layer_id_(-1),
       layer_id_(id),
       layer_tree_impl_(tree_impl),
       scroll_offset_(scroll_offset),
       scroll_clip_layer_id_(Layer::INVALID_ID),
       main_thread_scrolling_reasons_(
           MainThreadScrollingReason::kNotScrollingOnMain),
       user_scrollable_horizontal_(true),
       user_scrollable_vertical_(true),
-      stacking_order_changed_(false),
       double_sided_(true),
       should_flatten_transform_(true),
       should_flatten_transform_from_property_tree_(false),
       layer_property_changed_(false),
       masks_to_bounds_(false),
       contents_opaque_(false),
       is_root_for_isolated_group_(false),
       use_parent_backface_visibility_(false),
       use_local_transform_for_backface_visibility_(false),
       should_check_backface_visibility_(false),
@@ skipping 527 matching lines @@
 
   layer->PassCopyRequests(&copy_requests_);
 
   // If the main thread commits multiple times before the impl thread actually
   // draws, then damage tracking will become incorrect if we simply clobber the
   // update_rect here. The LayerImpl's update_rect needs to accumulate (i.e.
   // union) any update changes that have occurred on the main thread.
   update_rect_.Union(layer->update_rect());
   layer->SetUpdateRect(update_rect_);
 
-  layer->SetStackingOrderChanged(stacking_order_changed_);
   layer->SetDebugInfo(debug_info_);
 
   if (frame_timing_requests_dirty_) {
     layer->SetFrameTimingRequests(frame_timing_requests_);
     frame_timing_requests_dirty_ = false;
   }
 
   // Reset any state that should be cleared for the next update.
-  stacking_order_changed_ = false;
   layer_property_changed_ = false;
   update_rect_ = gfx::Rect();
   needs_push_properties_ = false;
   num_dependents_need_push_properties_ = 0;
 }
 
 bool LayerImpl::IsAffectedByPageScale() const {
   TransformTree& transform_tree =
       layer_tree_impl()->property_trees()->transform_tree;
   return transform_tree.Node(transform_tree_index())
@@ skipping 46 matching lines @@
   }
 
   list = new base::ListValue;
   for (size_t i = 0; i < children_.size(); ++i)
     list->Append(children_[i]->LayerTreeAsJson());
   result->Set("Children", list);
 
   return result;
 }
 
-void LayerImpl::SetStackingOrderChanged(bool stacking_order_changed) {
-  if (stacking_order_changed) {
-    stacking_order_changed_ = true;
-    NoteLayerPropertyChangedForSubtree();
-  }
-}
-
 bool LayerImpl::LayerPropertyChanged() const {
   if (layer_property_changed_)
     return true;
   TransformNode* node =
       layer_tree_impl()->property_trees()->transform_tree.Node(
           transform_tree_index());
   if (node && node->data.transform_changed)
     return true;
   return false;
 }
@@ skipping 556 matching lines @@
 
 void LayerImpl::SetTransformAndInvertibility(const gfx::Transform& transform,
                                              bool transform_is_invertible) {
   if (transform_ == transform) {
     DCHECK(transform_is_invertible_ == transform_is_invertible)
         << "Can't change invertibility if transform is unchanged";
     return;
   }
   transform_ = transform;
   transform_is_invertible_ = transform_is_invertible;
-  NoteLayerPropertyChangedForSubtree();
 }
 
 bool LayerImpl::TransformIsAnimating() const {
   LayerAnimationController::ObserverType observer_type =
       IsActive() ? LayerAnimationController::ObserverType::ACTIVE
                  : LayerAnimationController::ObserverType::PENDING;
   return layer_animation_controller_
              ? layer_animation_controller_->IsCurrentlyAnimatingProperty(
                    Animation::TRANSFORM, observer_type)
              : layer_tree_impl_->IsAnimatingTransformProperty(this);
@@ skipping 515 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