Revert of Remove ForceReclaimResources

cc/layers/texture_layer_unittest.cc

 // Copyright 2012 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/layers/texture_layer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 625 matching lines @@
 class TextureLayerImplWithMailboxThreadedCallback : public LayerTreeTest {
  public:
   TextureLayerImplWithMailboxThreadedCallback() = default;
 
   std::unique_ptr<TestCompositorFrameSink> CreateCompositorFrameSink(
       scoped_refptr<ContextProvider> compositor_context_provider,
       scoped_refptr<ContextProvider> worker_context_provider) override {
     bool synchronous_composite =
         !HasImplThread() &&
         !layer_tree_host()->GetSettings().single_thread_proxy_scheduler;
+    // Allow relaim resources for this test so that mailboxes in the display
+    // will be returned inside the commit that replaces them.
+    bool force_disable_reclaim_resources = false;
     return base::MakeUnique<TestCompositorFrameSink>(
         compositor_context_provider, std::move(worker_context_provider),
         shared_bitmap_manager(), gpu_memory_buffer_manager(),
         layer_tree_host()->GetSettings().renderer_settings,
-        ImplThreadTaskRunner(), synchronous_composite);
+        ImplThreadTaskRunner(), synchronous_composite,
+        force_disable_reclaim_resources);
   }
 
   // Make sure callback is received on main and doesn't block the impl thread.
   void ReleaseCallback(char mailbox_char,
                        const gpu::SyncToken& sync_token,
                        bool lost_resource) {
     EXPECT_EQ(true, main_thread_.CalledOnValidThread());
     EXPECT_FALSE(lost_resource);
     ++callback_count_;
   }
@@ skipping 32 matching lines @@
     EXPECT_EQ(0, callback_count_);
 
     // Case #1: change mailbox before the commit. The old mailbox should be
     // released immediately.
     SetMailbox('2');
     EXPECT_EQ(1, callback_count_);
     PostSetNeedsCommitToMainThread();
   }
 
   void DidCommit() override {
-    ++total_commit_count_;
-    if (total_commit_count_ % 2) {
-      // Perform an extra commit after each meaningful commit to reclaim
-      // resources.
-      PostSetNeedsCommitToMainThread();
-      return;
-    }
-
-    ++meaningful_commit_count_;
-    switch (meaningful_commit_count_) {
+    ++commit_count_;
+    switch (commit_count_) {
       case 1:
         // Case #2: change mailbox after the commit (and draw), where the
         // layer draws. The old mailbox should be released during the next
         // commit.
         SetMailbox('3');
         EXPECT_EQ(1, callback_count_);
         break;
       case 2:
         EXPECT_EQ(2, callback_count_);
         // Case #3: change mailbox when the layer doesn't draw. The old
@@ skipping 29 matching lines @@
         NOTREACHED();
         break;
     }
   }
 
   void AfterTest() override {}
 
  private:
   base::ThreadChecker main_thread_;
   int callback_count_ = 0;
-  int total_commit_count_ = 0;
-  int meaningful_commit_count_ = 0;
+  int commit_count_ = 0;
   scoped_refptr<Layer> root_;
   scoped_refptr<TextureLayer> layer_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(TextureLayerImplWithMailboxThreadedCallback);
 
 class TextureLayerMailboxIsActivatedDuringCommit : public LayerTreeTest {
  protected:
   TextureLayerMailboxIsActivatedDuringCommit() : activate_count_(0) {}
 
@@ skipping 685 matching lines @@
   base::ThreadChecker main_thread_;
   int callback_count_;
   scoped_refptr<Layer> root_;
   scoped_refptr<TextureLayer> layer_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(TextureLayerWithMailboxImplThreadDeleted);
 
 }  // namespace
 }  // namespace cc