Add flow control between renderer and GPU processes, and, on Mac OS X,...

gpu/command_buffer/service/gpu_processor.cc

 // Copyright (c) 2009 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 "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
 #include "app/gfx/gl/gl_context.h"
 #include "gpu/command_buffer/service/gpu_processor.h"
 
 using ::base::SharedMemory;
 
 namespace gpu {
 
 GPUProcessor::GPUProcessor(CommandBuffer* command_buffer,
                            gles2::ContextGroup* group)
     : command_buffer_(command_buffer),
       commands_per_update_(100),
+#if defined(OS_MACOSX)
+      swap_buffers_count_(0),
+      acknowledged_swap_buffers_count_(0),
+#endif
       method_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
   DCHECK(command_buffer);
   decoder_.reset(gles2::GLES2Decoder::Create(group));
   decoder_->set_engine(this);
 }
 
 GPUProcessor::GPUProcessor(CommandBuffer* command_buffer,
                            gles2::GLES2Decoder* decoder,
                            CommandParser* parser,
                            int commands_per_update)
     : command_buffer_(command_buffer),
       commands_per_update_(commands_per_update),
+#if defined(OS_MACOSX)
+      swap_buffers_count_(0),
+      acknowledged_swap_buffers_count_(0),
+#endif
       method_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
   DCHECK(command_buffer);
   decoder_.reset(decoder);
   parser_.reset(parser);
 }
 
 GPUProcessor::~GPUProcessor() {
   Destroy();
 }
 
@@ skipping 39 matching lines @@
   bool have_context = false;
   if (decoder_.get()) {
     have_context = decoder_->MakeCurrent();
     decoder_->Destroy();
     decoder_.reset();
   }
 
   parser_.reset();
 }
 
+#if defined(OS_MACOSX)
+namespace {
+const unsigned int kMaxOutstandingSwapBuffersCallsPerOnscreenContext = 1;
+const int64 kWaitingTimeForSwapBuffers = 1;  // ms
+}
+#endif
+
 void GPUProcessor::ProcessCommands() {
   CommandBuffer::State state = command_buffer_->GetState();
   if (state.error != error::kNoError)
     return;
 
   if (decoder_.get()) {
     if (!decoder_->MakeCurrent()) {
       LOG(ERROR) << "Context lost because MakeCurrent failed.";
       command_buffer_->SetParseError(error::kLostContext);
       return;
     }
   }
 
   parser_->set_put(state.put_offset);
 
+#if defined(OS_MACOSX)
+  bool do_rate_limiting = surface_.get() != NULL;
+  // Don't swamp the browser process with SwapBuffers calls it can't handle.
+  if (do_rate_limiting &&
+      swap_buffers_count_ - acknowledged_swap_buffers_count_ >=
+      kMaxOutstandingSwapBuffersCallsPerOnscreenContext) {
+    // Defer the processing of more commands.
+    MessageLoop::current()->PostDelayedTask(

[apatrick_chromium, 2010/11/24 23:56:09]

Rather than repeatedly poll for progress every 1ms, you could post the task to
continue processing this command buffer from the IPC message handler for the
SwapBuffers ack.

[Ken Russell (switch to Gerrit), 2010/11/25 01:02:08]

Thanks, this is an excellent suggestion and cleans up an area I was not
comfortable with. I've retested with this change.

+        FROM_HERE,
+        method_factory_.NewRunnableMethod(&GPUProcessor::ProcessCommands),
+        kWaitingTimeForSwapBuffers);
+    return;
+  }
+#endif
+
   int commands_processed = 0;
   while (commands_processed < commands_per_update_ && !parser_->IsEmpty()) {
     error::Error error = parser_->ProcessCommand();
     if (error != error::kNoError) {
       command_buffer_->SetParseError(error);
       return;
     }
     ++commands_processed;
   }
 
@@ skipping 32 matching lines @@
 
 void GPUProcessor::SetSwapBuffersCallback(
     Callback0::Type* callback) {
   wrapped_swap_buffers_callback_.reset(callback);
   decoder_->SetSwapBuffersCallback(
       NewCallback(this,
                   &GPUProcessor::WillSwapBuffers));
 }
 
 }  // namespace gpu