aw: Improve 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 188 matching lines @@
     DCHECK(service.get());
   } else {
     service = new GpuInProcessThread;
   }
   return service;
 }
 
 InProcessCommandBuffer::InProcessCommandBuffer(
     const scoped_refptr<Service>& service)
     : context_lost_(false),
+      idle_work_pending_(false),
       last_put_offset_(-1),
       flush_event_(false, false),
       service_(service.get() ? service : GetDefaultService()),
       gpu_thread_weak_ptr_factory_(this) {
   if (!service) {
     base::AutoLock lock(default_thread_clients_lock_.Get());
     default_thread_clients_.Get().insert(this);
   }
 }
 
@@ skipping 278 matching lines @@
     // Update state before signaling the flush event.
     base::AutoLock lock(state_after_last_flush_lock_);
     state_after_last_flush_ = command_buffer_->GetLastState();
   }
   DCHECK((!error::IsError(state_after_last_flush_.error) && !context_lost_) ||
          (error::IsError(state_after_last_flush_.error) && context_lost_));
 
   // If we've processed all pending commands but still have pending queries,
   // pump idle work until the query is passed.
   if (put_offset == state_after_last_flush_.get_offset &&
-      gpu_scheduler_->HasMoreWork()) {
-    service_->ScheduleIdleWork(
-        base::Bind(&InProcessCommandBuffer::ScheduleMoreIdleWork,
-                   gpu_thread_weak_ptr_));
+      gpu_scheduler_->HasMoreWork() && !idle_work_pending_) {
+    ScheduleIdleWorkOnGpuThread();
   }
 }
 
-void InProcessCommandBuffer::ScheduleMoreIdleWork() {
+void InProcessCommandBuffer::PerformIdleWork() {
   CheckSequencedThread();
+  idle_work_pending_ = false;
   base::AutoLock lock(command_buffer_lock_);
   if (gpu_scheduler_->HasMoreWork()) {
     gpu_scheduler_->PerformIdleWork();
-    service_->ScheduleIdleWork(
-        base::Bind(&InProcessCommandBuffer::ScheduleMoreIdleWork,
-                   gpu_thread_weak_ptr_));
+    ScheduleIdleWorkOnGpuThread();
   }
 }
 
+void InProcessCommandBuffer::ScheduleIdleWorkOnGpuThread() {
+  CheckSequencedThread();
+  if (idle_work_pending_)
+    return;
+  idle_work_pending_ = true;
+  service_->ScheduleIdleWork(
+      base::Bind(&InProcessCommandBuffer::PerformIdleWork,
+                 gpu_thread_weak_ptr_));
+}
+
 void InProcessCommandBuffer::Flush(int32 put_offset) {
   CheckSequencedThread();
   if (last_state_.error != gpu::error::kNoError)
     return;
 
   if (last_put_offset_ == put_offset)
     return;
 
   last_put_offset_ = put_offset;
   base::Closure task = base::Bind(&InProcessCommandBuffer::FlushOnGpuThread,
@@ skipping 298 matching lines @@
 }
 #endif
 
 // static
 void InProcessCommandBuffer::SetGpuMemoryBufferFactory(
     InProcessGpuMemoryBufferFactory* factory) {
   g_gpu_memory_buffer_factory = factory;
 }
 
 }  // namespace gpu