cc: Return resources to child compositor via a Callback.

cc/trees/layer_tree_host_unittest_delegated.cc

 // Copyright 2013 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 <algorithm>
 
 #include "base/bind.h"
+#include "base/location.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "base/time/time.h"
 #include "cc/layers/delegated_renderer_layer.h"
 #include "cc/layers/delegated_renderer_layer_client.h"
 #include "cc/layers/delegated_renderer_layer_impl.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/compositor_frame_ack.h"
 #include "cc/output/delegated_frame_data.h"
 #include "cc/quads/render_pass_draw_quad.h"
@@ skipping 738 matching lines @@
     const ResourceProvider::ResourceIdMap& map =
         host_impl->resource_provider()->GetChildToParentMap(
             delegated_impl->ChildId());
 
     // Both frames' resources should be in the parent's resource provider.
     EXPECT_EQ(2u, map.size());
     EXPECT_EQ(1u, map.count(999));
     EXPECT_EQ(1u, map.count(555));
 
     EXPECT_EQ(2u, delegated_impl->Resources().size());
-    EXPECT_EQ(1u, delegated_impl->Resources().count(map.find(999)->second));
-    EXPECT_EQ(1u, delegated_impl->Resources().count(map.find(555)->second));
+    EXPECT_EQ(1u, delegated_impl->Resources().count(999));
+    EXPECT_EQ(1u, delegated_impl->Resources().count(555));
 
     EndTest();
   }
 
   virtual void AfterTest() OVERRIDE {}
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDelegatedTestMergeResources);
 
 class LayerTreeHostDelegatedTestRemapResourcesInQuads
@@ skipping 63 matching lines @@
       case 1:
         // Generate a frame with two resources in it.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 999);
         AddTransferableResource(frame.get(), 999);
         AddTextureQuad(frame.get(), 555);
         AddTransferableResource(frame.get(), 555);
         delegated_->SetFrameData(frame.Pass());
         break;
       case 2:
-        // Retrieve unused resources to the main thread.
-        // TODO(danakj): Shouldn't need to commit to get resources.
-        layer_tree_host()->SetNeedsCommit();
-        return;
-      case 3:
         // All of the resources are in use.
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
 
         // Keep using 999 but stop using 555.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 999);
+        AddTransferableResource(frame.get(), 999);
         AddTextureQuad(frame.get(), 444);
         AddTransferableResource(frame.get(), 444);
         delegated_->SetFrameData(frame.Pass());
         break;
-      case 4:
-        // Retrieve unused resources to the main thread.
-        // TODO(danakj): Shouldn't need to commit to get resources.
-        layer_tree_host()->SetNeedsCommit();
-        return;
-      case 5:
+      case 3:
         // 555 is no longer in use.
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
         {
           unsigned expected[] = {555};
           EXPECT_RESOURCES(expected, resources);
         }
 
         // Stop using any resources.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         delegated_->SetFrameData(frame.Pass());
         break;
-      case 6:
+      case 4:
         // Postpone collecting resources for a frame. They should still be there
         // the next frame.
         layer_tree_host()->SetNeedsCommit();
         return;
-      case 7:
-        // 444 and 999 are no longer in use.
+      case 5:
+        // 444 and 999 are no longer in use. We sent two refs to 999, so we
+        // should get two back.
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
         {
-          unsigned expected[] = {444, 999};
+          unsigned expected[] = {444, 999, 999};
           EXPECT_RESOURCES(expected, resources);
         }
         EndTest();
         break;
     }
 
     // Resource are never immediately released.
     ReturnedResourceArray empty_resources;
     delegated_->TakeUnusedResourcesForChildCompositor(&empty_resources);
     EXPECT_TRUE(empty_resources.empty());
@@ skipping 28 matching lines @@
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 999);
         AddTransferableResource(frame.get(), 999);
         AddTextureQuad(frame.get(), 555);
         AddTransferableResource(frame.get(), 555);
         AddTextureQuad(frame.get(), 444);
         AddTransferableResource(frame.get(), 444);
         delegated_->SetFrameData(frame.Pass());
         break;
       case 2:
-        // Retrieve unused resources to the main thread.
-        // TODO(danakj): Shouldn't need to commit to get resources.
-        layer_tree_host()->SetNeedsCommit();
-        return;
-      case 3:
         // All of the resources are in use.
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
 
         // Keep using 999 but stop using 555 and 444.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 999);
+        AddTransferableResource(frame.get(), 999);
         delegated_->SetFrameData(frame.Pass());
 
         // Resource are not immediately released.
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
 
         // Now using 555 and 444 again, but not 999.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 555);
+        AddTransferableResource(frame.get(), 555);
         AddTextureQuad(frame.get(), 444);
+        AddTransferableResource(frame.get(), 444);
         delegated_->SetFrameData(frame.Pass());
         break;
-      case 4:
-        // Retrieve unused resources to the main thread.
-        // TODO(danakj): Shouldn't need to commit to get resources.
-        layer_tree_host()->SetNeedsCommit();
-        return;
-      case 5:
-        // The 999 resource is the only unused one.
+      case 3:
+        // The 999 resource is the only unused one. Two references were sent, so
+        // two should be returned.
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
         {
-          unsigned expected[] = {999};
+          unsigned expected[] = {999, 999};
           EXPECT_RESOURCES(expected, resources);
         }
         EndTest();
         break;
     }
   }
 
   virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
                                    bool result) OVERRIDE {
     ReturnUnusedResourcesFromParent(host_impl);
@@ skipping 22 matching lines @@
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 999);
         AddTransferableResource(frame.get(), 999);
         AddTextureQuad(frame.get(), 555);
         AddTransferableResource(frame.get(), 555);
         AddTextureQuad(frame.get(), 444);
         AddTransferableResource(frame.get(), 444);
         delegated_->SetFrameData(frame.Pass());
         break;
       case 2:
-        // Retrieve unused resources to the main thread.
-        // TODO(danakj): Shouldn't need to commit to get resources.
-        layer_tree_host()->SetNeedsCommit();
-        return;
-      case 3:
         // All of the resources are in use.
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
 
         // Keep using 999 but stop using 555 and 444.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 999);
+        AddTransferableResource(frame.get(), 999);
         delegated_->SetFrameData(frame.Pass());
 
         // Resource are not immediately released.
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
 
         // The parent compositor (this one) does a commit.
         break;
-      case 4:
-        // Retrieve unused resources to the main thread.
-        // TODO(danakj): Shouldn't need to commit to get resources.
-        layer_tree_host()->SetNeedsCommit();
-        return;
-      case 5:
+      case 3:
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
         {
           unsigned expected[] = {444, 555};
           EXPECT_RESOURCES(expected, resources);
         }
 
-        // The child compositor sends a frame before receiving an for the
-        // second frame. It uses 999, 444, and 555 again.
+        // The child compositor sends a frame referring to resources not in the
+        // frame.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 999);
         AddTextureQuad(frame.get(), 555);
         AddTextureQuad(frame.get(), 444);
         delegated_->SetFrameData(frame.Pass());
         break;
     }
   }
 
   virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
-    if (host_impl->active_tree()->source_frame_number() != 5)
+    if (host_impl->active_tree()->source_frame_number() != 3)
       return;
 
     LayerImpl* root_impl = host_impl->active_tree()->root_layer();
     FakeDelegatedRendererLayerImpl* delegated_impl =
         static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]);
 
     const ResourceProvider::ResourceIdMap& map =
         host_impl->resource_provider()->GetChildToParentMap(
             delegated_impl->ChildId());
 
     // The bad frame should be dropped. So we should only have one quad (the
     // one with resource 999) on the impl tree. And only 999 will be present
     // in the parent's resource provider.
     EXPECT_EQ(1u, map.size());
     EXPECT_EQ(1u, map.count(999));
 
     EXPECT_EQ(1u, delegated_impl->Resources().size());
-    EXPECT_EQ(1u, delegated_impl->Resources().count(map.find(999)->second));
+    EXPECT_EQ(1u, delegated_impl->Resources().count(999));
 
     const RenderPass* pass = delegated_impl->RenderPassesInDrawOrder()[0];
     EXPECT_EQ(1u, pass->quad_list.size());
     const TextureDrawQuad* quad = TextureDrawQuad::MaterialCast(
         pass->quad_list[0]);
     EXPECT_EQ(map.find(999)->second, quad->resource_id);
 
     EndTest();
   }
 
@@ skipping 25 matching lines @@
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 999);
         AddTransferableResource(frame.get(), 999);
         AddTextureQuad(frame.get(), 555);
         AddTransferableResource(frame.get(), 555);
         AddTextureQuad(frame.get(), 444);
         AddTransferableResource(frame.get(), 444);
         delegated_->SetFrameData(frame.Pass());
         break;
       case 2:
-        // Retrieve unused resources to the main thread.
-        // TODO(danakj): Shouldn't need to commit to get resources.
-        layer_tree_host()->SetNeedsCommit();
-        return;
-      case 3:
         // All of the resources are in use.
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
 
         // Keep using 999 but stop using 555 and 444.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 999);
         AddTransferableResource(frame.get(), 999);
         delegated_->SetFrameData(frame.Pass());
 
         // Resource are not immediately released.
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
 
         // The parent compositor (this one) does a commit.
         break;
-      case 4:
-        // Retrieve unused resources to the main thread.
-        // TODO(danakj): Shouldn't need to commit to get resources.
-        layer_tree_host()->SetNeedsCommit();
-        return;
-      case 5:
+      case 3:
         // The child compositor sends a frame before taking resources back
         // from the previous commit. This frame makes use of the resources 555
         // and 444, which were just released during commit.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 999);
         AddTransferableResource(frame.get(), 999);
         AddTextureQuad(frame.get(), 555);
         AddTransferableResource(frame.get(), 555);
         AddTextureQuad(frame.get(), 444);
         AddTransferableResource(frame.get(), 444);
         delegated_->SetFrameData(frame.Pass());
 
         // The resources are used by the new frame but are returned anyway since
         // we passed them again.
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
         {
           unsigned expected[] = {444, 555};
           EXPECT_RESOURCES(expected, resources);
         }
         break;
-      case 6:
-        // Retrieve unused resources to the main thread.
-        // TODO(danakj): Shouldn't need to commit to get resources.
-        layer_tree_host()->SetNeedsCommit();
-        return;
-      case 7:
+      case 4:
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
         EndTest();
         break;
     }
   }
 
   virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
-    if (host_impl->active_tree()->source_frame_number() != 5)
+    if (host_impl->active_tree()->source_frame_number() != 3)
       return;
 
     LayerImpl* root_impl = host_impl->active_tree()->root_layer();
     FakeDelegatedRendererLayerImpl* delegated_impl =
         static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]);
 
     const ResourceProvider::ResourceIdMap& map =
         host_impl->resource_provider()->GetChildToParentMap(
             delegated_impl->ChildId());
 
     // The third frame has all of the resources in it again, the delegated
     // renderer layer should continue to own the resources for it.
     EXPECT_EQ(3u, map.size());
     EXPECT_EQ(1u, map.count(999));
     EXPECT_EQ(1u, map.count(555));
     EXPECT_EQ(1u, map.count(444));
 
     EXPECT_EQ(3u, delegated_impl->Resources().size());
-    EXPECT_EQ(1u, delegated_impl->Resources().count(map.find(999)->second));
-    EXPECT_EQ(1u, delegated_impl->Resources().count(map.find(555)->second));
-    EXPECT_EQ(1u, delegated_impl->Resources().count(map.find(444)->second));
+    EXPECT_EQ(1u, delegated_impl->Resources().count(999));
+    EXPECT_EQ(1u, delegated_impl->Resources().count(555));
+    EXPECT_EQ(1u, delegated_impl->Resources().count(444));
 
     const RenderPass* pass = delegated_impl->RenderPassesInDrawOrder()[0];
     EXPECT_EQ(3u, pass->quad_list.size());
     const TextureDrawQuad* quad1 = TextureDrawQuad::MaterialCast(
         pass->quad_list[0]);
     EXPECT_EQ(map.find(999)->second, quad1->resource_id);
     const TextureDrawQuad* quad2 = TextureDrawQuad::MaterialCast(
         pass->quad_list[1]);
     EXPECT_EQ(map.find(555)->second, quad2->resource_id);
     const TextureDrawQuad* quad3 = TextureDrawQuad::MaterialCast(
@@ skipping 28 matching lines @@
       case 1:
         // Generate a frame with some resources in it.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 999);
         AddTransferableResource(frame.get(), 999);
         AddTextureQuad(frame.get(), 555);
         AddTransferableResource(frame.get(), 555);
         delegated_->SetFrameData(frame.Pass());
         break;
       case 2:
-        // Retrieve unused resources to the main thread.
-        // TODO(danakj): Shouldn't need to commit to get resources.
-        layer_tree_host()->SetNeedsCommit();
-        return;
-      case 3:
         // All of the resources are in use.
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
 
         // Generate a bad frame with a resource the layer doesn't have. The
         // 885 and 775 resources are unknown, while ownership of the legit 444
         // resource is passed in here. The bad frame does not use any of the
         // previous resources, 999 or 555.
         // A bad quad is present both before and after the good quad.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 885);
         AddTextureQuad(frame.get(), 444);
         AddTransferableResource(frame.get(), 444);
         AddTextureQuad(frame.get(), 775);
         delegated_->SetFrameData(frame.Pass());
 
         // The parent compositor (this one) does a commit.
         break;
-      case 4:
-        // Retrieve unused resources to the main thread.
-        // TODO(danakj): Shouldn't need to commit to get resources.
-        layer_tree_host()->SetNeedsCommit();
-        return;
-      case 5:
+      case 3:
         // The bad frame's resource is given back to the child compositor.
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
         {
           unsigned expected[] = {444};
           EXPECT_RESOURCES(expected, resources);
         }
 
         // Now send a good frame with 999 again.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 999);
         delegated_->SetFrameData(frame.Pass());
         break;
-      case 6:
-        // Retrieve unused resources to the main thread.
-        // TODO(danakj): Shouldn't need to commit to get resources.
-        layer_tree_host()->SetNeedsCommit();
-        return;
-      case 7:
+      case 4:
         // The unused 555 from the last good frame is now released.
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
         {
           unsigned expected[] = {555};
           EXPECT_RESOURCES(expected, resources);
         }
 
         EndTest();
         break;
     }
@@ skipping 16 matching lines @@
 
     switch (host_impl->active_tree()->source_frame_number()) {
       case 1: {
         // We have the first good frame with just 990 and 555 in it.
         // layer.
         EXPECT_EQ(2u, map.size());
         EXPECT_EQ(1u, map.count(999));
         EXPECT_EQ(1u, map.count(555));
 
         EXPECT_EQ(2u, delegated_impl->Resources().size());
-        EXPECT_EQ(1u, delegated_impl->Resources().count(map.find(999)->second));
-        EXPECT_EQ(1u, delegated_impl->Resources().count(map.find(555)->second));
+        EXPECT_EQ(1u, delegated_impl->Resources().count(999));
+        EXPECT_EQ(1u, delegated_impl->Resources().count(555));
 
         const RenderPass* pass = delegated_impl->RenderPassesInDrawOrder()[0];
         EXPECT_EQ(2u, pass->quad_list.size());
         const TextureDrawQuad* quad1 = TextureDrawQuad::MaterialCast(
             pass->quad_list[0]);
         EXPECT_EQ(map.find(999)->second, quad1->resource_id);
         const TextureDrawQuad* quad2 = TextureDrawQuad::MaterialCast(
             pass->quad_list[1]);
         EXPECT_EQ(map.find(555)->second, quad2->resource_id);
         break;
       }
-      case 3: {
+      case 2: {
         // We only keep resources from the last valid frame.
         EXPECT_EQ(2u, map.size());
         EXPECT_EQ(1u, map.count(999));
         EXPECT_EQ(1u, map.count(555));
 
         EXPECT_EQ(2u, delegated_impl->Resources().size());
-        EXPECT_EQ(1u, delegated_impl->Resources().count(map.find(999)->second));
-        EXPECT_EQ(1u, delegated_impl->Resources().count(map.find(555)->second));
+        EXPECT_EQ(1u, delegated_impl->Resources().count(999));
+        EXPECT_EQ(1u, delegated_impl->Resources().count(555));
 
         // The bad frame is dropped though, we still have the frame with 999 and
         // 555 in it.
         const RenderPass* pass = delegated_impl->RenderPassesInDrawOrder()[0];
         EXPECT_EQ(2u, pass->quad_list.size());
         const TextureDrawQuad* quad1 = TextureDrawQuad::MaterialCast(
             pass->quad_list[0]);
         EXPECT_EQ(map.find(999)->second, quad1->resource_id);
         const TextureDrawQuad* quad2 = TextureDrawQuad::MaterialCast(
             pass->quad_list[1]);
         EXPECT_EQ(map.find(555)->second, quad2->resource_id);
         break;
       }
-      case 5:
-        // Resources given to our parent compositor will be returned now, but
-        // the DelegatedRendererLayerImpl doesn't know about it until the next
-        // commit.
-        // TODO(danakj): Shouldn't need a commit to return resources to the
-        // DelegatedRendererLayerImpl or to the main thread.
-        break;
-      case 6: {
+      case 3: {
         // We have the new good frame with just 999 in it.
         EXPECT_EQ(1u, map.size());
         EXPECT_EQ(1u, map.count(999));
 
         EXPECT_EQ(1u, delegated_impl->Resources().size());
-        EXPECT_EQ(1u, delegated_impl->Resources().count(map.find(999)->second));
+        EXPECT_EQ(1u, delegated_impl->Resources().count(999));
 
         const RenderPass* pass = delegated_impl->RenderPassesInDrawOrder()[0];
         EXPECT_EQ(1u, pass->quad_list.size());
         const TextureDrawQuad* quad1 = TextureDrawQuad::MaterialCast(
             pass->quad_list[0]);
         EXPECT_EQ(map.find(999)->second, quad1->resource_id);
         break;
       }
     }
   }
@@ skipping 47 matching lines @@
 
     const ResourceProvider::ResourceIdMap& map =
         host_impl->resource_provider()->GetChildToParentMap(
             delegated_impl->ChildId());
 
     // The layer only held on to the resource that was used.
     EXPECT_EQ(1u, map.size());
     EXPECT_EQ(1u, map.count(555));
 
     EXPECT_EQ(1u, delegated_impl->Resources().size());
-    EXPECT_EQ(1u, delegated_impl->Resources().count(map.find(555)->second));
+    EXPECT_EQ(1u, delegated_impl->Resources().count(555));
   }
 
   virtual void AfterTest() OVERRIDE {}
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDelegatedTestUnnamedResource);
 
 class LayerTreeHostDelegatedTestDontLeakResource
     : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
  public:
   virtual void BeginTest() OVERRIDE {
     PostSetNeedsCommitToMainThread();
   }
 
-  virtual void DidCommit() OVERRIDE {
+  virtual void DidCommitAndDrawFrame() OVERRIDE {
     scoped_ptr<DelegatedFrameData> frame;
     ReturnedResourceArray resources;
 
     int next_source_frame_number = layer_tree_host()->source_frame_number();
     switch (next_source_frame_number) {
       case 1:
         // This frame includes two resources in it.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 999);
         AddTransferableResource(frame.get(), 999);
@@ skipping 13 matching lines @@
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
         {
           unsigned expected[] = {555, 999};
           EXPECT_RESOURCES(expected, resources);
         }
         // Send a frame with no resources in it.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         delegated_->SetFrameData(frame.Pass());
         break;
       case 3:
-        // The impl side will get back the resource at some point.
-        // TODO(piman): The test should work without this.
-        layer_tree_host()->SetNeedsCommit();
-        break;
-      case 4:
         // The now unused resource 555 should be returned.
         resources.clear();
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
         {
           unsigned expected[] = {555};
           EXPECT_RESOURCES(expected, resources);
         }
         EndTest();
         break;
     }
   }
 
   virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
     if (host_impl->active_tree()->source_frame_number() != 1)
       return;
 
     LayerImpl* root_impl = host_impl->active_tree()->root_layer();
     FakeDelegatedRendererLayerImpl* delegated_impl =
         static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]);
 
     const ResourceProvider::ResourceIdMap& map =
         host_impl->resource_provider()->GetChildToParentMap(
             delegated_impl->ChildId());
 
     // The layer only held on to the resource that was used.
     EXPECT_EQ(1u, map.size());
     EXPECT_EQ(1u, map.count(555));
 
     EXPECT_EQ(1u, delegated_impl->Resources().size());
-    EXPECT_EQ(1u, delegated_impl->Resources().count(map.find(555)->second));
+    EXPECT_EQ(1u, delegated_impl->Resources().count(555));
   }
 
   virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
                                    bool result) OVERRIDE {
     ReturnUnusedResourcesFromParent(host_impl);
   }
 
   virtual void AfterTest() OVERRIDE {}
 };
 
@@ skipping 18 matching lines @@
         delegated_->SetFrameData(frame.Pass());
         break;
       case 2:
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
 
         // 999 is in use in the grandparent compositor, generate a frame without
         // it present.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTextureQuad(frame.get(), 555);
+        AddTransferableResource(frame.get(), 555);
         delegated_->SetFrameData(frame.Pass());
         break;
       case 3:
         // Since 999 is in the grandparent it is not returned.
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
 
         // The impl side will get back the resource at some point.
-        // TODO(danakj): The test should work without this.
-        layer_tree_host()->SetNeedsCommit();
-        break;
-      case 4:
-        // 999 was returned from the grandparent and could be released.
-        delegated_->TakeUnusedResourcesForChildCompositor(&resources);
-        {
-          unsigned expected[] = {999};
-          EXPECT_RESOURCES(expected, resources);
-        }
-
-        EndTest();
+        ImplThreadTaskRunner()->PostTask(FROM_HERE,
+                                         receive_resource_on_thread_);
         break;
     }
   }
 
+  void ReceiveResourceOnThread(LayerTreeHostImpl* host_impl) {
+    LayerImpl* root_impl = host_impl->active_tree()->root_layer();
+    FakeDelegatedRendererLayerImpl* delegated_impl =
+        static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]);
+
+    const ResourceProvider::ResourceIdMap& map =
+        host_impl->resource_provider()->GetChildToParentMap(
+            delegated_impl->ChildId());
+
+    // Receive 999 back from the grandparent.
+    CompositorFrameAck ack;
+    output_surface()->ReturnResource(map.find(999)->second, &ack);
+    host_impl->ReclaimResources(&ack);
+    host_impl->OnSwapBuffersComplete();
+
+    // And then it should be released by the DelegatedRendererLayer.
+    MainThreadTaskRunner()->PostTask(
+        FROM_HERE,
+        base::Bind(&LayerTreeHostDelegatedTestResourceSentToParent::
+                        DidReceiveResourceOnMainThread,
+                   base::Unretained(this)));
+  }
+
+  void DidReceiveResourceOnMainThread() {
+    ReturnedResourceArray resources;
+
+    // 999 was returned from the grandparent and could be released.
+    delegated_->TakeUnusedResourcesForChildCompositor(&resources);
+    {
+      unsigned expected[] = {999};
+      EXPECT_RESOURCES(expected, resources);
+    }
+
+    EndTest();
+  }
+
   virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
     if (host_impl->active_tree()->source_frame_number() < 1)
       return;
 
     LayerImpl* root_impl = host_impl->active_tree()->root_layer();
     FakeDelegatedRendererLayerImpl* delegated_impl =
         static_cast<FakeDelegatedRendererLayerImpl*>(root_impl->children()[0]);
 
     const ResourceProvider::ResourceIdMap& map =
         host_impl->resource_provider()->GetChildToParentMap(
             delegated_impl->ChildId());
 
     switch (host_impl->active_tree()->source_frame_number()) {
       case 1: {
         EXPECT_EQ(2u, map.size());
         EXPECT_EQ(1u, map.count(999));
         EXPECT_EQ(1u, map.count(555));
 
         EXPECT_EQ(2u, delegated_impl->Resources().size());
-        EXPECT_EQ(1u, delegated_impl->Resources().count(map.find(999)->second));
-        EXPECT_EQ(1u, delegated_impl->Resources().count(map.find(555)->second));
+        EXPECT_EQ(1u, delegated_impl->Resources().count(999));
+        EXPECT_EQ(1u, delegated_impl->Resources().count(555));
 
         // The 999 resource will be sent to a grandparent compositor.
         break;
       }
       case 2: {
         EXPECT_EQ(2u, map.size());
         EXPECT_EQ(1u, map.count(999));
         EXPECT_EQ(1u, map.count(555));
 
         // 999 is in the parent, so not held by delegated renderer layer.
         EXPECT_EQ(1u, delegated_impl->Resources().size());
-        EXPECT_EQ(1u, delegated_impl->Resources().count(map.find(555)->second));
+        EXPECT_EQ(1u, delegated_impl->Resources().count(555));
 
-        // Receive 999 back from the grandparent.
-        CompositorFrameAck ack;
-        output_surface()->ReturnResource(map.find(999)->second, &ack);
-        host_impl->ReclaimResources(&ack);
-        host_impl->OnSwapBuffersComplete();
+        receive_resource_on_thread_ =
+            base::Bind(&LayerTreeHostDelegatedTestResourceSentToParent::
+                            ReceiveResourceOnThread,
+                       base::Unretained(this),
+                       host_impl);
         break;
       }
       case 3:
         // 999 should be released.
         EXPECT_EQ(1u, map.size());
         EXPECT_EQ(1u, map.count(555));
 
         EXPECT_EQ(1u, delegated_impl->Resources().size());
         EXPECT_EQ(1u, delegated_impl->Resources().count(map.find(555)->second));
         break;
     }
   }
 
   virtual void AfterTest() OVERRIDE {}
 
-  TransferableResource resource_in_grandparent;
+  base::Closure receive_resource_on_thread_;
 };
 
 SINGLE_AND_MULTI_THREAD_DELEGATING_RENDERER_TEST_F(
     LayerTreeHostDelegatedTestResourceSentToParent);
 
 class LayerTreeHostDelegatedTestCommitWithoutTake
     : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
  public:
   virtual void BeginTest() OVERRIDE {
     // Prevent drawing with resources that are sent to the grandparent.
@@ skipping 77 matching lines @@
             delegated_impl->ChildId());
 
     switch (host_impl->active_tree()->source_frame_number()) {
       case 1:
         EXPECT_EQ(3u, map.size());
         EXPECT_EQ(1u, map.count(999));
         EXPECT_EQ(1u, map.count(555));
         EXPECT_EQ(1u, map.count(444));
 
         EXPECT_EQ(3u, delegated_impl->Resources().size());
-        EXPECT_EQ(1u, delegated_impl->Resources().count(map.find(999)->second));
-        EXPECT_EQ(1u, delegated_impl->Resources().count(map.find(555)->second));
-        EXPECT_EQ(1u, delegated_impl->Resources().count(map.find(444)->second));
+        EXPECT_EQ(1u, delegated_impl->Resources().count(999));
+        EXPECT_EQ(1u, delegated_impl->Resources().count(555));
+        EXPECT_EQ(1u, delegated_impl->Resources().count(444));
         break;
       case 2:
         EXPECT_EQ(1u, map.size());
         EXPECT_EQ(1u, map.count(555));
 
         EXPECT_EQ(1u, delegated_impl->Resources().size());
-        EXPECT_EQ(1u, delegated_impl->Resources().count(map.find(555)->second));
+        EXPECT_EQ(1u, delegated_impl->Resources().count(555));
         break;
       case 3:
         EXPECT_EQ(2u, map.size());
         EXPECT_EQ(1u, map.count(999));
         EXPECT_EQ(1u, map.count(555));
 
         EXPECT_EQ(2u, delegated_impl->Resources().size());
-        EXPECT_EQ(1u, delegated_impl->Resources().count(map.find(999)->second));
-        EXPECT_EQ(1u, delegated_impl->Resources().count(map.find(555)->second));
+        EXPECT_EQ(1u, delegated_impl->Resources().count(999));
+        EXPECT_EQ(1u, delegated_impl->Resources().count(555));
     }
   }
 
   virtual void AfterTest() OVERRIDE {}
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDelegatedTestCommitWithoutTake);
 
 class DelegatedFrameIsActivatedDuringCommit
     : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
@@ skipping 92 matching lines @@
   base::WaitableEvent wait_event_;
   base::Lock activate_lock_;
   int activate_count_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     DelegatedFrameIsActivatedDuringCommit);
 
 }  // namespace
 }  // namespace cc