Reuse property trees

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 <algorithm>
 #include <stack>
 #include <string>
 
@@ skipping 491 matching lines @@
                          "LayerTreeHost::SetNeedsCommit::cancel prepaint",
                          TRACE_EVENT_SCOPE_THREAD);
     prepaint_callback_.Cancel();
   }
   proxy_->SetNeedsCommit();
   NotifySwapPromiseMonitorsOfSetNeedsCommit();
 }
 
 void LayerTreeHost::SetNeedsFullTreeSync() {
   needs_full_tree_sync_ = true;
+
+  property_trees_.needs_rebuild = true;
   SetNeedsCommit();
 }
 
 void LayerTreeHost::SetNeedsRedraw() {
   SetNeedsRedrawRect(gfx::Rect(device_viewport_size_));
 }
 
 void LayerTreeHost::SetNeedsRedrawRect(const gfx::Rect& damage_rect) {
   proxy_->SetNeedsRedraw(damage_rect);
 }
@@ skipping 97 matching lines @@
                        "has_trigger",
                        has_gpu_rasterization_trigger_);
 }
 
 void LayerTreeHost::SetViewportSize(const gfx::Size& device_viewport_size) {
   if (device_viewport_size == device_viewport_size_)
     return;
 
   device_viewport_size_ = device_viewport_size;
 
+  property_trees_.needs_rebuild = true;
   SetNeedsCommit();
 }
 
 void LayerTreeHost::SetTopControlsHeight(float height, bool shrink) {
   if (top_controls_height_ == height &&
       top_controls_shrink_blink_size_ == shrink)
     return;
 
   top_controls_height_ = height;
   top_controls_shrink_blink_size_ = shrink;
   SetNeedsCommit();
 }
 
 void LayerTreeHost::SetTopControlsShownRatio(float ratio) {
   if (top_controls_shown_ratio_ == ratio)
     return;
 
   top_controls_shown_ratio_ = ratio;
   SetNeedsCommit();
 }
 
 void LayerTreeHost::ApplyPageScaleDeltaFromImplSide(float page_scale_delta) {
   DCHECK(CommitRequested());
+  if (page_scale_delta == 1.f)
+    return;
   page_scale_factor_ *= page_scale_delta;
+  property_trees_.needs_rebuild = true;
 }
 
 void LayerTreeHost::SetPageScaleFactorAndLimits(float page_scale_factor,
                                                 float min_page_scale_factor,
                                                 float max_page_scale_factor) {
   if (page_scale_factor == page_scale_factor_ &&
       min_page_scale_factor == min_page_scale_factor_ &&
       max_page_scale_factor == max_page_scale_factor_)
     return;
 
   page_scale_factor_ = page_scale_factor;
   min_page_scale_factor_ = min_page_scale_factor;
   max_page_scale_factor_ = max_page_scale_factor;
+  property_trees_.needs_rebuild = true;
   SetNeedsCommit();
 }
 
 void LayerTreeHost::SetVisible(bool visible) {
   if (visible_ == visible)
     return;
   visible_ = visible;
   if (!visible)
     ReduceMemoryUsage();
   proxy_->SetVisible(visible);
@@ skipping 113 matching lines @@
       hud_layer_->PrepareForCalculateDrawProperties(
           device_viewport_size(), device_scale_factor_);
     }
 
     TRACE_EVENT0("cc", "LayerTreeHost::UpdateLayers::CalcDrawProps");
     bool can_render_to_separate_surface = true;
     // TODO(vmpstr): Passing 0 as the current render surface layer list id means
     // that we won't be able to detect if a layer is part of |update_list|.
     // Change this if this information is required.
     int render_surface_layer_list_id = 0;
-    PropertyTrees property_trees;
     LayerTreeHostCommon::CalcDrawPropsMainInputs inputs(
         root_layer, device_viewport_size(), gfx::Transform(),
         device_scale_factor_, page_scale_factor_, page_scale_layer,
         elastic_overscroll_, overscroll_elasticity_layer_.get(),
         GetRendererCapabilities().max_texture_size, settings_.can_use_lcd_text,
         settings_.layers_always_allowed_lcd_text,
         can_render_to_separate_surface,
         settings_.layer_transforms_should_scale_layer_contents,
         settings_.verify_property_trees, &update_list,
-        render_surface_layer_list_id, &property_trees);
+        render_surface_layer_list_id, &property_trees_);
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
   }
 
   // Reset partial texture update requests.
   partial_texture_update_requests_ = 0;
 
   bool did_paint_content = false;
   bool need_more_updates = false;
   PaintLayerContents(
       update_list, queue, &did_paint_content, &need_more_updates);
@@ skipping 292 matching lines @@
 
   partial_texture_update_requests_++;
   return true;
 }
 
 void LayerTreeHost::SetDeviceScaleFactor(float device_scale_factor) {
   if (device_scale_factor == device_scale_factor_)
     return;
   device_scale_factor_ = device_scale_factor;
 
+  property_trees_.needs_rebuild = true;
   SetNeedsCommit();
 }
 
 void LayerTreeHost::UpdateTopControlsState(TopControlsState constraints,
                                            TopControlsState current,
                                            bool animate) {
   // Top controls are only used in threaded mode.
   proxy_->ImplThreadTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&TopControlsManager::UpdateTopControlsState,
                  top_controls_manager_weak_ptr_,
                  constraints,
                  current,
                  animate));
 }
 
 void LayerTreeHost::AnimateLayers(base::TimeTicks monotonic_time) {
   if (!settings_.accelerated_animation_enabled)
     return;
 
-  if (animation_registrar_->AnimateLayers(monotonic_time))
-    animation_registrar_->UpdateAnimationState(true, NULL);
+  AnimationEventsVector events;
+  if (animation_registrar_->AnimateLayers(monotonic_time)) {
+    animation_registrar_->UpdateAnimationState(true, &events);
+    if (!events.empty())
+      property_trees_.needs_rebuild = true;
+  }
 }
 
 UIResourceId LayerTreeHost::CreateUIResource(UIResourceClient* client) {
   DCHECK(client);
 
   UIResourceId next_id = next_ui_resource_id_++;
   DCHECK(ui_resource_client_map_.find(next_id) ==
          ui_resource_client_map_.end());
 
   bool resource_lost = false;
@@ skipping 119 matching lines @@
     const BeginFrameArgs& args) const {
   client_->SendBeginFramesToChildren(args);
 }
 
 void LayerTreeHost::SetAuthoritativeVSyncInterval(
     const base::TimeDelta& interval) {
   proxy_->SetAuthoritativeVSyncInterval(interval);
 }
 
 }  // namespace cc