gpu: Reduce GL context switches used to check pending queries.

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 157 matching lines @@
       !base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableGpuProgramCache)) {
     program_cache_.reset(new gpu::gles2::MemoryProgramCache());
   }
   return program_cache_.get();
 }
 
 InProcessCommandBuffer::InProcessCommandBuffer(
     const scoped_refptr<Service>& service)
     : context_lost_(false),
-      idle_work_pending_(false),
+      delayed_work_pending_(false),
       image_factory_(nullptr),
       last_put_offset_(-1),
       gpu_memory_buffer_manager_(nullptr),
       flush_event_(false, false),
       service_(GetInitialService(service)),
       gpu_thread_weak_ptr_factory_(this) {
   DCHECK(service_.get());
   next_image_id_.GetNext();
 }
 
@@ skipping 298 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()) {
-    ScheduleIdleWorkOnGpuThread();
+      (gpu_scheduler_->HasMoreIdleWork() ||
+       gpu_scheduler_->HasPendingQueries())) {
+    ScheduleDelayedWorkOnGpuThread();
   }
 }
 
-void InProcessCommandBuffer::PerformIdleWork() {
+void InProcessCommandBuffer::PerformDelayedWork() {
   CheckSequencedThread();
-  idle_work_pending_ = false;
+  delayed_work_pending_ = false;
   base::AutoLock lock(command_buffer_lock_);
-  if (MakeCurrent() && gpu_scheduler_->HasMoreWork()) {
+  if (MakeCurrent()) {
     gpu_scheduler_->PerformIdleWork();
-    ScheduleIdleWorkOnGpuThread();
+    gpu_scheduler_->ProcessPendingQueries();
+    if (gpu_scheduler_->HasMoreIdleWork() ||
+        gpu_scheduler_->HasPendingQueries()) {
+      ScheduleDelayedWorkOnGpuThread();
+    }
   }
 }
 
-void InProcessCommandBuffer::ScheduleIdleWorkOnGpuThread() {
+void InProcessCommandBuffer::ScheduleDelayedWorkOnGpuThread() {
   CheckSequencedThread();
-  if (idle_work_pending_)
+  if (delayed_work_pending_)
     return;
-  idle_work_pending_ = true;
-  service_->ScheduleIdleWork(
-      base::Bind(&InProcessCommandBuffer::PerformIdleWork,
-                 gpu_thread_weak_ptr_));
+  delayed_work_pending_ = true;
+  service_->ScheduleDelayedWork(base::Bind(
+      &InProcessCommandBuffer::PerformDelayedWork, 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;
 
@@ skipping 392 matching lines @@
   base::RefCountedThreadSafe<GpuInProcessThread>::AddRef();
 }
 void GpuInProcessThread::Release() const {
   base::RefCountedThreadSafe<GpuInProcessThread>::Release();
 }
 
 void GpuInProcessThread::ScheduleTask(const base::Closure& task) {
   task_runner()->PostTask(FROM_HERE, task);
 }
 
-void GpuInProcessThread::ScheduleIdleWork(const base::Closure& callback) {
+void GpuInProcessThread::ScheduleDelayedWork(const base::Closure& callback) {
   // Match delay with GpuCommandBufferStub.
   task_runner()->PostDelayedTask(FROM_HERE, callback,
                                  base::TimeDelta::FromMilliseconds(2));
 }
 
 bool GpuInProcessThread::UseVirtualizedGLContexts() {
   return false;
 }
 
 scoped_refptr<gles2::ShaderTranslatorCache>
 GpuInProcessThread::shader_translator_cache() {
   if (!shader_translator_cache_.get())
     shader_translator_cache_ = new gpu::gles2::ShaderTranslatorCache;
   return shader_translator_cache_;
 }
 
 scoped_refptr<gles2::FramebufferCompletenessCache>
 GpuInProcessThread::framebuffer_completeness_cache() {
   if (!framebuffer_completeness_cache_.get())
     framebuffer_completeness_cache_ =
         new gpu::gles2::FramebufferCompletenessCache;
   return framebuffer_completeness_cache_;
 }
 
 SyncPointManager* GpuInProcessThread::sync_point_manager() {
   return sync_point_manager_;
 }
 
 }  // namespace gpu