Implement new behavior for DescheduleUntilFinishedCHROMIUM.

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 2173 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_;
+  // After a second fence is inserted, both the GpuChannelMessageQueue and
+  // CommandExecutor are descheduled. Once the first fence has completed, both
+  // get rescheduled.
+  std::vector<std::unique_ptr<gl::GLFence>> deschedule_until_finished_fences_;
 
   // 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);
 
@@ skipping 11459 matching lines @@
     uint32_t immediate_data_size,
     const void* cmd_data) {
   if (deschedule_until_finished_callback_.is_null() ||
       reschedule_after_finished_callback_.is_null()) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION,
                        "glDescheduleUntilFinishedCHROMIUM",
                        "Not fully implemented.");
     return error::kNoError;
   }
 
-  deschedule_until_finished_fence_.reset(gl::GLFence::Create());
-  DCHECK(deschedule_until_finished_fence_);
-  if (deschedule_until_finished_fence_->HasCompleted()) {
-    deschedule_until_finished_fence_.reset();
+  std::unique_ptr<gl::GLFence> fence(gl::GLFence::Create());
+  deschedule_until_finished_fences_.push_back(std::move(fence));
+
+  if (deschedule_until_finished_fences_.size() == 1)
+    return error::kNoError;
+
+  DCHECK_EQ(2u, deschedule_until_finished_fences_.size());
+  if (deschedule_until_finished_fences_[0]->HasCompleted()) {
+    deschedule_until_finished_fences_.erase(
+        deschedule_until_finished_fences_.begin());
     return error::kNoError;
   }
 
   TRACE_EVENT_ASYNC_BEGIN0("cc", "GLES2DecoderImpl::DescheduleUntilFinished",
                            this);
   deschedule_until_finished_callback_.Run();
   return error::kDeferLaterCommands;
 }
 
 error::Error GLES2DecoderImpl::HandleInsertFenceSyncCHROMIUM(
@@ skipping 116 matching lines @@
     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_)
+  if (deschedule_until_finished_fences_.size() < 2)
     return;
+  DCHECK_EQ(2u, deschedule_until_finished_fences_.size());
 
-  if (!deschedule_until_finished_fence_->HasCompleted())
+  if (!deschedule_until_finished_fences_[0]->HasCompleted())
     return;
 
   TRACE_EVENT_ASYNC_END0("cc", "GLES2DecoderImpl::DescheduleUntilFinished",
                          this);
-  deschedule_until_finished_fence_.reset();
+  deschedule_until_finished_fences_.erase(
+      deschedule_until_finished_fences_.begin());
   reschedule_after_finished_callback_.Run();
 }
 
 bool GLES2DecoderImpl::HasMoreIdleWork() const {
   return !pending_readpixel_fences_.empty() ||
          gpu_tracer_->HasTracesToProcess();
 }
 
 void GLES2DecoderImpl::PerformIdleWork() {
   gpu_tracer_->ProcessTraces();
   ProcessPendingReadPixels(false);
 }
 
 bool GLES2DecoderImpl::HasPollingWork() const {
-  return !!deschedule_until_finished_fence_.get();
+  return deschedule_until_finished_fences_.size() >= 2;
 }
 
 void GLES2DecoderImpl::PerformPollingWork() {
   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);
@@ skipping 2954 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