Call set_unblock(true) on async resize message to guarantee its...

chrome/renderer/command_buffer_proxy.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/logging.h"
 #include "base/process_util.h"
 #include "chrome/common/gpu_messages.h"
 #include "chrome/common/plugin_messages.h"
 #include "chrome/renderer/command_buffer_proxy.h"
 #include "chrome/renderer/plugin_channel_host.h"
@@ skipping 166 matching lines @@
         FROM_HERE, notify_repaint_task_.release());
 }
 
 void CommandBufferProxy::SetParseError(
     gpu::error::Error error) {
   // Not implemented in proxy.
   NOTREACHED();
 }
 
 void CommandBufferProxy::ResizeOffscreenFrameBuffer(const gfx::Size& size) {
-  Send(new GpuCommandBufferMsg_ResizeOffscreenFrameBuffer(route_id_, size));
+  IPC::Message* message =
+      new GpuCommandBufferMsg_ResizeOffscreenFrameBuffer(route_id_, size);
+  // We need to set the unblock flag on this message to guarantee the
+  // order in which it is processed in the GPU process. Ordinarily in
+  // certain situations, namely if a synchronous message is being
+  // processed, other synchronous messages may be processed before
+  // asynchronous messages. During some page reloads WebGL seems to
+  // send three messages (sync, async, sync) in rapid succession in
+  // that order, and the sync message (GpuCommandBufferMsg_Flush, on
+  // behalf of SwapBuffers) is sometimes processed before the async
+  // message (GpuCommandBufferMsg_ResizeOffscreenFrameBuffer). This
+  // causes the WebGL content to disappear because the back buffer is
+  // not correctly resized.
+  message->set_unblock(true);
+  Send(message);
 }
 
 #if defined(OS_MACOSX)
 void CommandBufferProxy::SetWindowSize(const gfx::Size& size) {
   Send(new GpuCommandBufferMsg_SetWindowSize(route_id_, size));
 }
 #endif
 
 void CommandBufferProxy::AsyncGetState(Task* completion_task) {
   IPC::Message* message = new GpuCommandBufferMsg_AsyncGetState(route_id_);
@@ skipping 27 matching lines @@
   pending_async_flush_tasks_.pop();
 
   if (task.get()) {
     // Although we need need to update last_state_ while potentially waiting
     // for a synchronous flush to complete, we do not need to invoke the
     // callback synchonously. Also, post it as a non nestable task so it is
     // always invoked by the outermost message loop.
     MessageLoop::current()->PostNonNestableTask(FROM_HERE, task.release());
   }
 }