Keeping track of descendants that draw content instead of recalcualting

cc/trees/occlusion_tracker_unittest.cc

 // Copyright 2012 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/occlusion_tracker.h"
 
 #include "cc/animation/layer_animation_controller.h"
 #include "cc/base/math_util.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_impl.h"
@@ skipping 115 matching lines @@
     return ref;
   }
 
   static LayerPtrType PassLayerPtr(LayerPtrType* layer) {
     LayerPtrType ref(*layer);
     *layer = NULL;
     return ref;
   }
 
   static void DestroyLayer(LayerPtrType* layer) { *layer = NULL; }
+
+  static void UpdateData(LayerType* layerType) {}
 };
 
 struct OcclusionTrackerTestImplThreadTypes {
   typedef LayerImpl LayerType;
   typedef LayerTreeImpl HostType;
   typedef RenderSurfaceImpl RenderSurfaceType;
   typedef TestContentLayerImpl ContentLayerType;
   typedef scoped_ptr<LayerImpl> LayerPtrType;
   typedef scoped_ptr<ContentLayerType> ContentLayerPtrType;
   typedef LayerIterator<LayerImpl> TestLayerIterator;
   typedef OcclusionTracker<LayerImpl> OcclusionTrackerType;
 
   static LayerPtrType CreateLayer(HostType* host) {
     return LayerImpl::Create(host, next_layer_impl_id++);
   }
   static ContentLayerPtrType CreateContentLayer(HostType* host) {
     return make_scoped_ptr(new ContentLayerType(host, next_layer_impl_id++));
   }
   static int next_layer_impl_id;
 
   static LayerPtrType PassLayerPtr(LayerPtrType* layer) {
     return layer->Pass();
   }
 
   static LayerPtrType PassLayerPtr(ContentLayerPtrType* layer) {
     return layer->PassAs<LayerType>();
   }
 
   static void DestroyLayer(LayerPtrType* layer) { layer->reset(); }
+
+  static void UpdateData(LayerType* layer) {

[danakj, 2014/07/17 17:21:26]

Let's give this a more descriptive name. How about RecursiveUpdateNumChildren?

[awoloszyn, 2014/07/17 20:45:01]

Done.

+    FakeLayerTreeHostImpl::RecursiveUpdateNumChildren(layer);
+  }
 };
 
 int OcclusionTrackerTestImplThreadTypes::next_layer_impl_id = 1;
 
 template <typename Types> class OcclusionTrackerTest : public testing::Test {
  protected:
   explicit OcclusionTrackerTest(bool opaque_layers)
       : opaque_layers_(opaque_layers), host_(FakeLayerTreeHost::Create()) {}
 
   virtual void RunMyTest() = 0;
@@ skipping 122 matching lines @@
         CopyOutputRequest::CreateBitmapRequest(base::Bind(
             &OcclusionTrackerTest<Types>::CopyOutputCallback,
             base::Unretained(this))));
     layer->PassCopyRequests(&requests);
   }
 
   void CalcDrawEtc(TestContentLayerImpl* root) {
     DCHECK(root == root_.get());
     DCHECK(!root->render_surface());
 
+    Types::UpdateData(root);
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
         root, root->bounds(), &render_surface_layer_list_impl_);
     inputs.can_adjust_raster_scales = true;
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
     layer_iterator_ = layer_iterator_begin_ =
         Types::TestLayerIterator::Begin(&render_surface_layer_list_impl_);
   }
 
   void CalcDrawEtc(TestContentLayer* root) {
@@ skipping 3232 matching lines @@
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_inside_target().ToString());
   }
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestHiddenCopyRequestDoesNotOcclude)
 
 }  // namespace
 }  // namespace cc