cc: DelegatedRendererLayer creates a ChildId with the ResourceProvider

cc/test/layer_tree_test_common.cc

Index: cc/test/layer_tree_test_common.cc
diff --git a/cc/test/layer_tree_test_common.cc b/cc/test/layer_tree_test_common.cc
index 0100135ded1710a24dbcb1e466aa6f7f9bfd8d67..2240279769602a02326b67e08d14edddd7989334 100644
--- a/cc/test/layer_tree_test_common.cc
+++ b/cc/test/layer_tree_test_common.cc
@@ -78,6 +78,10 @@ void MockLayerTreeHostImpl::commitComplete()
 {
     LayerTreeHostImpl::commitComplete();
     m_testHooks->commitCompleteOnThread(this);
+
+    if (!settings().implSidePainting)
+        m_testHooks->treeActivatedOnThread(this);

[piman, 2013/02/26 22:49:21]

Should this be before LayerTreeHostImpl::commitComplete? The assumption is that
activation happens in finishCommitOnImplThread, which is called before
commitComplete.

[danakj, 2013/02/26 22:56:54]

It could be commit complete - they're equal at the moment. But I think this will
remain true forever, whereas commit complete is true only if we block commit?

[piman, 2013/02/26 23:19:21]

This part is only relevant for non-impl-side-painting I guess - I assume when we
remove non-impl-side-painting, this code would go away too. I'm just trying to
see if we can preserve the order of the callbacks so that if we inspect state
from either of the callbacks, it's consistent.
If it doesn't matter, then feel free to land as is.

[danakj, 2013/02/26 23:32:55]

Oh sorry I replied about a completely different line of code... Yes this goes
away when implSidePainting is always true.

You're absolutely right. However, with impl painting on, the tree is activated
after commit complete. Creating a test environment where different settings call
things in different order is really horrible, so I prefer to lie here and do it
after commitComplete - same as with impl painting. It should be safe because it
just delays the activate notification, the tree is definitely activated when
this is called.

(For example theres lots of callbacks thread proxy does but single thread proxy
doesn't which makes testing both modes a lot trickier than it should be. I'm
scarred from this.)

+
 }
 
 bool MockLayerTreeHostImpl::prepareToDraw(FrameData& frame)
@@ -94,13 +98,25 @@ void MockLayerTreeHostImpl::drawLayers(FrameData& frame)
     m_testHooks->drawLayersOnThread(this);
 }
 
-void MockLayerTreeHostImpl::activatePendingTreeIfNeeded()
+bool MockLayerTreeHostImpl::activatePendingTreeIfNeeded()
 {
     if (!pendingTree())
-        return;
+        return false;
+
+    if (!m_testHooks->canActivatePendingTree())
+        return false;
 
-    if (m_testHooks->canActivatePendingTree())
-        activatePendingTree();
+    bool activated = LayerTreeHostImpl::activatePendingTreeIfNeeded();
+    if (activated)
+        m_testHooks->treeActivatedOnThread(this);
+    return activated;
+}
+
+bool MockLayerTreeHostImpl::initializeRenderer(scoped_ptr<OutputSurface> outputSurface)
+{
+    bool success = LayerTreeHostImpl::initializeRenderer(outputSurface.Pass());
+    m_testHooks->initializedRendererOnThread(this, success);
+    return success;
 }
 
 void MockLayerTreeHostImpl::animateLayers(base::TimeTicks monotonicTime, base::Time wallClockTime)