gpu: Add callback for yielding command buffer execution.

gpu/command_buffer/service/command_executor.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/command_executor.h"
 
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/message_loop/message_loop.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "gpu/command_buffer/service/logger.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_fence.h"
 #include "ui/gl/gl_switches.h"
 
 using ::base::SharedMemory;
 
 namespace gpu {
 
 CommandExecutor::CommandExecutor(CommandBufferServiceBase* command_buffer,
                                  AsyncAPIInterface* handler,
                                  gles2::GLES2Decoder* decoder)
-    : command_buffer_(command_buffer),
-      handler_(handler),
-      decoder_(decoder),
-      scheduled_(true),
-      was_preempted_(false) {}
+    : command_buffer_(command_buffer), handler_(handler), decoder_(decoder) {}
 
 CommandExecutor::~CommandExecutor() {}
 
 void CommandExecutor::PutChanged() {
   TRACE_EVENT1("gpu", "CommandExecutor:PutChanged", "decoder",
                decoder_ ? decoder_->GetLogger()->GetLogPrefix() : "None");
 
   CommandBuffer::State state = command_buffer_->GetLastState();
 
   // If there is no parser, exit.
   if (!parser_.get()) {
     DCHECK_EQ(state.get_offset, command_buffer_->GetPutOffset());
     return;
   }
 
   parser_->set_put(command_buffer_->GetPutOffset());
   if (state.error != error::kNoError)
     return;
 
   base::TimeTicks begin_time(base::TimeTicks::Now());
   error::Error error = error::kNoError;
   if (decoder_)
     decoder_->BeginDecoding();
   while (!parser_->IsEmpty()) {
-    if (IsPreempted())
+    if (PauseExecution())
       break;
 
     DCHECK(scheduled());
 
     error = parser_->ProcessCommands(CommandParser::kParseCommandsSlice);
 
     if (error == error::kDeferCommandUntilLater) {
       DCHECK(!scheduled());
       break;
     }
@@ skipping 78 matching lines @@
 
 int32_t CommandExecutor::GetGetOffset() {
   return parser_->get();
 }
 
 void CommandExecutor::SetCommandProcessedCallback(
     const base::Closure& callback) {
   command_processed_callback_ = callback;
 }
 
-bool CommandExecutor::IsPreempted() {
-  if (!preemption_flag_.get())
+void CommandExecutor::SetPauseExecutionCallback(
+    const PauseExecutionCallback& callback) {
+  pause_execution_callback_ = callback;
+}
+
+bool CommandExecutor::PauseExecution() {
+  if (pause_execution_callback_.is_null())
     return false;
 
-  if (!was_preempted_ && preemption_flag_->IsSet()) {
-    TRACE_COUNTER_ID1("gpu", "CommandExecutor::Preempted", this, 1);
-    was_preempted_ = true;
-  } else if (was_preempted_ && !preemption_flag_->IsSet()) {
-    TRACE_COUNTER_ID1("gpu", "CommandExecutor::Preempted", this, 0);
-    was_preempted_ = false;
+  bool pause = pause_execution_callback_.Run();
+  if (paused_ != pause) {
+    TRACE_COUNTER_ID1("gpu", "CommandExecutor::Paused", this, pause);
+    paused_ = pause;
   }
-
-  return preemption_flag_->IsSet();
+  return pause;
 }
 
 bool CommandExecutor::HasMoreIdleWork() const {
   return (decoder_ && decoder_->HasMoreIdleWork());
 }
 
 void CommandExecutor::PerformIdleWork() {
   if (!decoder_)
     return;
   decoder_->PerformIdleWork();
 }
 
 bool CommandExecutor::HasPollingWork() const {
   return (decoder_ && decoder_->HasPollingWork());
 }
 
 void CommandExecutor::PerformPollingWork() {
   if (!decoder_)
     return;
   decoder_->PerformPollingWork();
 }
 
 }  // namespace gpu