gpu: Optimize in-process idle task scheduling

gpu/command_buffer/service/in_process_command_buffer.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 "gpu/command_buffer/service/in_process_command_buffer.h"
 
 #include <queue>
 #include <set>
 #include <utility>
 
@@ skipping 64 matching lines @@
   }
 
   void ScheduleTask(const base::Closure& task) override;
   void ScheduleIdleWork(const base::Closure& callback) override;
   bool UseVirtualizedGLContexts() override { return false; }
   scoped_refptr<gles2::ShaderTranslatorCache> shader_translator_cache()
       override;
 
  private:
   ~GpuInProcessThread() override;
+
+  void CheckIdleTasksLocked();
+  void RunIdleTask();
+
   friend class base::RefCountedThreadSafe<GpuInProcessThread>;
 
   scoped_refptr<gpu::gles2::ShaderTranslatorCache> shader_translator_cache_;
+
+  base::Lock lock_;
+  bool idle_post_pending_;
+  std::queue<base::Closure> pending_idle_tasks_;
   DISALLOW_COPY_AND_ASSIGN(GpuInProcessThread);
 };
 
-GpuInProcessThread::GpuInProcessThread() : base::Thread("GpuThread") {
+GpuInProcessThread::GpuInProcessThread()
+    : base::Thread("GpuThread"), idle_post_pending_(false) {
   Start();
 }
 
 GpuInProcessThread::~GpuInProcessThread() {
   Stop();
 }
 
 void GpuInProcessThread::ScheduleTask(const base::Closure& task) {
   message_loop()->PostTask(FROM_HERE, task);

[no sievers, 2015/01/13 21:00:00]

Should this also change then and have its own queue which we handle here?

I.e. CheckIdleTasks() -> CheckTasks()
ScheduleTask(task) similar as ScheduleIdleWork() but put in different queue.

RunIdleTask() -> RunLoop() which could do something like:
get the current number of tasks and run all of them
then run idle tasks while there are no normal tasks

[boliu, 2015/01/13 22:07:23]

I think we get this behavior with the current code. It's just the queue for
non-idle tasks you describe here is the task queue inside the message loop. No?

 }
 
 void GpuInProcessThread::ScheduleIdleWork(const base::Closure& callback) {
-  message_loop()->PostDelayedTask(
-      FROM_HERE, callback, base::TimeDelta::FromMilliseconds(5));
+  base::AutoLock lock(lock_);
+  pending_idle_tasks_.push(callback);
+  CheckIdleTasksLocked();
+}
+
+void GpuInProcessThread::CheckIdleTasksLocked() {
+  lock_.AssertAcquired();
+  if (pending_idle_tasks_.size() && !idle_post_pending_) {
+    idle_post_pending_ = true;
+    message_loop()->PostTask(
+        FROM_HERE, base::Bind(&GpuInProcessThread::RunIdleTask, this));
+  }
+}
+
+void GpuInProcessThread::RunIdleTask() {
+  base::Closure idle_task;
+  base::AutoLock lock(lock_);
+  idle_post_pending_ = false;
+  DCHECK(pending_idle_tasks_.size());
+  idle_task = pending_idle_tasks_.front();
+  pending_idle_tasks_.pop();
+
+  {
+    base::AutoUnlock unlock(lock_);
+    idle_task.Run();
+  }
+
+  CheckIdleTasksLocked();
 }
 
 scoped_refptr<gles2::ShaderTranslatorCache>
 GpuInProcessThread::shader_translator_cache() {
   if (!shader_translator_cache_.get())
     shader_translator_cache_ = new gpu::gles2::ShaderTranslatorCache;
   return shader_translator_cache_;
 }
 
 struct GpuInProcessThreadHolder {
@@ skipping 829 matching lines @@
 
 #if defined(OS_ANDROID)
 scoped_refptr<gfx::SurfaceTexture>
 InProcessCommandBuffer::GetSurfaceTexture(uint32 stream_id) {
   DCHECK(stream_texture_manager_);
   return stream_texture_manager_->GetSurfaceTexture(stream_id);
 }
 #endif
 
 }  // namespace gpu