Free worker context resources on idle.

gpu/command_buffer/client/gles2_implementation_unittest.cc

 // Copyright (c) 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.
 
 // Tests for GLES2Implementation.
 
 #include "gpu/command_buffer/client/gles2_implementation.h"
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
 #include <GLES3/gl3.h>
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 
+#include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/memory/ptr_util.h"
+#include "base/test/test_mock_time_task_runner.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "gpu/command_buffer/client/client_test_helper.h"
 #include "gpu/command_buffer/client/gles2_cmd_helper.h"
 #include "gpu/command_buffer/client/program_info_manager.h"
 #include "gpu/command_buffer/client/query_tracker.h"
 #include "gpu/command_buffer/client/ring_buffer.h"
 #include "gpu/command_buffer/client/shared_memory_limits.h"
 #include "gpu/command_buffer/client/transfer_buffer.h"
 #include "gpu/command_buffer/common/command_buffer.h"
 #include "gpu/command_buffer/common/sync_token.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ skipping 445 matching lines @@
       capabilities.bind_generates_resource_chromium =
           bind_generates_resource_service ? 1 : 0;
       capabilities.sync_query = sync_query;
       capabilities.occlusion_query_boolean = occlusion_query_boolean;
       capabilities.timer_queries = timer_queries;
       capabilities.major_version = major_version;
       capabilities.minor_version = minor_version;
       EXPECT_CALL(*gpu_control_, GetCapabilities())
           .WillOnce(Return(capabilities));
 
+      task_runner_ = make_scoped_refptr(new base::TestMockTimeTaskRunner());
+
       {
         InSequence sequence;
 
         const bool support_client_side_arrays = true;
         gl_.reset(new GLES2Implementation(
             helper_.get(), share_group, transfer_buffer_.get(),
             bind_generates_resource_client, lose_context_when_out_of_memory,
-            support_client_side_arrays, gpu_control_.get(), nullptr));
+            support_client_side_arrays, gpu_control_.get(), task_runner_));
       }
 
       // The client should be set to something non-null.
       EXPECT_CALL(*gpu_control_, SetGpuControlClient(gl_.get())).Times(1);
 
       if (!gl_->Initialize(kTransferBufferSize, kTransferBufferSize,
                            kTransferBufferSize, SharedMemoryLimits::kNoLimit))
         return false;
 
       helper_->CommandBufferHelper::Finish();
@@ skipping 29 matching lines @@
     void ClearCommands() {
       scoped_refptr<Buffer> ring_buffer = helper_->get_ring_buffer();
       memset(ring_buffer->memory(), kInitialValue, ring_buffer->size());
     }
 
     std::unique_ptr<MockClientCommandBuffer> command_buffer_;
     std::unique_ptr<MockClientGpuControl> gpu_control_;
     std::unique_ptr<GLES2CmdHelper> helper_;
     std::unique_ptr<MockTransferBuffer> transfer_buffer_;
     std::unique_ptr<GLES2Implementation> gl_;
+    scoped_refptr<base::TestMockTimeTaskRunner> task_runner_;
     CommandBufferEntry* commands_;
     int token_;
   };
 
   GLES2ImplementationTest() : commands_(NULL) {}
 
   void SetUp() override;
   void TearDown() override;
 
   bool NoCommandsWritten() {
@@ skipping 66 matching lines @@
     transfer_buffer_ = test_contexts_[0].transfer_buffer_.get();
     gl_ = test_contexts_[0].gl_.get();
     commands_ = test_contexts_[0].commands_;
     return success;
   }
 
   MockClientCommandBuffer* command_buffer() const {
     return test_contexts_[0].command_buffer_.get();
   }
 
+  base::TestMockTimeTaskRunner* task_runner() const {
+    return test_contexts_[0].task_runner_.get();
+  }
+
   int GetNextToken() { return test_contexts_[0].GetNextToken(); }
 
   const void* GetPut() {
     return helper_->GetSpace(0);
   }
 
   void ClearCommands() {
     scoped_refptr<Buffer> ring_buffer = helper_->get_ring_buffer();
     memset(ring_buffer->memory(), kInitialValue, ring_buffer->size());
   }
@@ skipping 4002 matching lines @@
     EXPECT_TRUE(gl_->AnyClientsVisible());
     EXPECT_CALL(*command_buffer(), OnFlush()).Times(2);
     EXPECT_CALL(*command_buffer(), DestroyTransferBuffer(_)).Times(1);
     gl_->Flush();
     gl_->TrimResources();
     gl_->Flush();
     Mock::VerifyAndClearExpectations(command_buffer());
   }
 }
 
+TEST_F(GLES2ImplementationTest, ClientBusyBasic) {
+  bool signaled = false;
+  gl_->SetIdleCallback(
+      base::Bind([](bool* signaled) { *signaled = true; }, &signaled));
+  auto busy = gl_->ClientBecameBusy();
+  gl_->ClientBecameNotBusy(std::move(busy));
+
+  task_runner()->FastForwardBy(base::TimeDelta::FromSeconds(5));
+  EXPECT_TRUE(signaled);
+}
+
+TEST_F(GLES2ImplementationTest, ClientBusyCancelled) {
+  auto runner = make_scoped_refptr(new base::TestMockTimeTaskRunner());
+  base::ThreadTaskRunnerHandle handle(runner);
+
+  bool signaled = false;
+  gl_->SetIdleCallback(
+      base::Bind([](bool* signaled) { *signaled = true; }, &signaled));
+  auto busy = gl_->ClientBecameBusy();
+
+  // This will trigger the idle callback to start counting down.
+  gl_->ClientBecameNotBusy(std::move(busy));
+
+  // Immediately take another busy lock to stop the countdown.
+  busy = gl_->ClientBecameBusy();
+
+  // Advance time and ensure that our callback was cancelled (does not run).
+  task_runner()->FastForwardBy(base::TimeDelta::FromSeconds(5));
+  EXPECT_FALSE(signaled);
+
+  // Release our busy lock, and let the idle callback run.
+  gl_->ClientBecameNotBusy(std::move(busy));
+
+  task_runner()->FastForwardBy(base::TimeDelta::FromSeconds(5));
+  EXPECT_TRUE(signaled);
+}
+
 #include "base/macros.h"
 #include "gpu/command_buffer/client/gles2_implementation_unittest_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu