Harmonize LayerTreeHost/LayerTreeHostImpl synchronization steps

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 272 matching lines @@
       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->SetNeedsPushProperties(); });
   }
 
   LayerTreeImpl* sync_tree = host_impl->sync_tree();
+  sync_tree->lifecycle().AdvanceTo(LayerTreeLifecycle::kBeginningSync);
 
   if (next_commit_forces_redraw_) {
     sync_tree->ForceRedrawNextActivation();
     next_commit_forces_redraw_ = false;
   }
   if (next_commit_forces_recalculate_raster_scales_) {
     sync_tree->ForceRecalculateRasterScales();
     next_commit_forces_recalculate_raster_scales_ = false;
   }
 
   sync_tree->set_source_frame_number(SourceFrameNumber());
 
   if (needs_full_tree_sync_)
     TreeSynchronizer::SynchronizeTrees(root_layer(), sync_tree);
 
-  PushPropertiesTo(sync_tree);
-
-  sync_tree->PassSwapPromises(swap_promise_manager_.TakeSwapPromises());
-
-  host_impl->SetHasGpuRasterizationTrigger(has_gpu_rasterization_trigger_);
-  host_impl->SetContentIsSuitableForGpuRasterization(
-      content_is_suitable_for_gpu_rasterization_);
-  RecordGpuRasterizationHistogram(host_impl);
-
-  host_impl->SetViewportSize(device_viewport_size_);
-  sync_tree->SetDeviceScaleFactor(device_scale_factor_);
-  host_impl->SetDebugState(debug_state_);
-
-  if (did_navigate_) {
-    did_navigate_ = false;
-    host_impl->ClearImageCacheOnNavigation();
-  }
-
-  sync_tree->set_ui_resource_request_queue(
-      ui_resource_manager_->TakeUIResourcesRequests());
-
   {
     TRACE_EVENT0("cc", "LayerTreeHostInProcess::PushProperties");
 
+    PushPropertyTreesTo(sync_tree);
+    sync_tree->lifecycle().AdvanceTo(LayerTreeLifecycle::kSyncedPropertyTrees);
+
     TreeSynchronizer::PushLayerProperties(this, sync_tree);
+    sync_tree->lifecycle().AdvanceTo(
+        LayerTreeLifecycle::kSyncedLayerProperties);
+
+    PushLayerTreePropertiesTo(sync_tree);
+    PushLayerTreeHostPropertiesTo(host_impl);
+
+    sync_tree->PassSwapPromises(swap_promise_manager_.TakeSwapPromises());
+
+    // TODO(pdr): Move this into PushPropertyTreesTo or introduce a lifecycle
+    // state for it.
+    sync_tree->SetDeviceScaleFactor(device_scale_factor_);
+
+    if (did_navigate_) {
+      did_navigate_ = false;
+      host_impl->ClearImageCacheOnNavigation();
+    }
+
+    sync_tree->set_ui_resource_request_queue(
+        ui_resource_manager_->TakeUIResourcesRequests());
 
     // This must happen after synchronizing property trees and after pushing
     // properties, which updates the clobber_active_value flag.
+    // TODO(pdr): Enforce this comment with DCHECKS and a lifecycle state.
     sync_tree->property_trees()->scroll_tree.PushScrollUpdatesFromMainThread(
         property_trees(), sync_tree);
 
     // This must happen after synchronizing property trees and after push
     // properties, which updates property tree indices, but before animation
     // host pushes properties as animation host push properties can change
     // Animation::InEffect and we want the old InEffect value for updating
     // property tree scrolling and animation.
+    // TODO(pdr): Enforce this comment with DCHECKS and a lifecycle state.
     bool is_impl_side_update = false;
     sync_tree->UpdatePropertyTreeScrollingAndAnimationFromMainThread(
         is_impl_side_update);
 
     TRACE_EVENT0("cc", "LayerTreeHostInProcess::AnimationHost::PushProperties");
     DCHECK(host_impl->mutator_host());
     mutator_host_->PushPropertiesTo(host_impl->mutator_host());
+
+    sync_tree->lifecycle().AdvanceTo(LayerTreeLifecycle::kNotSyncing);
   }
 
   // Transfer image decode requests to the impl thread.
   for (auto& request : queued_image_decodes_)
     host_impl->QueueImageDecode(std::move(request.first), request.second);
   queued_image_decodes_.clear();
 
   micro_benchmark_controller_.ScheduleImplBenchmarks(host_impl);
   property_trees_.ResetAllChangeTracking();
 }
 
+void LayerTreeHost::PushPropertyTreesTo(LayerTreeImpl* tree_impl) {
+  bool property_trees_changed_on_active_tree =
+      tree_impl->IsActiveTree() && tree_impl->property_trees()->changed;
+  // Property trees may store damage status. We preserve the sync tree damage
+  // status by pushing the damage status from sync tree property trees to main
+  // thread property trees or by moving it onto the layers.
+  if (root_layer_ && property_trees_changed_on_active_tree) {
+    if (property_trees_.sequence_number ==
+        tree_impl->property_trees()->sequence_number)
+      tree_impl->property_trees()->PushChangeTrackingTo(&property_trees_);
+    else
+      tree_impl->MoveChangeTrackingToLayers();
+  }
+
+  tree_impl->SetPropertyTrees(&property_trees_);
+}
+
 void LayerTreeHost::WillCommit() {
   swap_promise_manager_.WillCommit();
   client_->WillCommit();
 }
 
 
 void LayerTreeHost::UpdateDeferCommitsInternal() {
   proxy_->SetDeferCommits(defer_commits_ ||
                           (settings_.enable_surface_synchronization &&
                            !local_surface_id_.is_valid()));
@@ skipping 743 matching lines @@
   needs_full_tree_sync_ = true;
   property_trees_.needs_rebuild = true;
   SetNeedsCommit();
 }
 
 void LayerTreeHost::SetPropertyTreesNeedRebuild() {
   property_trees_.needs_rebuild = true;
   SetNeedsUpdateLayers();
 }
 
-void LayerTreeHost::PushPropertiesTo(LayerTreeImpl* tree_impl) {
+void LayerTreeHost::PushLayerTreePropertiesTo(LayerTreeImpl* tree_impl) {
   tree_impl->set_needs_full_tree_sync(needs_full_tree_sync_);
   needs_full_tree_sync_ = false;
 
   if (hud_layer_.get()) {
     LayerImpl* hud_impl = tree_impl->LayerById(hud_layer_->id());
     tree_impl->set_hud_layer(static_cast<HeadsUpDisplayLayerImpl*>(hud_impl));
   } else {
     tree_impl->set_hud_layer(nullptr);
   }
 
@@ skipping 17 matching lines @@
         page_scale_layer_->id(), inner_viewport_scroll_layer_->id(),
         outer_viewport_scroll_layer_ ? outer_viewport_scroll_layer_->id()
                                      : Layer::INVALID_ID);
     DCHECK(inner_viewport_scroll_layer_->IsContainerForFixedPositionLayers());
   } else {
     tree_impl->ClearViewportLayers();
   }
 
   tree_impl->RegisterSelection(selection_);
 
-  bool property_trees_changed_on_active_tree =
-      tree_impl->IsActiveTree() && tree_impl->property_trees()->changed;
-  // Property trees may store damage status. We preserve the sync tree damage
-  // status by pushing the damage status from sync tree property trees to main
-  // thread property trees or by moving it onto the layers.
-  if (root_layer_ && property_trees_changed_on_active_tree) {
-    if (property_trees_.sequence_number ==
-        tree_impl->property_trees()->sequence_number)
-      tree_impl->property_trees()->PushChangeTrackingTo(&property_trees_);
-    else
-      tree_impl->MoveChangeTrackingToLayers();
-  }
-  // Setting property trees must happen before pushing the page scale.
-  tree_impl->SetPropertyTrees(&property_trees_);
-
   tree_impl->PushPageScaleFromMainThread(
       page_scale_factor_, min_page_scale_factor_, max_page_scale_factor_);
 
   tree_impl->set_browser_controls_shrink_blink_size(
       browser_controls_shrink_blink_size_);
   tree_impl->set_top_controls_height(top_controls_height_);
   tree_impl->set_bottom_controls_height(bottom_controls_height_);
   tree_impl->PushBrowserControlsFromMainThread(top_controls_shown_ratio_);
   tree_impl->elastic_overscroll()->PushFromMainThread(elastic_overscroll_);
   if (tree_impl->IsActiveTree())
@@ skipping 10 matching lines @@
   if (pending_page_scale_animation_) {
     tree_impl->SetPendingPageScaleAnimation(
         std::move(pending_page_scale_animation_));
   }
 
   DCHECK(!tree_impl->ViewportSizeInvalid());
 
   tree_impl->set_has_ever_been_drawn(false);
 }
 
+void LayerTreeHost::PushLayerTreeHostPropertiesTo(
+    LayerTreeHostImpl* host_impl) {
+  host_impl->SetHasGpuRasterizationTrigger(has_gpu_rasterization_trigger_);
+  host_impl->SetContentIsSuitableForGpuRasterization(
+      content_is_suitable_for_gpu_rasterization_);
+  RecordGpuRasterizationHistogram(host_impl);
+
+  host_impl->SetViewportSize(device_viewport_size_);
+  host_impl->SetDebugState(debug_state_);
+}
+
 Layer* LayerTreeHost::LayerByElementId(ElementId element_id) const {
   auto iter = element_layers_map_.find(element_id);
   return iter != element_layers_map_.end() ? iter->second : nullptr;
 }
 
 void LayerTreeHost::RegisterElement(ElementId element_id,
                                     ElementListType list_type,
                                     Layer* layer) {
   if (layer->element_id()) {
     element_layers_map_[layer->element_id()] = layer;
@@ skipping 238 matching lines @@
 void LayerTreeHost::SetNeedsDisplayOnAllLayers() {
   for (auto* layer : *this)
     layer->SetNeedsDisplay();
 }
 
 void LayerTreeHost::SetHasCopyRequest(bool has_copy_request) {
   has_copy_request_ = has_copy_request;
 }
 
 }  // namespace cc