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

gpu/command_buffer/service/in_process_command_buffer.h

 // 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.
 
 #ifndef GPU_COMMAND_BUFFER_SERVICE_IN_PROCESS_COMMAND_BUFFER_H_
 #define GPU_COMMAND_BUFFER_SERVICE_IN_PROCESS_COMMAND_BUFFER_H_
 
 #include <map>
 #include <vector>
 
@@ skipping 121 matching lines @@
    public:
     Service();
     virtual ~Service();
 
     virtual void AddRef() const = 0;
     virtual void Release() const = 0;
 
     // Queues a task to run as soon as possible.
     virtual void ScheduleTask(const base::Closure& task) = 0;
 
-    // Schedules |callback| to run at an appropriate time for performing idle
+    // Schedules |callback| to run at an appropriate time for performing delayed
     // work.
-    virtual void ScheduleIdleWork(const base::Closure& task) = 0;
+    virtual void ScheduleDelayedWork(const base::Closure& task) = 0;
 
     virtual bool UseVirtualizedGLContexts() = 0;
     virtual scoped_refptr<gles2::ShaderTranslatorCache>
         shader_translator_cache() = 0;
     virtual scoped_refptr<gles2::FramebufferCompletenessCache>
     framebuffer_completeness_cache() = 0;
     virtual SyncPointManager* sync_point_manager() = 0;
     scoped_refptr<gfx::GLShareGroup> share_group();
     scoped_refptr<gles2::MailboxManager> mailbox_manager();
     scoped_refptr<gles2::SubscriptionRefSet> subscription_ref_set();
@@ skipping 38 matching lines @@
           attribs(attribs),
           gpu_preference(gpu_preference),
           capabilities(capabilities),
           context_group(share_group),
           image_factory(image_factory) {}
   };
 
   bool InitializeOnGpuThread(const InitializeOnGpuThreadParams& params);
   bool DestroyOnGpuThread();
   void FlushOnGpuThread(int32 put_offset);
-  void ScheduleIdleWorkOnGpuThread();
+  void ScheduleDelayedWorkOnGpuThread();
   uint32 CreateStreamTextureOnGpuThread(uint32 client_texture_id);
   bool MakeCurrent();
   base::Closure WrapCallback(const base::Closure& callback);
   State GetStateFast();
   void QueueTask(const base::Closure& task) { service_->ScheduleTask(task); }
   void CheckSequencedThread();
   void RetireSyncPointOnGpuThread(uint32 sync_point);
   void SignalSyncPointOnGpuThread(uint32 sync_point,
                                   const base::Closure& callback);
   bool WaitSyncPointOnGpuThread(uint32 sync_point);
   void SignalQueryOnGpuThread(unsigned query_id, const base::Closure& callback);
   void DestroyTransferBufferOnGpuThread(int32 id);
   void CreateImageOnGpuThread(int32 id,
                               const gfx::GpuMemoryBufferHandle& handle,
                               const gfx::Size& size,
                               gfx::BufferFormat format,
                               uint32 internalformat);
   void DestroyImageOnGpuThread(int32 id);
   void SetGetBufferOnGpuThread(int32 shm_id, base::WaitableEvent* completion);
 
   // Callbacks:
   void OnContextLost();
   void OnResizeView(gfx::Size size, float scale_factor);
   bool GetBufferChanged(int32 transfer_buffer_id);
   void PumpCommands();
-  void PerformIdleWork();
+  void PerformDelayedWork();
 
   // Members accessed on the gpu thread (possibly with the exception of
   // creation):
   bool context_lost_;
   scoped_refptr<TransferBufferManagerInterface> transfer_buffer_manager_;
   scoped_ptr<GpuScheduler> gpu_scheduler_;
   scoped_ptr<gles2::GLES2Decoder> decoder_;
   scoped_refptr<gfx::GLContext> context_;
   scoped_refptr<gfx::GLSurface> surface_;
   base::Closure context_lost_callback_;
-  bool idle_work_pending_;  // Used to throttle PerformIdleWork.
+  bool delayed_work_pending_;  // Used to throttle PerformDelayedWork.
   ImageFactory* image_factory_;
 
   // Members accessed on the client thread:
   State last_state_;
   int32 last_put_offset_;
   gpu::Capabilities capabilities_;
   GpuMemoryBufferManager* gpu_memory_buffer_manager_;
   base::AtomicSequenceNumber next_image_id_;
 
   // Accessed on both threads:
@@ skipping 23 matching lines @@
 class GPU_EXPORT GpuInProcessThread
     : public base::Thread,
       public NON_EXPORTED_BASE(InProcessCommandBuffer::Service),
       public base::RefCountedThreadSafe<GpuInProcessThread> {
  public:
   explicit GpuInProcessThread(SyncPointManager* sync_point_manager);
 
   void AddRef() const override;
   void Release() const override;
   void ScheduleTask(const base::Closure& task) override;
-  void ScheduleIdleWork(const base::Closure& callback) override;
+  void ScheduleDelayedWork(const base::Closure& callback) override;
   bool UseVirtualizedGLContexts() override;
   scoped_refptr<gles2::ShaderTranslatorCache> shader_translator_cache()
       override;
   scoped_refptr<gles2::FramebufferCompletenessCache>
   framebuffer_completeness_cache() override;
   SyncPointManager* sync_point_manager() override;
 
  private:
   ~GpuInProcessThread() override;
   friend class base::RefCountedThreadSafe<GpuInProcessThread>;
 
   SyncPointManager* sync_point_manager_;  // Non-owning.
   scoped_refptr<gpu::gles2::ShaderTranslatorCache> shader_translator_cache_;
   scoped_refptr<gpu::gles2::FramebufferCompletenessCache>
       framebuffer_completeness_cache_;
   DISALLOW_COPY_AND_ASSIGN(GpuInProcessThread);
 };
 
 }  // namespace gpu
 
 #endif  // GPU_COMMAND_BUFFER_SERVICE_IN_PROCESS_COMMAND_BUFFER_H_