gpu: Add a new extension CHROMIUM_deschedule.

gpu/command_buffer/service/gles2_cmd_decoder.cc

 // 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.
 
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
 #include <limits.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
@@ skipping 634 matching lines @@
   void EndDecoding() override;
 
   ErrorState* GetErrorState() override;
   const ContextState* GetContextState() override { return &state_; }
 
   void SetShaderCacheCallback(const ShaderCacheCallback& callback) override;
   void SetFenceSyncReleaseCallback(
       const FenceSyncReleaseCallback& callback) override;
   void SetWaitFenceSyncCallback(const WaitFenceSyncCallback& callback) override;
 
+  void SetDescheduleUntilFinishedCallback(
+      const NoParamCallback& callback) override;
+  void SetRescheduleAfterFinishedCallback(
+      const NoParamCallback& callback) override;
+
   void SetIgnoreCachedStateForTest(bool ignore) override;
   void SetForceShaderNameHashingForTest(bool force) override;
   uint32_t GetAndClearBackbufferClearBitsForTest() override;
   void ProcessFinishedAsyncTransfers();
 
   bool GetServiceTextureId(uint32_t client_texture_id,
                            uint32_t* service_texture_id) override;
 
   uint32_t GetTextureUploadCount() override;
   base::TimeDelta GetTotalTextureUploadTime() override;
@@ skipping 307 matching lines @@
       GLsizei height);
 
   // Wrapper for TexImageIOSurface2DCHROMIUM.
   void DoTexImageIOSurface2DCHROMIUM(
       GLenum target,
       GLsizei width,
       GLsizei height,
       GLuint io_surface_id,
       GLuint plane);
 
+  void DoDescheduleUntilFinishedCHROMIUM();
+
   void DoCopyTextureCHROMIUM(GLuint source_id,
                              GLuint dest_id,
                              GLenum internal_format,
                              GLenum dest_type,
                              GLboolean unpack_flip_y,
                              GLboolean unpack_premultiply_alpha,
                              GLboolean unpack_unmultiply_alpha);
 
   void DoCopySubTextureCHROMIUM(GLuint source_id,
                                 GLuint dest_id,
@@ skipping 963 matching lines @@
             back_buffer_color_format_ == GL_RGBA8);
   }
 
   // Set remaining commands to process to 0 to force DoCommands to return
   // and allow context preemption and GPU watchdog checks in CommandExecutor().
   void ExitCommandProcessingEarly() { commands_to_process_ = 0; }
 
   void ProcessPendingReadPixels(bool did_finish);
   void FinishReadPixels(const cmds::ReadPixels& c, GLuint buffer);
 
+  // Checks to see if the inserted fence has completed.
+  void ProcessDescheduleUntilFinished();
+
   void DoBindFragmentInputLocationCHROMIUM(GLuint program_id,
                                            GLint location,
                                            const std::string& name);
 
   // If |texture_manager_version_| doesn't match the current version, then this
   // will rebind all external textures to match their current service_id.
   void RestoreAllExternalTextureBindingsIfNeeded() override;
 
   const SamplerState& GetSamplerStateForTextureUnit(GLenum target, GLuint unit);
 
@@ skipping 119 matching lines @@
   GLenum offscreen_saved_color_format_;
 
   std::unique_ptr<QueryManager> query_manager_;
 
   std::unique_ptr<VertexArrayManager> vertex_array_manager_;
 
   std::unique_ptr<ImageManager> image_manager_;
 
   FenceSyncReleaseCallback fence_sync_release_callback_;
   WaitFenceSyncCallback wait_fence_sync_callback_;
+  NoParamCallback deschedule_until_finished_callback_;
+  NoParamCallback reschedule_after_finished_callback_;
 
   ShaderCacheCallback shader_cache_callback_;
 
   // The format of the back buffer_
   GLenum back_buffer_color_format_;
   bool back_buffer_has_depth_;
   bool back_buffer_has_stencil_;
 
   // Tracks read buffer and draw buffer for backbuffer, whether it's onscreen
   // or offscreen.
@@ skipping 75 matching lines @@
 
   std::unique_ptr<GPUTracer> gpu_tracer_;
   std::unique_ptr<GPUStateTracer> gpu_state_tracer_;
   const unsigned char* gpu_decoder_category_;
   int gpu_trace_level_;
   bool gpu_trace_commands_;
   bool gpu_debug_commands_;
 
   std::queue<linked_ptr<FenceCallback> > pending_readpixel_fences_;
 
+  // After this fence is inserted, both the GpuChannelMessageQueue and
+  // CommandExecutor are descheduled. Once the fence has completed, both get
+  // rescheduled.
+  std::unique_ptr<gl::GLFence> deschedule_until_finished_fence_;
+
   // Used to validate multisample renderbuffers if needed
   GLuint validation_texture_;
   GLuint validation_fbo_multisample_;
   GLuint validation_fbo_;
 
   typedef gpu::gles2::GLES2Decoder::Error (GLES2DecoderImpl::*CmdHandler)(
       uint32_t immediate_data_size,
       const void* data);
 
   // A struct to hold info about each command.
@@ skipping 1961 matching lines @@
 void GLES2DecoderImpl::SetFenceSyncReleaseCallback(
     const FenceSyncReleaseCallback& callback) {
   fence_sync_release_callback_ = callback;
 }
 
 void GLES2DecoderImpl::SetWaitFenceSyncCallback(
     const WaitFenceSyncCallback& callback) {
   wait_fence_sync_callback_ = callback;
 }
 
+void GLES2DecoderImpl::SetDescheduleUntilFinishedCallback(
+    const NoParamCallback& callback) {
+  deschedule_until_finished_callback_ = callback;
+}
+
+void GLES2DecoderImpl::SetRescheduleAfterFinishedCallback(
+    const NoParamCallback& callback) {
+  reschedule_after_finished_callback_ = callback;
+}
+
 bool GLES2DecoderImpl::GetServiceTextureId(uint32_t client_texture_id,
                                            uint32_t* service_texture_id) {
   TextureRef* texture_ref = texture_manager()->GetTexture(client_texture_id);
   if (texture_ref) {
     *service_texture_id = texture_ref->service_id();
     return true;
   }
   return false;
 }
 
@@ skipping 9582 matching lines @@
           pending_readpixel_fences_.front()->fence->HasCompleted())) {
     std::vector<base::Closure> callbacks =
         pending_readpixel_fences_.front()->callbacks;
     pending_readpixel_fences_.pop();
     for (size_t i = 0; i < callbacks.size(); i++) {
       callbacks[i].Run();
     }
   }
 }
 
+void GLES2DecoderImpl::ProcessDescheduleUntilFinished() {
+  if (!deschedule_until_finished_fence_)
+    return;
+
+  if (!deschedule_until_finished_fence_->HasCompleted())
+    return;
+
+  deschedule_until_finished_fence_.reset();
+  reschedule_after_finished_callback_.Run();
+}
+
 bool GLES2DecoderImpl::HasMoreIdleWork() const {
-  return !pending_readpixel_fences_.empty() ||
+  return deschedule_until_finished_fence_ ||
+         !pending_readpixel_fences_.empty() ||
          gpu_tracer_->HasTracesToProcess();
 }
 
 void GLES2DecoderImpl::PerformIdleWork() {
   gpu_tracer_->ProcessTraces();
   ProcessPendingReadPixels(false);
+  ProcessDescheduleUntilFinished();
 }
 
 error::Error GLES2DecoderImpl::HandleBeginQueryEXT(uint32_t immediate_data_size,
                                                    const void* cmd_data) {
   const gles2::cmds::BeginQueryEXT& c =
       *static_cast<const gles2::cmds::BeginQueryEXT*>(cmd_data);
   GLenum target = static_cast<GLenum>(c.target);
   GLuint client_id = static_cast<GLuint>(c.id);
   int32_t sync_shm_id = static_cast<int32_t>(c.sync_data_shm_id);
   uint32_t sync_shm_offset = static_cast<uint32_t>(c.sync_data_shm_offset);
@@ skipping 471 matching lines @@
 
   if (!valid_format) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, function_name,
                        "invalid internal format");
     return false;
   }
 
   return true;
 }
 
+void GLES2DecoderImpl::DoDescheduleUntilFinishedCHROMIUM() {
+  TRACE_EVENT0("gpu", "GLES2DecoderImpl::DoDescheduleUntilFinishedCHROMIUM");
+  if (deschedule_until_finished_callback_.is_null() ||
+      reschedule_after_finished_callback_.is_null()) {
+    return;
+  }
+
+  deschedule_until_finished_fence_.reset(gl::GLFence::Create());
+  DCHECK(deschedule_until_finished_fence_);
+  if (deschedule_until_finished_fence_->HasCompleted()) {
+    deschedule_until_finished_fence_.reset();
+    return;
+  }
+
+  deschedule_until_finished_callback_.Run();
+}
+
 void GLES2DecoderImpl::DoCopyTextureCHROMIUM(
     GLuint source_id,
     GLuint dest_id,
     GLenum internal_format,
     GLenum dest_type,
     GLboolean unpack_flip_y,
     GLboolean unpack_premultiply_alpha,
     GLboolean unpack_unmultiply_alpha) {
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::DoCopyTextureCHROMIUM");
   static const char kFunctionName[] = "glCopyTextureCHROMIUM";
@@ skipping 2534 matching lines @@
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "base/macros.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu