1 files changed, 56 insertions, 48 deletions

diff --git a/chromium/third_party/blink/renderer/platform/graphics/gpu/drawing_buffer_test.cc b/chromium/third_party/blink/renderer/platform/graphics/gpu/drawing_buffer_test.cc
index 537c1af0001..8509c15a852 100644
--- a/chromium/third_party/blink/renderer/platform/graphics/gpu/drawing_buffer_test.cc
+++ b/chromium/third_party/blink/renderer/platform/graphics/gpu/drawing_buffer_test.cc
@@ -246,58 +246,64 @@ TEST_F(DrawingBufferTest, VerifySharedImagesReleasedAfterReleaseCallback) {
   drawing_buffer_->BeginDestruction();
 }
 
-TEST_F(DrawingBufferTest, VerifyOnlyOneRecycledResourceMustBeKept) {
-  viz::TransferableResource resource1;
-  std::unique_ptr<viz::SingleReleaseCallback> release_callback1;
-  viz::TransferableResource resource2;
-  std::unique_ptr<viz::SingleReleaseCallback> release_callback2;
-  viz::TransferableResource resource3;
-  std::unique_ptr<viz::SingleReleaseCallback> release_callback3;
+TEST_F(DrawingBufferTest, VerifyCachedRecycledResourcesAreKept) {
+  const size_t kNumResources = DrawingBuffer::kDefaultColorBufferCacheLimit + 1;
+  std::vector<viz::TransferableResource> resources(kNumResources);
+  std::vector<std::unique_ptr<viz::SingleReleaseCallback>> release_callbacks(
+      kNumResources);
 
   // Produce resources.
-  EXPECT_FALSE(drawing_buffer_->MarkContentsChanged());
-  EXPECT_TRUE(drawing_buffer_->PrepareTransferableResource(nullptr, &resource1,
-                                                           &release_callback1));
-  EXPECT_TRUE(drawing_buffer_->MarkContentsChanged());
-  EXPECT_TRUE(drawing_buffer_->PrepareTransferableResource(nullptr, &resource2,
-                                                           &release_callback2));
-  EXPECT_TRUE(drawing_buffer_->MarkContentsChanged());
-  EXPECT_TRUE(drawing_buffer_->PrepareTransferableResource(nullptr, &resource3,
-                                                           &release_callback3));
+  for (size_t i = 0; i < kNumResources; ++i) {
+    drawing_buffer_->MarkContentsChanged();
+    EXPECT_TRUE(drawing_buffer_->PrepareTransferableResource(
+        nullptr, &resources[i], &release_callbacks[i]));
+  }
 
-  // Release resources by specific order; 1, 3, 2.
-  EXPECT_TRUE(drawing_buffer_->MarkContentsChanged());
-  release_callback1->Run(gpu::SyncToken(), false /* lostResource */);
-  EXPECT_FALSE(drawing_buffer_->MarkContentsChanged());
-  release_callback3->Run(gpu::SyncToken(), false /* lostResource */);
-  EXPECT_FALSE(drawing_buffer_->MarkContentsChanged());
-  release_callback2->Run(gpu::SyncToken(), false /* lostResource */);
+  // Release resources.
+  for (auto& release_callback : release_callbacks) {
+    drawing_buffer_->MarkContentsChanged();
+    release_callback->Run(gpu::SyncToken(), false /* lostResource */);
+  }
 
-  // The first recycled resource must be 2. 1 and 3 were deleted by FIFO order
-  // because DrawingBuffer never keeps more than one resource.
-  viz::TransferableResource recycled_resource1;
-  std::unique_ptr<viz::SingleReleaseCallback> recycled_release_callback1;
-  EXPECT_FALSE(drawing_buffer_->MarkContentsChanged());
-  EXPECT_TRUE(drawing_buffer_->PrepareTransferableResource(
-      nullptr, &recycled_resource1, &recycled_release_callback1));
-  EXPECT_EQ(resource2.mailbox_holder.mailbox,
-            recycled_resource1.mailbox_holder.mailbox);
+  std::vector<std::unique_ptr<viz::SingleReleaseCallback>>
+      recycled_release_callbacks(DrawingBuffer::kDefaultColorBufferCacheLimit);
+
+  // The first recycled resource must be from the cache
+  for (size_t i = 0; i < DrawingBuffer::kDefaultColorBufferCacheLimit; ++i) {
+    viz::TransferableResource recycled_resource;
+    std::unique_ptr<viz::SingleReleaseCallback> recycled_release_callback;
+    drawing_buffer_->MarkContentsChanged();
+    EXPECT_TRUE(drawing_buffer_->PrepareTransferableResource(
+        nullptr, &recycled_resource, &recycled_release_callbacks[i]));
+
+    bool recycled = false;
+    for (auto& resource : resources) {
+      if (recycled_resource.mailbox_holder.mailbox ==
+          resource.mailbox_holder.mailbox) {
+        recycled = true;
+        break;
+      }
+    }
+    EXPECT_TRUE(recycled);
+  }
 
-  // The second recycled resource must be a new resource.
-  viz::TransferableResource recycled_resource2;
-  std::unique_ptr<viz::SingleReleaseCallback> recycled_release_callback2;
-  EXPECT_TRUE(drawing_buffer_->MarkContentsChanged());
+  // The next recycled resource must be a new resource.
+  viz::TransferableResource next_recycled_resource;
+  std::unique_ptr<viz::SingleReleaseCallback> next_recycled_release_callback;
+  drawing_buffer_->MarkContentsChanged();
   EXPECT_TRUE(drawing_buffer_->PrepareTransferableResource(
-      nullptr, &recycled_resource2, &recycled_release_callback2));
-  EXPECT_NE(resource1.mailbox_holder.mailbox,
-            recycled_resource2.mailbox_holder.mailbox);
-  EXPECT_NE(resource2.mailbox_holder.mailbox,
-            recycled_resource2.mailbox_holder.mailbox);
-  EXPECT_NE(resource3.mailbox_holder.mailbox,
-            recycled_resource2.mailbox_holder.mailbox);
-
-  recycled_release_callback1->Run(gpu::SyncToken(), false /* lostResource */);
-  recycled_release_callback2->Run(gpu::SyncToken(), false /* lostResource */);
+      nullptr, &next_recycled_resource, &next_recycled_release_callback));
+  for (auto& resource : resources) {
+    EXPECT_NE(resource.mailbox_holder.mailbox,
+              next_recycled_resource.mailbox_holder.mailbox);
+  }
+  recycled_release_callbacks.push_back(
+      std::move(next_recycled_release_callback));
+
+  // Cleanup
+  for (auto& release_cb : recycled_release_callbacks) {
+    release_cb->Run(gpu::SyncToken(), false /* lostResource */);
+  }
   drawing_buffer_->BeginDestruction();
 }
 
@@ -679,7 +685,8 @@ TEST(DrawingBufferDepthStencilTest, packedDepthStencilSupported) {
         IntSize(10, 10), premultiplied_alpha, want_alpha_channel,
         want_depth_buffer, want_stencil_buffer, want_antialiasing, preserve,
         DrawingBuffer::kWebGL1, DrawingBuffer::kAllowChromiumImage,
-        CanvasColorParams(), gl::GpuPreference::kHighPerformance);
+        kLow_SkFilterQuality, CanvasColorParams(),
+        gl::GpuPreference::kHighPerformance);
 
     // When we request a depth or a stencil buffer, we will get both.
     EXPECT_EQ(cases[i].request_depth || cases[i].request_stencil,
@@ -749,7 +756,8 @@ TEST_F(DrawingBufferTest,
       nullptr, gpu_compositing, false /* using_swap_chain */, nullptr,
       too_big_size, false, false, false, false, false, DrawingBuffer::kDiscard,
       DrawingBuffer::kWebGL1, DrawingBuffer::kAllowChromiumImage,
-      CanvasColorParams(), gl::GpuPreference::kHighPerformance);
+      kLow_SkFilterQuality, CanvasColorParams(),
+      gl::GpuPreference::kHighPerformance);
   EXPECT_EQ(too_big_drawing_buffer, nullptr);
   drawing_buffer_->BeginDestruction();
 }