Free worker context resources on idle.

gpu/command_buffer/client/gles2_implementation.h

 // 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.
 
 #ifndef GPU_COMMAND_BUFFER_CLIENT_GLES2_IMPLEMENTATION_H_
 #define GPU_COMMAND_BUFFER_CLIENT_GLES2_IMPLEMENTATION_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <list>
 #include <map>
 #include <memory>
 #include <queue>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
+#include "base/cancelable_callback.h"
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/trace_event/memory_dump_provider.h"
 #include "gpu/command_buffer/client/buffer_tracker.h"
 #include "gpu/command_buffer/client/client_context_state.h"
 #include "gpu/command_buffer/client/context_support.h"
 #include "gpu/command_buffer/client/gles2_impl_export.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/command_buffer/client/gpu_control_client.h"
@@ skipping 174 matching lines @@
                             const gfx::Rect& display_bounds,
                             const gfx::RectF& uv_rect) override;
   uint64_t ShareGroupTracingGUID() const override;
   void SetErrorMessageCallback(
       const base::Callback<void(const char*, int32_t)>& callback) override;
   std::unique_ptr<ScopedVisibility> ClientBecameVisible() override;
   void ClientBecameNotVisible(
       std::unique_ptr<ScopedVisibility> visibility) override;
   bool AnyClientsVisible() const override;
 
+  std::unique_ptr<ScopedBusy> ClientBecameBusy() override;
+  void ClientBecameNotBusy(std::unique_ptr<ScopedBusy> busy) override;
+  void SetIdleCallback(const base::Closure& callback,
+                       scoped_refptr<base::SingleThreadTaskRunner>
+                           callback_task_runner) override;
+
   // TODO(danakj): Move to ContextSupport once ContextProvider doesn't need to
   // intercept it.
   void SetLostContextCallback(const base::Closure& callback);
 
   void GetProgramInfoCHROMIUMHelper(GLuint program,
                                     std::vector<int8_t>* result);
   GLint GetAttribLocationHelper(GLuint program, const char* name);
   GLint GetUniformLocationHelper(GLuint program, const char* name);
   GLint GetFragDataIndexEXTHelper(GLuint program, const char* name);
   GLint GetFragDataLocationHelper(GLuint program, const char* name);
@@ skipping 30 matching lines @@
       const char* function_name, GLuint id, GLenum pname, GLuint64* params);
 
   void FreeUnusedSharedMemory();
   void FreeEverything();
 
   // ContextSupport implementation.
   void SignalSyncToken(const gpu::SyncToken& sync_token,
                        const base::Closure& callback) override;
   void SignalQuery(uint32_t query, const base::Closure& callback) override;
   void SetAggressivelyFreeResources(bool aggressively_free_resources) override;
+  void TrimResources() override;
 
   // base::trace_event::MemoryDumpProvider implementation.
   bool OnMemoryDump(const base::trace_event::MemoryDumpArgs& args,
                     base::trace_event::ProcessMemoryDump* pmd) override;
 
   const scoped_refptr<ShareGroup>& share_group() const { return share_group_; }
 
   const Capabilities& capabilities() const {
     return capabilities_;
   }
@@ skipping 414 matching lines @@
   void RemoveMappedBufferRangeById(GLuint buffer);
   void ClearMappedBufferRangeMap();
 
   void DrawElementsImpl(GLenum mode, GLsizei count, GLenum type,
                         const void* indices, const char* func_name);
   void UpdateCachedExtensionsIfNeeded();
   void InvalidateCachedExtensions();
 
   PixelStoreParams GetUnpackParameters(Dimension dimension);
 
+  void ScheduleIdleCallback();
+  void CancelIdleCallback();
+
   GLES2Util util_;
   GLES2CmdHelper* helper_;
   TransferBufferInterface* transfer_buffer_;
   std::string last_error_;
   DebugMarkerManager debug_marker_manager_;
   std::string this_in_hex_;
 
   std::queue<int32_t> swap_buffers_tokens_;
   std::queue<int32_t> rate_limit_tokens_;
 
@@ skipping 107 matching lines @@
 
   std::unique_ptr<QueryTracker> query_tracker_;
   std::unique_ptr<IdAllocator> query_id_allocator_;
 
   std::unique_ptr<BufferTracker> buffer_tracker_;
 
   base::Callback<void(const char*, int32_t)> error_message_callback_;
   base::Closure lost_context_callback_;
   bool lost_context_callback_run_ = false;
 
+  base::Closure idle_callback_;
+  std::unique_ptr<base::CancelableClosure> pending_idle_callback_;

[danakj, 2016/08/23 01:26:25]

why unique_ptr it?

[ericrk, 2016/08/24 18:32:21]

You must create a CancelableClosure on the same thread you call cancel on, so
this lets us delay creation until we are on the idle_callback_task_runner_.

This can be re-worked if we go with a generation_id_, see my comments below.

+  scoped_refptr<base::SingleThreadTaskRunner> idle_callback_task_runner_;
+  bool is_idle_ = true;
+
   int current_trace_stack_;
 
   GpuControl* gpu_control_;
 
   Capabilities capabilities_;
 
   // Flag to indicate whether the implementation can retain resources, or
   // whether it should aggressively free them.
   bool aggressively_free_resources_ = false;
 
@@ skipping 49 matching lines @@
 
 inline bool GLES2Implementation::GetTexParameterivHelper(
     GLenum /* target */, GLenum /* pname */, GLint* /* params */) {
   return false;
 }
 
 }  // namespace gles2
 }  // namespace gpu
 
 #endif  // GPU_COMMAND_BUFFER_CLIENT_GLES2_IMPLEMENTATION_H_