Added a way for sync point clients to issue out of order waits.

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.
 
 #include "content/common/gpu/gpu_channel.h"
 
 #include <utility>
 
 #if defined(OS_WIN)
 #include <windows.h>
@@ skipping 147 matching lines @@
     return channel_messages_.front();
   }
   return nullptr;
 }
 
 void GpuChannelMessageQueue::BeginMessageProcessing(
     const GpuChannelMessage* msg) {
   sync_point_order_data_->BeginProcessingOrderNumber(msg->order_number);
 }
 
+void GpuChannelMessageQueue::PauseMessageProcessing(
+    const GpuChannelMessage* msg) {
+  sync_point_order_data_->PauseProcessingOrderNumber(msg->order_number);
+}
+
 bool GpuChannelMessageQueue::MessageProcessed() {
   base::AutoLock auto_lock(channel_messages_lock_);
   DCHECK(!channel_messages_.empty());
   scoped_ptr<GpuChannelMessage> msg(channel_messages_.front());
   channel_messages_.pop_front();
   sync_point_order_data_->FinishProcessingOrderNumber(msg->order_number);
   return !channel_messages_.empty();
 }
 
 void GpuChannelMessageQueue::DeleteAndDisableMessages() {
@@ skipping 673 matching lines @@
     IPC::Message* reply = IPC::SyncMessage::GenerateReply(&message);
     reply->set_reply_error();
     Send(reply);
     handled = true;
   }
 
   // A command buffer may be descheduled or preempted but only in the middle of
   // a flush. In this case we should not pop the message from the queue.
   if (stub && stub->HasUnprocessedCommands()) {
     DCHECK_EQ((uint32_t)GpuCommandBufferMsg_AsyncFlush::ID, message.type());
+    message_queue_->PauseMessageProcessing(m);
     // If the stub is still scheduled then we were preempted and need to
     // schedule a wakeup otherwise some other event will wake us up e.g. sync
     // point completion. No DCHECK for preemption flag because that can change
     // any time.
     if (stub->IsScheduled())
       ScheduleHandleMessage();
     return;
   }
 
   if (message_queue_->MessageProcessed())
@@ skipping 200 matching lines @@
     }
   }
 }
 
 void GpuChannel::HandleUpdateValueState(
     unsigned int target, const gpu::ValueState& state) {
   pending_valuebuffer_state_->UpdateState(target, state);
 }
 
 }  // namespace content