cc: Add CHECKs for diagnosing invalid property tree indices post-commit.

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 45 matching lines @@
 #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 {
+namespace {
+
+void EnsureValidIndicesOnLayer(Layer* layer, PropertyTrees* property_trees) {
+  CHECK_EQ(property_trees->sequence_number,
+           layer->property_tree_sequence_number());
+  CHECK(property_trees->transform_tree.Node(layer->transform_tree_index()));
+  CHECK(property_trees->clip_tree.Node(layer->clip_tree_index()));
+  CHECK(property_trees->effect_tree.Node(layer->effect_tree_index()));
+  CHECK(property_trees->scroll_tree.Node(layer->scroll_tree_index()));
+}
+
+void EnsureValidPropertyTreeState(LayerTreeHost* host) {
+  // Temporary check to debug crbug.com/726423. The property tree indices on
+  // the LayerTreeImpl should be valid after all state synchronization has
+  // finished.
+  for (auto* layer : *host)
+    EnsureValidIndicesOnLayer(layer, host->property_trees());
+
+  for (auto id : host->property_trees()->effect_tree.mask_layer_ids())
+    EnsureValidIndicesOnLayer(host->LayerById(id), host->property_trees());
+}
+
+}  // namespace
 
 LayerTreeHost::InitParams::InitParams() {}
 
 LayerTreeHost::InitParams::~InitParams() {}
 
 std::unique_ptr<LayerTreeHost> LayerTreeHost::CreateThreaded(
     scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner,
     InitParams* params) {
   DCHECK(params->main_task_runner.get());
   DCHECK(impl_task_runner.get());
@@ skipping 221 matching lines @@
     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());
 
+  EnsureValidPropertyTreeState(this);
+
   if (needs_full_tree_sync_)
     TreeSynchronizer::SynchronizeTrees(root_layer(), sync_tree);
 
   // Track the navigation state before pushing properties since it overwrites
   // the |content_source_id_| on the sync tree.
   bool did_navigate = content_source_id_ != sync_tree->content_source_id();
   if (did_navigate)
     host_impl->ClearImageCacheOnNavigation();
 
   {
@@ skipping 421 matching lines @@
           "cc", "LayerTreeHostInProcess::UpdateLayers_BuiltPropertyTrees",
           TRACE_EVENT_SCOPE_THREAD, "property_trees",
           property_trees->AsTracedValue());
     } else {
       TRACE_EVENT_INSTANT1(
           "cc", "LayerTreeHostInProcess::UpdateLayers_ReceivedPropertyTrees",
           TRACE_EVENT_SCOPE_THREAD, "property_trees",
           property_trees->AsTracedValue());
     }
 
-    // Temporary check to debug crbug.com/726423. The property tree indices on
-    // the LayerTreeImpl should be valid after all state synchronization has
-    // finished.
-    for (auto* layer : *this) {
-      CHECK(property_trees_.transform_tree.Node(layer->transform_tree_index()));
-      CHECK(property_trees_.clip_tree.Node(layer->clip_tree_index()));
-      CHECK(property_trees_.effect_tree.Node(layer->effect_tree_index()));
-      CHECK(property_trees_.scroll_tree.Node(layer->scroll_tree_index()));
-    }
-
     draw_property_utils::UpdatePropertyTrees(this, property_trees);
     draw_property_utils::FindLayersThatNeedUpdates(this, property_trees,
                                                    &update_layer_list);
   }
 
+  EnsureValidPropertyTreeState(this);
+
   bool content_is_suitable_for_gpu = true;
   bool did_paint_content =
       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;
     }
@@ skipping 713 matching lines @@
 
 void LayerTreeHost::SetHasCopyRequest(bool has_copy_request) {
   has_copy_request_ = has_copy_request;
 }
 
 void LayerTreeHost::RequestBeginMainFrameNotExpected(bool new_state) {
   proxy_->RequestBeginMainFrameNotExpected(new_state);
 }
 
 }  // namespace cc