Implement a method to access the non-composited content root layer picture pile.

cc/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/layer_tree_host.h"
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "cc/animation_registrar.h"
 #include "cc/font_atlas.h"
 #include "cc/heads_up_display_layer.h"
 #include "cc/heads_up_display_layer_impl.h"
 #include "cc/layer.h"
 #include "cc/layer_animation_controller.h"
 #include "cc/layer_iterator.h"
 #include "cc/layer_tree_host_client.h"
 #include "cc/layer_tree_host_common.h"
 #include "cc/layer_tree_host_impl.h"
 #include "cc/layer_tree_impl.h"
 #include "cc/math_util.h"
 #include "cc/occlusion_tracker.h"
 #include "cc/overdraw_metrics.h"
+#include "cc/picture_layer.h"
+#include "cc/picture_pile_impl.h"
 #include "cc/single_thread_proxy.h"
 #include "cc/switches.h"
 #include "cc/thread.h"
 #include "cc/thread_proxy.h"
 #include "cc/tree_synchronizer.h"
 
 using namespace std;
 
 namespace {
 static int numLayerTreeInstances;
@@ skipping 857 matching lines @@
                 layer->notifyAnimationStarted(events[eventIndex], wallClockTime.ToDoubleT());
             else
                 layer->notifyAnimationFinished(wallClockTime.ToDoubleT());
         }
     }
 
     for (size_t childIndex = 0; childIndex < layer->children().size(); ++childIndex)
         setAnimationEventsRecursive(events, layer->children()[childIndex].get(), wallClockTime);
 }
 
+Layer* LayerTreeHost::getNonCompositedContentRootLayer() const
+{
+    // Non-composited content root is the first drawable layer we find
+    // in a breadth-first exploration from the root.

[enne (OOO), 2013/01/02 19:35:22]

Can you not just use an in-order traversal instead of this breadth-first search?

[Leandro Graciá Gil, 2013/01/02 19:50:46]

How is this in-order traversal defined given that the tree is not necessarily
binary? Do you mean a depth-first traversal visiting first the node and then its
children?

[enne (OOO), 2013/01/02 20:16:57]

Yeah, that's exactly what I was trying to say.

[Leandro Graciá Gil, 2013/01/03 20:32:10]

Done.

+    std::queue<Layer*> layers;
+    layers.push(m_rootLayer.get());
+
+    while (!layers.empty()) {
+        Layer* layer = layers.front();
+        layers.pop();
+
+        if (!layer)
+            return NULL;
+
+        if (layer->isDrawable() && layer->isPictureLayer())

[enne (OOO), 2013/01/02 19:35:22]

This is only going to be true if impl-side painting is turned on.  In other
cases, getNonCompositedContentRootLayer is not going to find anything.

[Leandro Graciá Gil, 2013/01/02 19:50:46]

This is ok for our use case as we'll always use impl-side painting, but I guess
not for a generic method. What should I do here then? If I remove isPictureLayer
it doesn't work.

[enne (OOO), 2013/01/02 20:16:57]

I think the right answer is to just not expose this function on LayerTreeHost. 
Instead, implement a function that returns you a PicturePileImpl from
LayerTreeHostImpl and do the walk there instead.

[Leandro Graciá Gil, 2013/01/03 20:32:10]

Done.

+            return layer;
+
+        for (LayerList::const_iterator it = layer->children().begin();
+             it != layer->children().end(); ++it) {
+            layers.push(it->get());
+        }
+    }
+
+    return NULL;
+}
+
+scoped_refptr<PicturePileImpl> LayerTreeHost::capturePicturePile(const Layer* layer)
+{
+    if (!layer || !layer->isPictureLayer())
+        return scoped_refptr<PicturePileImpl>();
+
+    return m_proxy->capturePicturePile(static_cast<const PictureLayer*>(layer));
+}
+
 }  // namespace cc