cc : Delete LayerImpl::NoteLayerPropertyChangedForSubtree

cc/trees/property_tree.cc

 // Copyright 2014 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 <stddef.h>
 
 #include <set>
 #include <vector>
 
 #include "base/logging.h"
@@ skipping 417 matching lines @@
 }
 
 EffectNodeData::EffectNodeData()
     : opacity(1.f),
       screen_space_opacity(1.f),
       has_render_surface(false),
       has_copy_request(false),
       has_background_filters(false),
       is_drawn(true),
       has_animated_opacity(false),
-      opacity_changed(false),
+      effect_changed(false),
       num_copy_requests_in_subtree(0),
       transform_id(0),
       clip_id(0) {}
 
 EffectNodeData::EffectNodeData(const EffectNodeData& other) = default;
 
 bool EffectNodeData::operator==(const EffectNodeData& other) const {
   return opacity == other.opacity &&
          screen_space_opacity == other.screen_space_opacity &&
          has_render_surface == other.has_render_surface &&
          has_copy_request == other.has_copy_request &&
          has_background_filters == other.has_background_filters &&
          is_drawn == other.is_drawn &&
          has_animated_opacity == other.has_animated_opacity &&
-         opacity_changed == other.opacity_changed &&
+         effect_changed == other.effect_changed &&
          num_copy_requests_in_subtree == other.num_copy_requests_in_subtree &&
          transform_id == other.transform_id && clip_id == other.clip_id;
 }
 
 void EffectNodeData::ToProtobuf(proto::TreeNode* proto) const {
   DCHECK(!proto->has_effect_node_data());
   proto::EffectNodeData* data = proto->mutable_effect_node_data();
   data->set_opacity(opacity);
   data->set_screen_space_opacity(screen_space_opacity);
   data->set_has_render_surface(has_render_surface);
   data->set_has_copy_request(has_copy_request);
   data->set_has_background_filters(has_background_filters);
   data->set_is_drawn(is_drawn);
   data->set_has_animated_opacity(has_animated_opacity);
-  data->set_opacity_changed(opacity_changed);
+  data->set_effect_changed(effect_changed);
   data->set_num_copy_requests_in_subtree(num_copy_requests_in_subtree);
   data->set_transform_id(transform_id);
   data->set_clip_id(clip_id);
 }
 
 void EffectNodeData::FromProtobuf(const proto::TreeNode& proto) {
   DCHECK(proto.has_effect_node_data());
   const proto::EffectNodeData& data = proto.effect_node_data();
 
   opacity = data.opacity();
   screen_space_opacity = data.screen_space_opacity();
   has_render_surface = data.has_render_surface();
   has_copy_request = data.has_copy_request();
   has_background_filters = data.has_background_filters();
   is_drawn = data.is_drawn();
   has_animated_opacity = data.has_animated_opacity();
-  opacity_changed = data.opacity_changed();
+  effect_changed = data.effect_changed();
   num_copy_requests_in_subtree = data.num_copy_requests_in_subtree();
   transform_id = data.transform_id();
   clip_id = data.clip_id();
 }
 
 ScrollNodeData::ScrollNodeData()
     : scrollable(false),
       main_thread_scrolling_reasons(
           MainThreadScrollingReason::kNotScrollingOnMain),
       contains_non_fast_scrollable_region(false),
@@ skipping 675 matching lines @@
   if (node->data.has_copy_request || node->data.has_background_filters)
     node->data.is_drawn = true;
   else if (node->data.opacity == 0.f && !node->data.has_animated_opacity)
     node->data.is_drawn = false;
   else if (parent_node)
     node->data.is_drawn = parent_node->data.is_drawn;
   else
     node->data.is_drawn = true;
 }
 
-void EffectTree::UpdateOpacityChanged(EffectNode* node,
-                                      EffectNode* parent_node) {
-  if (parent_node && parent_node->data.opacity_changed) {
-    node->data.opacity_changed = true;
+void EffectTree::UpdateEffectChanged(EffectNode* node,
+                                     EffectNode* parent_node) {
+  if (parent_node && parent_node->data.effect_changed) {
+    node->data.effect_changed = true;
   }
 }
 
 void EffectTree::UpdateEffects(int id) {
   EffectNode* node = Node(id);
   EffectNode* parent_node = parent(node);
 
   UpdateOpacities(node, parent_node);
   UpdateIsDrawn(node, parent_node);
-  UpdateOpacityChanged(node, parent_node);
+  UpdateEffectChanged(node, parent_node);
 }
 
 void EffectTree::ClearCopyRequests() {
   for (auto& node : nodes()) {
     node.data.num_copy_requests_in_subtree = 0;
     node.data.has_copy_request = false;
   }
   set_needs_update(true);
 }
 
 bool EffectTree::ContributesToDrawnSurface(int id) {
   // All drawn nodes contribute to drawn surface.
   // Exception : Nodes that are hidden and are drawn only for the sake of
   // copy requests.
   EffectNode* node = Node(id);
   EffectNode* parent_node = parent(node);
   bool contributes_to_drawn_surface =
       node->data.is_drawn &&
       (node->data.opacity != 0.f || node->data.has_animated_opacity ||
        node->data.has_background_filters);
   if (parent_node && !parent_node->data.is_drawn)
     contributes_to_drawn_surface = false;
   return contributes_to_drawn_surface;
 }
 
 void EffectTree::ResetChangeTracking() {
   for (int id = 1; id < static_cast<int>(size()); ++id) {
     EffectNode* node = Node(id);
-    node->data.opacity_changed = false;
+    node->data.effect_changed = false;
   }
 }
 
 void TransformTree::UpdateNodeAndAncestorsHaveIntegerTranslations(
     TransformNode* node,
     TransformNode* parent_node) {
   node->data.node_and_ancestors_have_only_integer_translation =
       node->data.to_parent.IsIdentityOrIntegerTranslation();
   if (parent_node)
     node->data.node_and_ancestors_have_only_integer_translation =
@@ skipping 162 matching lines @@
   screen_space_transform.ConcatTransform(transform_node->data.to_screen);
   if (scroll_node->data.should_flatten)
     screen_space_transform.FlattenTo2d();
   return screen_space_transform;
 }
 
 PropertyTrees::PropertyTrees()
     : needs_rebuild(true),
       non_root_surfaces_enabled(true),
       changed(false),
+      full_tree_damaged(false),
       sequence_number(0) {
   transform_tree.SetPropertyTrees(this);
   effect_tree.SetPropertyTrees(this);
   clip_tree.SetPropertyTrees(this);
   scroll_tree.SetPropertyTrees(this);
 }
 
 PropertyTrees::~PropertyTrees() {}
 
 bool PropertyTrees::operator==(const PropertyTrees& other) const {
   return transform_tree == other.transform_tree &&
          effect_tree == other.effect_tree && clip_tree == other.clip_tree &&
          scroll_tree == other.scroll_tree &&
          needs_rebuild == other.needs_rebuild && changed == other.changed &&
+         full_tree_damaged == other.full_tree_damaged &&
          non_root_surfaces_enabled == other.non_root_surfaces_enabled &&
          sequence_number == other.sequence_number;
 }
 
 PropertyTrees& PropertyTrees::operator=(const PropertyTrees& from) {
   transform_tree = from.transform_tree;
   effect_tree = from.effect_tree;
   clip_tree = from.clip_tree;
   scroll_tree = from.scroll_tree;
   needs_rebuild = from.needs_rebuild;
   changed = from.changed;
+  full_tree_damaged = from.full_tree_damaged;
   non_root_surfaces_enabled = from.non_root_surfaces_enabled;
   sequence_number = from.sequence_number;
   inner_viewport_container_bounds_delta_ =
       from.inner_viewport_container_bounds_delta();
   outer_viewport_container_bounds_delta_ =
       from.outer_viewport_container_bounds_delta();
   inner_viewport_scroll_bounds_delta_ =
       from.inner_viewport_scroll_bounds_delta();
   transform_tree.SetPropertyTrees(this);
   effect_tree.SetPropertyTrees(this);
   clip_tree.SetPropertyTrees(this);
   scroll_tree.SetPropertyTrees(this);
   return *this;
 }
 
 void PropertyTrees::ToProtobuf(proto::PropertyTrees* proto) const {
   // TODO(khushalsagar): Add support for sending diffs when serializaing
   // property trees. See crbug/555370.
   transform_tree.ToProtobuf(proto->mutable_transform_tree());
   effect_tree.ToProtobuf(proto->mutable_effect_tree());
   clip_tree.ToProtobuf(proto->mutable_clip_tree());
   scroll_tree.ToProtobuf(proto->mutable_scroll_tree());
   proto->set_needs_rebuild(needs_rebuild);
   proto->set_changed(changed);
+  proto->set_full_tree_damaged(full_tree_damaged);
   proto->set_non_root_surfaces_enabled(non_root_surfaces_enabled);
 
   // TODO(khushalsagar): Consider using the sequence number to decide if
   // property trees need to be serialized again for a commit. See crbug/555370.
   proto->set_sequence_number(sequence_number);
 }
 
 // static
 void PropertyTrees::FromProtobuf(const proto::PropertyTrees& proto) {
   transform_tree.FromProtobuf(proto.transform_tree());
   effect_tree.FromProtobuf(proto.effect_tree());
   clip_tree.FromProtobuf(proto.clip_tree());
   scroll_tree.FromProtobuf(proto.scroll_tree());
 
   needs_rebuild = proto.needs_rebuild();
   changed = proto.changed();
+  full_tree_damaged = proto.full_tree_damaged();
   non_root_surfaces_enabled = proto.non_root_surfaces_enabled();
   sequence_number = proto.sequence_number();
 
   transform_tree.SetPropertyTrees(this);
   effect_tree.SetPropertyTrees(this);
   clip_tree.SetPropertyTrees(this);
   scroll_tree.SetPropertyTrees(this);
 }
 
 void PropertyTrees::SetInnerViewportContainerBoundsDelta(
@@ skipping 15 matching lines @@
 }
 
 void PropertyTrees::SetInnerViewportScrollBoundsDelta(
     gfx::Vector2dF bounds_delta) {
   inner_viewport_scroll_bounds_delta_ = bounds_delta;
 }
 
 void PropertyTrees::PushChangeTrackingTo(PropertyTrees* tree) {
   for (int id = 1; id < static_cast<int>(effect_tree.size()); ++id) {
     EffectNode* node = effect_tree.Node(id);
-    if (node->data.opacity_changed) {
+    if (node->data.effect_changed) {
       EffectNode* target_node = tree->effect_tree.Node(node->id);
-      target_node->data.opacity_changed = true;
+      target_node->data.effect_changed = true;
     }
   }
   for (int id = 1; id < static_cast<int>(transform_tree.size()); ++id) {
     TransformNode* node = transform_tree.Node(id);
     if (node->data.transform_changed) {
       TransformNode* target_node = tree->transform_tree.Node(node->id);
       target_node->data.transform_changed = true;
     }
   }
+  tree->full_tree_damaged = full_tree_damaged;
+}
+
+void PropertyTrees::ResetAllChangeTracking(ResetFlags flag) {
+  switch (flag) {
+    case EFFECT_TREE:
+      effect_tree.ResetChangeTracking();
+      break;
+    case TRANSFORM_TREE:
+      transform_tree.ResetChangeTracking();
+      break;
+    case ALL_TREES:
+      transform_tree.ResetChangeTracking();
+      effect_tree.ResetChangeTracking();
+  }
+  changed = false;
+  full_tree_damaged = false;
 }
 
 }  // namespace cc