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;
+}
+#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) {
+    // Stop doing work on this command buffer. In the GPU process,
+    // receipt of the GpuMsg_AcceleratedSurfaceBuffersSwappedACK
+    // message causes ProcessCommands to be scheduled again.
+    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;
   }
 
   command_buffer_->SetGetOffset(static_cast<int32>(parser_->get()));
 
   if (!parser_->IsEmpty()) {
-    MessageLoop::current()->PostTask(
-        FROM_HERE,
-        method_factory_.NewRunnableMethod(&GPUProcessor::ProcessCommands));
+    ScheduleProcessCommands();
   }
 }
 
+void GPUProcessor::ScheduleProcessCommands() {
+  MessageLoop::current()->PostTask(
+      FROM_HERE,
+      method_factory_.NewRunnableMethod(&GPUProcessor::ProcessCommands));
+}
+
 Buffer GPUProcessor::GetSharedMemoryBuffer(int32 shm_id) {
   return command_buffer_->GetTransferBuffer(shm_id);
 }
 
 void GPUProcessor::set_token(int32 token) {
   command_buffer_->SetToken(token);
 }
 
 bool GPUProcessor::SetGetOffset(int32 offset) {
   if (parser_->set_get(offset)) {
@@ skipping 13 matching lines @@
 
 void GPUProcessor::SetSwapBuffersCallback(
     Callback0::Type* callback) {
   wrapped_swap_buffers_callback_.reset(callback);
   decoder_->SetSwapBuffersCallback(
       NewCallback(this,
                   &GPUProcessor::WillSwapBuffers));
 }
 
 }  // namespace gpu