cc: Remove SetNeedsUpdate function from cc::Layer

cc/trees/layer_tree_host.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/trees/layer_tree_host.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 25 matching lines @@
 #include "cc/debug/rendering_stats_instrumentation.h"
 #include "cc/input/layer_selection_bound.h"
 #include "cc/input/page_scale_animation.h"
 #include "cc/layers/heads_up_display_layer.h"
 #include "cc/layers/heads_up_display_layer_impl.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_iterator.h"
 #include "cc/layers/painted_scrollbar_layer.h"
 #include "cc/resources/ui_resource_manager.h"
 #include "cc/trees/draw_property_utils.h"
+#include "cc/trees/effect_node.h"
 #include "cc/trees/layer_tree_host_client.h"
 #include "cc/trees/layer_tree_host_common.h"
 #include "cc/trees/layer_tree_host_impl.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/mutator_host.h"
 #include "cc/trees/property_tree_builder.h"
 #include "cc/trees/proxy_main.h"
 #include "cc/trees/single_thread_proxy.h"
 #include "cc/trees/swap_promise_manager.h"
+#include "cc/trees/transform_node.h"
 #include "cc/trees/tree_synchronizer.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/geometry/vector2d_conversions.h"
 
 namespace {
 static base::StaticAtomicSequenceNumber s_layer_tree_host_sequence_number;
 }
 
 namespace cc {
 
@@ skipping 200 matching lines @@
 // will run after the commit, but on the main thread.
 void LayerTreeHost::FinishCommitOnImplThread(
     LayerTreeHostImpl* host_impl) {
   DCHECK(task_runner_provider_->IsImplThread());
 
   bool is_new_trace;
   TRACE_EVENT_IS_NEW_TRACE(&is_new_trace);
   if (is_new_trace &&
       frame_viewer_instrumentation::IsTracingLayerTreeSnapshots() &&
       root_layer()) {
+    // We'll be dumping layer trees as part of trace, so make sure
+    // PushPropertiesTo() propagates layer debug info to the impl side --
+    // otherwise this won't happen for the layers that remain unchanged since
+    // tracing started.
     LayerTreeHostCommon::CallFunctionForEveryLayer(
-        this, [](Layer* layer) { layer->DidBeginTracing(); });
+        this, [](Layer* layer) { layer->SetNeedsPushProperties(); });
   }
 
   LayerTreeImpl* sync_tree = host_impl->sync_tree();
 
   if (next_commit_forces_redraw_) {
     sync_tree->ForceRedrawNextActivation();
     next_commit_forces_redraw_ = false;
   }
   if (next_commit_forces_recalculate_raster_scales_) {
     sync_tree->ForceRecalculateRasterScales();
@@ skipping 343 matching lines @@
 
   if (hud_layer_) {
     hud_layer_->PrepareForCalculateDrawProperties(device_viewport_size_,
                                                   device_scale_factor_);
   }
 
   gfx::Transform identity_transform;
   LayerList update_layer_list;
 
   {
+    base::AutoReset<bool> update_property_trees(&in_update_property_trees_,
+                                                true);
     TRACE_EVENT0("cc",
                  "LayerTreeHostInProcess::UpdateLayers::BuildPropertyTrees");
     TRACE_EVENT0(
         TRACE_DISABLED_BY_DEFAULT("cc.debug.cdp-perf"),
         "LayerTreeHostInProcessCommon::ComputeVisibleRectsWithPropertyTrees");
     PropertyTreeBuilder::PreCalculateMetaInformation(root_layer);
     bool can_render_to_separate_surface = true;
     PropertyTrees* property_trees = &property_trees_;
     if (!settings_.use_layer_lists) {
       // If use_layer_lists is set, then the property trees should have been
@@ skipping 17 matching lines @@
                                              can_render_to_separate_surface);
     draw_property_utils::FindLayersThatNeedUpdates(this, property_trees,
                                                    &update_layer_list);
   }
 
   for (const auto& layer : update_layer_list)
     layer->SavePaintProperties();
 
   bool content_is_suitable_for_gpu = true;
   bool did_paint_content =
-      UpdateLayers(update_layer_list, &content_is_suitable_for_gpu);
+      PaintContent(update_layer_list, &content_is_suitable_for_gpu);
 
   if (content_is_suitable_for_gpu) {
     ++num_consecutive_frames_suitable_for_gpu_;
     if (num_consecutive_frames_suitable_for_gpu_ >=
         kNumFramesToConsiderBeforeGpuRasterization) {
       content_is_suitable_for_gpu_rasterization_ = true;
     }
   } else {
     num_consecutive_frames_suitable_for_gpu_ = 0;
     content_is_suitable_for_gpu_rasterization_ = false;
@@ skipping 296 matching lines @@
 
 Layer* LayerTreeHost::LayerById(int id) const {
   auto iter = layer_id_map_.find(id);
   return iter != layer_id_map_.end() ? iter->second : nullptr;
 }
 
 size_t LayerTreeHost::NumLayers() const {
   return layer_id_map_.size();
 }
 
-bool LayerTreeHost::UpdateLayers(const LayerList& update_layer_list,
+bool LayerTreeHost::PaintContent(const LayerList& update_layer_list,
                                  bool* content_is_suitable_for_gpu) {
   base::AutoReset<bool> painting(&in_paint_layer_contents_, true);
   bool did_paint_content = false;
   for (const auto& layer : update_layer_list) {
     did_paint_content |= layer->Update();
     *content_is_suitable_for_gpu &= layer->IsSuitableForGpuRasterization();
   }
   return did_paint_content;
 }
 
@@ skipping 198 matching lines @@
   Layer* layer = LayerByElementId(element_id);
   DCHECK(layer);
   layer->OnFilterAnimated(filters);
 }
 
 void LayerTreeHost::SetElementOpacityMutated(ElementId element_id,
                                              ElementListType list_type,
                                              float opacity) {
   Layer* layer = LayerByElementId(element_id);
   DCHECK(layer);
+  DCHECK_GE(opacity, 0.f);
+  DCHECK_LE(opacity, 1.f);
   layer->OnOpacityAnimated(opacity);
+
+  if (property_trees_.IsInIdToIndexMap(PropertyTrees::TreeType::EFFECT,
+                                       layer->id())) {
+    DCHECK_EQ(layer->effect_tree_index(),
+              property_trees_.layer_id_to_effect_node_index[layer->id()]);
+    EffectNode* node =
+        property_trees_.effect_tree.Node(layer->effect_tree_index());
+    if (node->opacity == opacity)
+      return;
+
+    node->opacity = opacity;
+    property_trees_.effect_tree.set_needs_update(true);
+  }
+
+  SetNeedsUpdateLayers();
 }
 
 void LayerTreeHost::SetElementTransformMutated(
     ElementId element_id,
     ElementListType list_type,
     const gfx::Transform& transform) {
   Layer* layer = LayerByElementId(element_id);
   DCHECK(layer);
   layer->OnTransformAnimated(transform);
+
+  if (property_trees_.IsInIdToIndexMap(PropertyTrees::TreeType::TRANSFORM,
+                                       layer->id())) {
+    DCHECK_EQ(layer->transform_tree_index(),
+              property_trees_.layer_id_to_transform_node_index[layer->id()]);
+    TransformNode* node =
+        property_trees_.transform_tree.Node(layer->transform_tree_index());
+    if (node->local == transform)
+      return;
+
+    node->local = transform;
+    node->needs_local_transform_update = true;
+    node->has_potential_animation = true;
+    property_trees_.transform_tree.set_needs_update(true);
+  }
+
+  SetNeedsUpdateLayers();
 }
 
 void LayerTreeHost::SetElementScrollOffsetMutated(
     ElementId element_id,
     ElementListType list_type,
     const gfx::ScrollOffset& scroll_offset) {
   Layer* layer = LayerByElementId(element_id);
   DCHECK(layer);
   layer->OnScrollOffsetAnimated(scroll_offset);
 }
@@ skipping 30 matching lines @@
 LayerListReverseIterator<Layer> LayerTreeHost::rend() {
   return LayerListReverseIterator<Layer>(nullptr);
 }
 
 void LayerTreeHost::SetNeedsDisplayOnAllLayers() {
   for (auto* layer : *this)
     layer->SetNeedsDisplay();
 }
 
 }  // namespace cc