cc : Stop pushing properties not used by LayerImpl to LayerImpl (4)

cc/trees/tree_synchronizer.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/tree_synchronizer.h"
 
 #include <stddef.h>
 
 #include <set>
 
@@ skipping 107 matching lines @@
 }
 
 void SynchronizeTreesRecursive(OwnedLayerImplMap* old_layers,
                                LayerImpl* old_root,
                                LayerTreeImpl* tree_impl) {
   tree_impl->SetRootLayer(
       SynchronizeTreesRecursiveInternal(old_layers, old_root, tree_impl));
 }
 
 #if DCHECK_IS_ON()
-static void CheckScrollAndClipPointersForLayer(Layer* layer,
-                                               LayerImpl* layer_impl) {
-  DCHECK_EQ(!!layer, !!layer_impl);
+static void CheckScrollAndClipPointersForLayer(Layer* layer) {
   if (!layer)
     return;
 
-  // Having a scroll parent on the impl thread implies having one the main
-  // thread, too. The main thread may have a scroll parent that is not in the
-  // tree because it's been removed but not deleted. In this case, the layer
-  // impl will have no scroll parent. Same argument applies for clip parents and
-  // scroll/clip children.
-  DCHECK(!layer_impl->scroll_parent() || !!layer->scroll_parent());
-  DCHECK(!layer_impl->clip_parent() || !!layer->clip_parent());
-  DCHECK(!layer_impl->scroll_children() || !!layer->scroll_children());
-  DCHECK(!layer_impl->clip_children() || !!layer->clip_children());
-
-  if (layer_impl->scroll_parent())
-    DCHECK_EQ(layer->scroll_parent()->id(), layer_impl->scroll_parent()->id());
-
-  if (layer_impl->clip_parent())
-    DCHECK_EQ(layer->clip_parent()->id(), layer_impl->clip_parent()->id());
-
-  if (layer_impl->scroll_children()) {
+  if (layer->scroll_children()) {
     for (std::set<Layer*>::iterator it = layer->scroll_children()->begin();
          it != layer->scroll_children()->end(); ++it) {
       DCHECK_EQ((*it)->scroll_parent(), layer);
     }
-    for (std::set<LayerImpl*>::iterator it =
-             layer_impl->scroll_children()->begin();
-         it != layer_impl->scroll_children()->end(); ++it) {
-      DCHECK_EQ((*it)->scroll_parent(), layer_impl);
-    }
   }
 
-  if (layer_impl->clip_children()) {
+  if (layer->clip_children()) {
     for (std::set<Layer*>::iterator it = layer->clip_children()->begin();
          it != layer->clip_children()->end(); ++it) {
       DCHECK_EQ((*it)->clip_parent(), layer);
     }
-    for (std::set<LayerImpl*>::iterator it =
-             layer_impl->clip_children()->begin();
-         it != layer_impl->clip_children()->end(); ++it) {
-      DCHECK_EQ((*it)->clip_parent(), layer_impl);
-    }
   }
 }
 
-static void CheckScrollAndClipPointers(LayerTreeHost* host,
-                                       LayerTreeImpl* host_impl) {
-  for (auto* layer_impl : *host_impl) {
-    Layer* layer = host->LayerById(layer_impl->id());
-    CheckScrollAndClipPointersForLayer(layer, layer_impl);
-  }
+static void CheckScrollAndClipPointers(LayerTreeHost* host) {
+  for (auto* layer : *host)
+    CheckScrollAndClipPointersForLayer(layer);

[ajuma, 2016/04/27 21:57:21]

Since scroll and clip children aren't being pushed anymore, this checking
probably fits better in PropertyTreeBuilder. How about moving it there in a
follow-up?

[jaydasika, 2016/04/28 01:50:01]

Acknowledged.

 }
 #endif
 
 template <typename LayerType>
 static void PushLayerPropertiesInternal(
     std::unordered_set<LayerType*> layers_that_should_push_properties,
     LayerTreeImpl* impl_tree) {
   for (auto layer : layers_that_should_push_properties) {
     LayerImpl* layer_impl = impl_tree->LayerById(layer->id());
     DCHECK(layer_impl);
     layer->PushPropertiesTo(layer_impl);
   }
 }
 
 void TreeSynchronizer::PushLayerProperties(LayerTreeImpl* pending_tree,
                                            LayerTreeImpl* active_tree) {
   PushLayerPropertiesInternal(pending_tree->LayersThatShouldPushProperties(),
                               active_tree);
 }
 
 void TreeSynchronizer::PushLayerProperties(LayerTreeHost* host_tree,
                                            LayerTreeImpl* impl_tree) {
   PushLayerPropertiesInternal(host_tree->LayersThatShouldPushProperties(),
                               impl_tree);
 
 #if DCHECK_IS_ON()
-  if (host_tree->root_layer() && impl_tree->root_layer())
-    CheckScrollAndClipPointers(host_tree, impl_tree);
+  if (host_tree->root_layer())
+    CheckScrollAndClipPointers(host_tree);
 #endif
 }
 
 }  // namespace cc