Execute all GL commands up to the put offset reported by a flush.

content/common/gpu/gpu_command_buffer_stub.cc

 // Copyright (c) 2011 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.
 
 #if defined(ENABLE_GPU)
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/debug/trace_event.h"
 #include "base/process_util.h"
@@ skipping 46 matching lines @@
   if (scheduler_.get()) {
     scheduler_->Destroy();
   }
 
   GpuChannelManager* gpu_channel_manager = channel_->gpu_channel_manager();
   gpu_channel_manager->Send(new GpuHostMsg_DestroyCommandBuffer(
       handle_, renderer_id_, render_view_id_));
 }
 
 bool GpuCommandBufferStub::OnMessageReceived(const IPC::Message& message) {
-  // If the scheduler is unscheduled, defer sync and async messages until it is
-  // rescheduled. Also, even if the scheduler is scheduled, do not allow newly
-  // received messages to be handled before previously received deferred ones;
-  // append them to the deferred queue as well.
-  if ((scheduler_.get() && !scheduler_->IsScheduled()) ||
-      !deferred_messages_.empty()) {
-    deferred_messages_.push(new IPC::Message(message));
-    return true;
-  }
-
   // Always use IPC_MESSAGE_HANDLER_DELAY_REPLY for synchronous message handlers
   // here. This is so the reply can be delayed if the scheduler is unscheduled.
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(GpuCommandBufferStub, message)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_Initialize,
                                     OnInitialize);
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_SetParent,
                                     OnSetParent);
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_GetState, OnGetState);
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_Flush, OnFlush);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_AsyncFlush, OnAsyncFlush);
+    IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_Rescheduled, OnRescheduled);
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_CreateTransferBuffer,
                                     OnCreateTransferBuffer);
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_RegisterTransferBuffer,
                                     OnRegisterTransferBuffer);
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_DestroyTransferBuffer,
                                     OnDestroyTransferBuffer);
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_GetTransferBuffer,
                                     OnGetTransferBuffer);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_CreateVideoDecoder,
                         OnCreateVideoDecoder)
@@ skipping 13 matching lines @@
     handled = video_decoder_->OnMessageReceived(message);
 
   DCHECK(handled);
   return handled;
 }
 
 bool GpuCommandBufferStub::Send(IPC::Message* message) {
   return channel_->Send(message);
 }
 
+bool GpuCommandBufferStub::IsScheduled() {
+  return !scheduler_.get() || scheduler_->IsScheduled();
+}
+
 void GpuCommandBufferStub::OnInitialize(
     base::SharedMemoryHandle ring_buffer,
     int32 size,
     IPC::Message* reply_message) {
   DCHECK(!command_buffer_.get());
 
   bool result = false;
 
   command_buffer_.reset(new gpu::CommandBufferService);
 
 #if defined(OS_WIN)
   // Windows dups the shared memory handle it receives into the current process
   // and closes it when this variable goes out of scope.
   base::SharedMemory shared_memory(ring_buffer,
                                    false,
                                    channel_->renderer_process());
 #else
   // POSIX receives a dup of the shared memory handle and closes the dup when
   // this variable goes out of scope.
   base::SharedMemory shared_memory(ring_buffer, false);
 #endif
 
   // Initialize the CommandBufferService and GpuScheduler.
   if (command_buffer_->Initialize(&shared_memory, size)) {
-    scheduler_.reset(new gpu::GpuScheduler(command_buffer_.get(),
-                                           channel_,
-                                           NULL));
+    scheduler_.reset(gpu::GpuScheduler::Create(command_buffer_.get(),
+                                               channel_,
+                                               NULL));
     if (scheduler_->Initialize(
         handle_,
         initial_size_,
         disallowed_extensions_,
         allowed_extensions_.c_str(),
         requested_attribs_,
         channel_->share_group())) {
       command_buffer_->SetPutOffsetChangeCallback(
           NewCallback(scheduler_.get(),
                       &gpu::GpuScheduler::PutChanged));
       command_buffer_->SetParseErrorCallback(
           NewCallback(this, &GpuCommandBufferStub::OnParseError));
       scheduler_->SetSwapBuffersCallback(
           NewCallback(this, &GpuCommandBufferStub::OnSwapBuffers));
-      scheduler_->SetLatchCallback(base::Bind(
-          &GpuChannel::OnLatchCallback, base::Unretained(channel_), route_id_));
       scheduler_->SetScheduledCallback(
-          NewCallback(this, &GpuCommandBufferStub::OnScheduled));
+          NewCallback(channel_, &GpuChannel::OnScheduled));
       scheduler_->SetTokenCallback(base::Bind(
           &GpuCommandBufferStub::OnSetToken, base::Unretained(this)));
       if (watchdog_)
         scheduler_->SetCommandProcessedCallback(
             NewCallback(this, &GpuCommandBufferStub::OnCommandProcessed));
 
 #if defined(OS_MACOSX) || defined(TOUCH_UI)
       if (handle_) {
         // This context conceptually puts its output directly on the
         // screen, rendered by the accelerated plugin layer in
@@ skipping 78 matching lines @@
   // it may cause other side effects to simply pass the next WaitLatch on all
   // contexts. Instead, just lose all related contexts when there's an error.
   channel_->DestroySoon();
 }
 
 void GpuCommandBufferStub::OnFlush(int32 put_offset,
                                    int32 last_known_get,
                                    uint32 flush_count,
                                    IPC::Message* reply_message) {
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnFlush");
-  gpu::CommandBuffer::State state;
+  gpu::CommandBuffer::State state = command_buffer_->GetState();
   if (flush_count - last_flush_count_ >= 0x8000000U) {
     // We received this message out-of-order. This should not happen but is here
     // to catch regressions. Ignore the message.
     NOTREACHED() << "Received an AsyncFlush message out-of-order";
-    state = command_buffer_->GetState();
+    GpuCommandBufferMsg_Flush::WriteReplyParams(reply_message, state);
+    Send(reply_message);
   } else {
     last_flush_count_ = flush_count;
+
+    // Reply immediately if the client was out of date with the current get
+    // offset.
+    bool reply_immediately = state.get_offset != last_known_get;
+    if (reply_immediately) {
+      GpuCommandBufferMsg_Flush::WriteReplyParams(reply_message, state);
+      Send(reply_message);
+    }
+
+    // Process everything up to the put offset.
     state = command_buffer_->FlushSync(put_offset, last_known_get);
+
+    // Lose all contexts if the context was lost.
+    if (state.error == gpu::error::kLostContext &&
+        gfx::GLContext::LosesAllContextsOnContextLost()) {
+      channel_->LoseAllContexts();
+    }
+
+    // Then if the client was up-to-date with the get offset, reply to the
+    // synchronpous IPC only after processing all commands are processed. This
+    // prevents the client from "spinning" when it fills up the command buffer.
+    // Otherwise, since the state has changed since the immediate reply, send
+    // an asyncronous state update back to the client.
+    if (!reply_immediately) {
+      GpuCommandBufferMsg_Flush::WriteReplyParams(reply_message, state);
+      Send(reply_message);
+    } else {
+      ReportState();
+    }
   }
-  if (state.error == gpu::error::kLostContext &&
-      gfx::GLContext::LosesAllContextsOnContextLost())
-    channel_->LoseAllContexts();
-
-  GpuCommandBufferMsg_Flush::WriteReplyParams(reply_message, state);
-  Send(reply_message);
 }
 
 void GpuCommandBufferStub::OnAsyncFlush(int32 put_offset, uint32 flush_count) {
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnAsyncFlush");
   if (flush_count - last_flush_count_ < 0x8000000U) {
     last_flush_count_ = flush_count;
     command_buffer_->Flush(put_offset);
   } else {
     // We received this message out-of-order. This should not happen but is here
     // to catch regressions. Ignore the message.
     NOTREACHED() << "Received a Flush message out-of-order";
   }
-  // TODO(piman): Do this everytime the scheduler finishes processing a batch of
-  // commands.
-  MessageLoop::current()->PostTask(FROM_HERE,
-      task_factory_.NewRunnableMethod(&GpuCommandBufferStub::ReportState));
+
+  ReportState();
+}
+
+void GpuCommandBufferStub::OnRescheduled() {
+  gpu::CommandBuffer::State state = command_buffer_->GetLastState();
+  command_buffer_->Flush(state.put_offset);
+
+  ReportState();
 }
 
 void GpuCommandBufferStub::OnCreateTransferBuffer(int32 size,
                                                   int32 id_request,
                                                   IPC::Message* reply_message) {
   int32 id = command_buffer_->CreateTransferBuffer(size, id_request);
   GpuCommandBufferMsg_CreateTransferBuffer::WriteReplyParams(reply_message, id);
   Send(reply_message);
 }
 
@@ skipping 63 matching lines @@
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnSwapBuffers");
   ReportState();
   Send(new GpuCommandBufferMsg_SwapBuffers(route_id_));
 }
 
 void GpuCommandBufferStub::OnCommandProcessed() {
   if (watchdog_)
     watchdog_->CheckArmed();
 }
 
-void GpuCommandBufferStub::HandleDeferredMessages() {
-  // Empty the deferred queue so OnMessageRecieved does not defer on that
-  // account and to prevent an infinite loop if the scheduler is unscheduled
-  // as a result of handling already deferred messages.
-  std::queue<IPC::Message*> deferred_messages_copy;
-  std::swap(deferred_messages_copy, deferred_messages_);
-
-  while (!deferred_messages_copy.empty()) {
-    scoped_ptr<IPC::Message> message(deferred_messages_copy.front());
-    deferred_messages_copy.pop();
-
-    OnMessageReceived(*message);
-  }
-}
-
-void GpuCommandBufferStub::OnScheduled() {
-  // Post a task to handle any deferred messages. The deferred message queue is
-  // not emptied here, which ensures that OnMessageReceived will continue to
-  // defer newly received messages until the ones in the queue have all been
-  // handled by HandleDeferredMessages. HandleDeferredMessages is invoked as a
-  // task to prevent reentrancy.
-  MessageLoop::current()->PostTask(
-      FROM_HERE,
-      task_factory_.NewRunnableMethod(
-          &GpuCommandBufferStub::HandleDeferredMessages));
-}
-
 #if defined(OS_MACOSX)
 void GpuCommandBufferStub::OnSetWindowSize(const gfx::Size& size) {
   GpuChannelManager* gpu_channel_manager = channel_->gpu_channel_manager();
   // Try using the IOSurface version first.
   uint64 new_backing_store = scheduler_->SetWindowSizeForIOSurface(size);
   if (new_backing_store) {
     GpuHostMsg_AcceleratedSurfaceSetIOSurface_Params params;
     params.renderer_id = renderer_id_;
     params.render_view_id = render_view_id_;
     params.window = handle_;
@@ skipping 67 matching lines @@
   scheduler_->set_acknowledged_swap_buffers_count(swap_buffers_count);
 
   for(uint64 i = 0; i < delta; i++) {
     OnSwapBuffers();
     // Wake up the GpuScheduler to start doing work again.
     scheduler_->SetScheduled(true);
   }
 }
 #endif  // defined(OS_MACOSX) || defined(TOUCH_UI)
 
-void GpuCommandBufferStub::CommandBufferWasDestroyed() {
-  TRACE_EVENT0("gpu", "GpuCommandBufferStub::CommandBufferWasDestroyed");
-  // In case the renderer is currently blocked waiting for a sync reply from
-  // the stub, this method allows us to cleanup and unblock pending messages.
-  if (scheduler_.get()) {
-    while (!scheduler_->IsScheduled())
-      scheduler_->SetScheduled(true);
-  }
-  // Handle any deferred messages now that the scheduler is not blocking
-  // message handling.
-  HandleDeferredMessages();
-}
-
 void GpuCommandBufferStub::AddSetTokenCallback(
     const base::Callback<void(int32)>& callback) {
   set_token_callbacks_.push_back(callback);
 }
 
 void GpuCommandBufferStub::OnSetToken(int32 token) {
   for (size_t i = 0; i < set_token_callbacks_.size(); ++i)
     set_token_callbacks_[i].Run(token);
 }
 
@@ skipping 75 matching lines @@
       new GpuVideoDecodeAccelerator(this, route_id_, this));
   video_decoder_->Initialize(configs);
 }
 
 void GpuCommandBufferStub::OnDestroyVideoDecoder() {
   LOG(ERROR) << "GpuCommandBufferStub::OnDestroyVideoDecoder";
   video_decoder_.reset();
 }
 
 #endif  // defined(ENABLE_GPU)