Revert 93066 - Execute all GL commands up to the put offset reported by a each flush.This means g...

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(gpu::GpuScheduler::Create(command_buffer_.get(),
-                                               channel_,
-                                               NULL));
+    scheduler_.reset(new gpu::GpuScheduler(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(channel_, &GpuChannel::OnScheduled));
+          NewCallback(this, &GpuCommandBufferStub::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 = command_buffer_->GetState();
+  gpu::CommandBuffer::State state;
   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";
-    GpuCommandBufferMsg_Flush::WriteReplyParams(reply_message, state);
-    Send(reply_message);
+    state = command_buffer_->GetState();
   } else {
     last_flush_count_ = flush_count;
+    state = command_buffer_->FlushSync(put_offset, last_known_get);
+  }
+  if (state.error == gpu::error::kLostContext &&
+      gfx::GLContext::LosesAllContextsOnContextLost())
+    channel_->LoseAllContexts();
 
-    // 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();
-    }
-  }
+  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";
   }
-
-  ReportState();
-}
-
-void GpuCommandBufferStub::OnRescheduled() {
-  gpu::CommandBuffer::State state = command_buffer_->GetLastState();
-  command_buffer_->Flush(state.put_offset);
-
-  ReportState();
+  // TODO(piman): Do this everytime the scheduler finishes processing a batch of
+  // commands.
+  MessageLoop::current()->PostTask(FROM_HERE,
+      task_factory_.NewRunnableMethod(&GpuCommandBufferStub::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)