gpu: don't try to discard/recreate backbuffer while draws are deferred.

content/common/gpu/gpu_channel.cc

 // Copyright (c) 2012 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(OS_WIN)
 #include <windows.h>
 #endif
 
 #include "content/common/gpu/gpu_channel.h"
 
@@ skipping 217 matching lines @@
     : gpu_channel_manager_(gpu_channel_manager),
       unprocessed_messages_(new gpu::RefCountedCounter),
       client_id_(client_id),
       share_group_(share_group ? share_group : new gfx::GLShareGroup),
       mailbox_manager_(mailbox ? mailbox : new gpu::gles2::MailboxManager),
       image_manager_(new gpu::gles2::ImageManager),
       watchdog_(watchdog),
       software_(software),
       handle_messages_scheduled_(false),
       processed_get_state_fast_(false),
+      currently_processing_message_(NULL),
       weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
   DCHECK(gpu_channel_manager);
   DCHECK(client_id);
 
   channel_id_ = IPC::Channel::GenerateVerifiedChannelID("gpu");
   const CommandLine* command_line = CommandLine::ForCurrentProcess();
   log_messages_ = command_line->HasSwitch(switches::kLogPluginMessages);
   disallowed_features_.multisampling =
       command_line->HasSwitch(switches::kDisableGLMultisampling);
 #if defined(OS_ANDROID)
@@ skipping 105 matching lines @@
   }
 
   if (!channel_.get()) {
     delete message;
     return false;
   }
 
   return channel_->Send(message);
 }
 
+void GpuChannel::RequeueMessage() {
+  DCHECK(currently_processing_message_);
+  deferred_messages_.push_front(
+      new IPC::Message(*currently_processing_message_));
+  unprocessed_messages_->IncCount();
+  currently_processing_message_ = NULL;
+}
+
 void GpuChannel::OnScheduled() {
   if (handle_messages_scheduled_)
     return;
   // 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 HandleMessage. HandleMessage is invoked as a
   // task to prevent reentrancy.
   MessageLoop::current()->PostTask(
       FROM_HERE,
@@ skipping 160 matching lines @@
       }
       return;
     }
 
     scoped_ptr<IPC::Message> message(m);
     deferred_messages_.pop_front();
     unprocessed_messages_->DecCount();
 
     processed_get_state_fast_ =
         (message->type() == GpuCommandBufferMsg_GetStateFast::ID);
+
+    currently_processing_message_ = message.get();
+    bool result = router_.RouteMessage(*message);
+    currently_processing_message_ = NULL;
+
     // Handle deferred control messages.
-    if (!router_.RouteMessage(*message)) {
+    if (!result) {
       // Respond to sync messages even if router failed to route.
       if (message->is_sync()) {
         IPC::Message* reply = IPC::SyncMessage::GenerateReply(&*message);
         reply->set_reply_error();
         Send(reply);
       }
     } else {
       // If the command buffer becomes unscheduled as a result of handling the
       // message but still has more commands to process, synthesize an IPC
       // message to flush that command buffer.
@@ skipping 117 matching lines @@
     }
   }
 
   GpuChannelMsg_CollectRenderingStatsForSurface::WriteReplyParams(
       reply_message,
       stats);
   Send(reply_message);
 }
 
 }  // namespace content