cc: refcount resources as we send them to the parent

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 "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/shared_quad_state.h"
 #include "cc/quads/texture_draw_quad.h"
 #include "cc/test/fake_delegated_renderer_layer.h"
 #include "cc/test/fake_delegated_renderer_layer_impl.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/layer_tree_test.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "gpu/GLES2/gl2extchromium.h"
 
 namespace cc {
 namespace {
 
+bool TransferableResourceLower(const TransferableResource& a,
+                               const TransferableResource& b) {
+  return a.id < b.id;
+}
+
+// Tests if the list of resources matches an expectation, modulo the order.
+bool ResourcesMatch(TransferableResourceArray actual,
+                    unsigned* expected,
+                    size_t expected_count) {
+  EXPECT_EQ(expected_count, actual.size());
+  if (expected_count != actual.size())
+    return false;
+
+  std::sort(actual.begin(), actual.end(), TransferableResourceLower);
+  std::sort(expected, expected + expected_count);
+  bool result = true;
+  for (size_t i = 0; i < expected_count; ++i) {
+    EXPECT_EQ(actual[i].id, expected[i]);
+    if (actual[i].id != expected[i])
+      result = false;
+  }
+
+  return result;
+}
+
+#define EXPECT_RESOURCES(expected, actual) \
+    EXPECT_TRUE(ResourcesMatch(actual, expected, arraysize(expected)));
+
 // These tests deal with delegated renderer layers.
 class LayerTreeHostDelegatedTest : public LayerTreeTest {
  protected:
   scoped_ptr<DelegatedFrameData> CreateFrameData(gfx::Rect root_output_rect,
                                                  gfx::Rect root_damage_rect) {
     scoped_ptr<DelegatedFrameData> frame(new DelegatedFrameData);
 
     scoped_ptr<RenderPass> root_pass(RenderPass::Create());
     root_pass->SetNew(RenderPass::Id(1, 1),
                       root_output_rect,
@@ skipping 449 matching lines @@
     scoped_ptr<DelegatedFrameData> frame1 =
         CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
     AddTextureQuad(frame1.get(), 999);
     AddTransferableResource(frame1.get(), 999);
     delegated_->SetFrameData(frame1.Pass());
 
     // The second frame uses resource 999 still, but also adds 555.
     scoped_ptr<DelegatedFrameData> frame2 =
         CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
     AddTextureQuad(frame2.get(), 999);
+    AddTransferableResource(frame2.get(), 999);
     AddTextureQuad(frame2.get(), 555);
     AddTransferableResource(frame2.get(), 555);
     delegated_->SetFrameData(frame2.Pass());
 
+    TransferableResourceArray returned_resources;

[danakj, 2013/08/16 16:49:44]

// The resource 999 from frame1 is returned since it is still on the main
thread.

[piman, 2013/08/16 20:43:19]

Done.

+    delegated_->TakeUnusedResourcesForChildCompositor(&returned_resources);
+    {
+      unsigned expected[] = {999};
+      EXPECT_RESOURCES(expected, returned_resources);
+    }
+
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
     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(
@@ skipping 107 matching lines @@
         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:
         // 555 is no longer in use.
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
-        EXPECT_EQ(1u, resources.size());
-        EXPECT_EQ(555u, resources[0].id);
+        {
+          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:
         // 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.
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
-        EXPECT_EQ(2u, resources.size());
-        if (resources[0].id == 999) {
-          EXPECT_EQ(999u, resources[0].id);
-          EXPECT_EQ(444u, resources[1].id);
-        } else {
-          EXPECT_EQ(444u, resources[0].id);
-          EXPECT_EQ(999u, resources[1].id);
+        {
+          unsigned expected[] = {444, 999};
+          EXPECT_RESOURCES(expected, resources);
         }
         EndTest();
         break;
     }
 
     // Resource are never immediately released.
     TransferableResourceArray empty_resources;
     delegated_->TakeUnusedResourcesForChildCompositor(&empty_resources);
     EXPECT_TRUE(empty_resources.empty());
   }
@@ skipping 59 matching lines @@
         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.
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
-        EXPECT_EQ(1u, resources.size());
-        EXPECT_EQ(999u, resources[0].id);
+        {
+          unsigned expected[] = {999};
+          EXPECT_RESOURCES(expected, resources);
+        }
         EndTest();
         break;
     }
   }
 
   virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
                                    bool result) OVERRIDE {
     ReturnUnusedResourcesFromParent(host_impl);
   }
 
@@ skipping 47 matching lines @@
 
         // 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:
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
-        EXPECT_EQ(2u, resources.size());
-        if (resources[0].id == 555) {
-          EXPECT_EQ(555u, resources[0].id);
-          EXPECT_EQ(444u, resources[1].id);
-        } else {
-          EXPECT_EQ(444u, resources[0].id);
-          EXPECT_EQ(555u, resources[1].id);
+        {
+          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.
         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;
@@ skipping 70 matching lines @@
         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:
         // 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 so are not returned.
+        // The resources are used by the new frame but are returned anyway since
+        // we passed them again.
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
-        EXPECT_EQ(0u, resources.size());
+        {
+          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:
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
         EndTest();
@@ skipping 96 matching lines @@
         // 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:
         // The bad frame's resource is given back to the child compositor.
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
-        EXPECT_EQ(1u, resources.size());
-        EXPECT_EQ(444u, resources[0].id);
+        {
+          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:
         // The unused 555 from the last good frame is now released.
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
-        EXPECT_EQ(1u, resources.size());
-        EXPECT_EQ(555u, resources[0].id);
+        {
+          unsigned expected[] = {555};
+          EXPECT_RESOURCES(expected, resources);
+        }
 
         EndTest();
         break;
     }
   }
 
   virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
                                    bool result) OVERRIDE {
     if (host_impl->active_tree()->source_frame_number() < 1)
       return;
@@ skipping 99 matching lines @@
         // This frame includes two resources in it, but only uses one.
         frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
         AddTransferableResource(frame.get(), 999);
         AddTextureQuad(frame.get(), 555);
         AddTransferableResource(frame.get(), 555);
         delegated_->SetFrameData(frame.Pass());
         break;
       case 2:
         // The unused resource should be returned.
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
-        EXPECT_EQ(1u, resources.size());
-        EXPECT_EQ(999u, resources[0].id);
+        {
+          unsigned expected[] = {999};
+          EXPECT_RESOURCES(expected, resources);
+        }
 
         EndTest();
         break;
     }
   }
 
   virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
     if (host_impl->active_tree()->source_frame_number() != 1)
       return;
 
@@ skipping 36 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);
         delegated_->SetFrameData(frame.Pass());
 
         // But then we immediately stop using 999.
         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 2:
-        // The unused resource should be returned.
+        // The unused resources should be returned. 555 is still used, but it's
+        // returned once to account for the first frame.
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
-        EXPECT_EQ(1u, resources.size());
-        EXPECT_EQ(999u, resources[0].id);
-
+        {
+          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));
   }
 
+  virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
+                                   bool result) OVERRIDE {
+    ReturnUnusedResourcesFromParent(host_impl);
+  }
+
   virtual void AfterTest() OVERRIDE {}
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDelegatedTestDontLeakResource);
 
 class LayerTreeHostDelegatedTestResourceSentToParent
     : public LayerTreeHostDelegatedTestCaseSingleDelegatedLayer {
  public:
   virtual void DidCommitAndDrawFrame() OVERRIDE {
     scoped_ptr<DelegatedFrameData> frame;
@@ skipping 25 matching lines @@
         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);
-        EXPECT_EQ(1u, resources.size());
-        EXPECT_EQ(999u, resources[0].id);
+        {
+          unsigned expected[] = {999};
+          EXPECT_RESOURCES(expected, resources);
+        }
 
         EndTest();
         break;
     }
   }
 
   virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
     if (host_impl->active_tree()->source_frame_number() < 1)
       return;
 
@@ skipping 77 matching lines @@
         AddTransferableResource(frame.get(), 444);
         delegated_->SetFrameData(frame.Pass());
         break;
       case 2:
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
         EXPECT_EQ(0u, resources.size());
 
         // Stop using 999 and 444 in this frame and commit.
         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());
+        // 999 and 444 will be returned for frame 1, but not 555 since it's in
+        // the current frame.
         break;
       case 3:
         // Don't take resources here, but set a new frame that uses 999 again.
         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 4:
-        // 999 and 555 are in use, but 444 should be returned now.
+        // 555 from frame 1 and 2 isn't returned since it's still in use. 999
+        // from frame 1 is returned though.
         delegated_->TakeUnusedResourcesForChildCompositor(&resources);
-        EXPECT_EQ(1u, resources.size());
-        EXPECT_EQ(444u, resources[0].id);
+        {
+          unsigned expected[] = {444, 999};
+          EXPECT_RESOURCES(expected, resources);
+        }
+
+        frame = CreateFrameData(gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1));
+        delegated_->SetFrameData(frame.Pass());
+        // 555 will be returned 3 times for frames 1 2 and 3, and 999 will be
+        // returned once for frame 3.
+        break;
+      case 5:
+        delegated_->TakeUnusedResourcesForChildCompositor(&resources);
+        {
+          unsigned expected[] = {555, 555, 555, 999};
+          EXPECT_RESOURCES(expected, resources);
+        }
 
         EndTest();
         break;
     }
   }
 
   virtual void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
     if (host_impl->active_tree()->source_frame_number() < 1)
       return;
 
@@ skipping 35 matching lines @@
     }
   }
 
   virtual void AfterTest() OVERRIDE {}
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostDelegatedTestCommitWithoutTake);
 
 }  // namespace
 }  // namespace cc