Added global order numbers to in process command buffers.

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"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 
@@ skipping 52 matching lines @@
 // Once we trigger a preemption, the maximum duration that we will wait
 // before clearing the preemption.
 const int64 kMaxPreemptTimeMs = kVsyncIntervalMs;
 
 // Stop the preemption once the time for the longest pending IPC drops
 // below this threshold.
 const int64 kStopPreemptThresholdMs = kVsyncIntervalMs;
 
 }  // anonymous namespace
 
-// Begin order numbers at 1 so 0 can mean no orders.
-uint32_t GpuChannelMessageQueue::global_order_counter_ = 1;
-
 scoped_refptr<GpuChannelMessageQueue> GpuChannelMessageQueue::Create(
     const base::WeakPtr<GpuChannel>& gpu_channel,
     base::SingleThreadTaskRunner* task_runner) {
   return new GpuChannelMessageQueue(gpu_channel, task_runner);
 }
 
+scoped_refptr<gpu::SyncPointClientState>
+    GpuChannelMessageQueue::GetSyncPointClientState() {
+  return sync_point_client_state_;
+}
+
 GpuChannelMessageQueue::GpuChannelMessageQueue(
     const base::WeakPtr<GpuChannel>& gpu_channel,
     base::SingleThreadTaskRunner* task_runner)
     : enabled_(true),
-      unprocessed_order_num_(0),
-      processed_order_num_(0),
+      sync_point_client_state_(gpu::SyncPointClientState::Create()),
       gpu_channel_(gpu_channel),
       task_runner_(task_runner) {}
 
 GpuChannelMessageQueue::~GpuChannelMessageQueue() {
   DCHECK(channel_messages_.empty());
 }
 
 uint32_t GpuChannelMessageQueue::GetUnprocessedOrderNum() const {
-  base::AutoLock auto_lock(channel_messages_lock_);
-  return unprocessed_order_num_;
+  return sync_point_client_state_->unprocessed_order_num();
 }
 
-void GpuChannelMessageQueue::PushBackMessage(const IPC::Message& message) {
+uint32_t GpuChannelMessageQueue::GetProcessedOrderNum() const {
+  return sync_point_client_state_->processed_order_num();
+}
+
+void GpuChannelMessageQueue::PushBackMessage(
+    gpu::SyncPointManager* sync_point_manager, const IPC::Message& message) {
   base::AutoLock auto_lock(channel_messages_lock_);
-  if (enabled_)
-    PushMessageHelper(make_scoped_ptr(new GpuChannelMessage(message)));
+  if (enabled_) {
+    PushMessageHelper(sync_point_manager,
+                      make_scoped_ptr(new GpuChannelMessage(message)));
+  }
 }
 
 bool GpuChannelMessageQueue::GenerateSyncPointMessage(
     gpu::SyncPointManager* sync_point_manager,
     const IPC::Message& message,
     bool retire_sync_point,
     uint32_t* sync_point) {
   DCHECK_EQ((uint32_t)GpuCommandBufferMsg_InsertSyncPoint::ID, message.type());
   DCHECK(sync_point);
   base::AutoLock auto_lock(channel_messages_lock_);
   if (enabled_) {
     *sync_point = sync_point_manager->GenerateSyncPoint();
 
     scoped_ptr<GpuChannelMessage> msg(new GpuChannelMessage(message));
     msg->retire_sync_point = retire_sync_point;
     msg->sync_point = *sync_point;
 
-    PushMessageHelper(msg.Pass());
+    PushMessageHelper(sync_point_manager, msg.Pass());
     return true;
   }
   return false;
 }
 
 bool GpuChannelMessageQueue::HasQueuedMessages() const {
   base::AutoLock auto_lock(channel_messages_lock_);
   return !channel_messages_.empty();
 }
 
 base::TimeTicks GpuChannelMessageQueue::GetNextMessageTimeTick() const {
   base::AutoLock auto_lock(channel_messages_lock_);
   if (!channel_messages_.empty())
     return channel_messages_.front()->time_received;
   return base::TimeTicks();
 }
 
 GpuChannelMessage* GpuChannelMessageQueue::GetNextMessage() const {
   base::AutoLock auto_lock(channel_messages_lock_);
   if (!channel_messages_.empty()) {
-    DCHECK_GT(channel_messages_.front()->order_number, processed_order_num_);
-    DCHECK_LE(channel_messages_.front()->order_number, unprocessed_order_num_);
+    DCHECK_GT(channel_messages_.front()->order_number,
+              sync_point_client_state_->processed_order_num());
+    DCHECK_LE(channel_messages_.front()->order_number,
+              sync_point_client_state_->unprocessed_order_num());
+
     return channel_messages_.front();
   }
   return nullptr;
 }
 
+void GpuChannelMessageQueue::BeginMessageProcessing(
+    const GpuChannelMessage* msg) {
+  sync_point_client_state_->BeginProcessingOrderNumber(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();
-  processed_order_num_ = msg->order_number;
+  sync_point_client_state_->FinishProcessingOrderNumber(msg->order_number);
   return !channel_messages_.empty();
 }
 
 void GpuChannelMessageQueue::DeleteAndDisableMessages(
     GpuChannelManager* gpu_channel_manager) {
   {
     base::AutoLock auto_lock(channel_messages_lock_);
     DCHECK(enabled_);
     enabled_ = false;
   }
@@ skipping 14 matching lines @@
     }
   }
 }
 
 void GpuChannelMessageQueue::ScheduleHandleMessage() {
   task_runner_->PostTask(FROM_HERE,
                          base::Bind(&GpuChannel::HandleMessage, gpu_channel_));
 }
 
 void GpuChannelMessageQueue::PushMessageHelper(
+    gpu::SyncPointManager* sync_point_manager,
     scoped_ptr<GpuChannelMessage> msg) {
   channel_messages_lock_.AssertAcquired();
   DCHECK(enabled_);
 
-  msg->order_number = global_order_counter_++;
+  msg->order_number =
+      sync_point_client_state_->GenerateUnprocessedOrderNumber(
+          sync_point_manager);
   msg->time_received = base::TimeTicks::Now();
 
-  unprocessed_order_num_ = msg->order_number;
-
   bool had_messages = !channel_messages_.empty();
   channel_messages_.push_back(msg.release());
   if (!had_messages)
     ScheduleHandleMessage();
 }
 
 GpuChannelMessageFilter::GpuChannelMessageFilter(
     const base::WeakPtr<GpuChannel>& gpu_channel,
     GpuChannelMessageQueue* message_queue,
     gpu::SyncPointManager* sync_point_manager,
@@ skipping 124 matching lines @@
   }
 
   // Forward all other messages to the GPU Channel.
   if (!handled) {
     if (message.type() == GpuCommandBufferMsg_WaitForTokenInRange::ID ||
         message.type() == GpuCommandBufferMsg_WaitForGetOffsetInRange::ID) {
       task_runner_->PostTask(FROM_HERE,
                              base::Bind(&GpuChannel::HandleOutOfOrderMessage,
                                         gpu_channel_, message));
     } else {
-      message_queue_->PushBackMessage(message);
+      message_queue_->PushBackMessage(sync_point_manager_, message);
     }
     handled = true;
   }
 
   UpdatePreemptionState();
   return handled;
 }
 
 void GpuChannelMessageFilter::OnMessageProcessed() {
   UpdatePreemptionState();
@@ skipping 251 matching lines @@
   channel_->AddFilter(filter_.get());
 
   return channel_handle;
 }
 
 base::ProcessId GpuChannel::GetClientPID() const {
   return channel_->GetPeerPID();
 }
 
 uint32_t GpuChannel::GetProcessedOrderNum() const {
-  return message_queue_->processed_order_num();
+  return message_queue_->GetProcessedOrderNum();
 }
 
 uint32_t GpuChannel::GetUnprocessedOrderNum() const {
   return message_queue_->GetUnprocessedOrderNum();
 }
 
 bool GpuChannel::OnMessageReceived(const IPC::Message& message) {
   // All messages should be pushed to channel_messages_ and handled separately.
   NOTREACHED();
   return false;
@@ skipping 174 matching lines @@
     IPC_MESSAGE_HANDLER(GpuChannelMsg_DestroyCommandBuffer,
                         OnDestroyCommandBuffer)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuMsg_CreateJpegDecoder,
                                     OnCreateJpegDecoder)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   DCHECK(handled) << msg.type();
   return handled;
 }
 
+scoped_refptr<gpu::SyncPointClientState> GpuChannel::GetSyncPointClientState() {
+  return message_queue_->GetSyncPointClientState();
+}
+
 void GpuChannel::HandleMessage() {
   // If we have been preempted by another channel, just post a task to wake up.
   if (preempted_flag_ && preempted_flag_->IsSet()) {
     ScheduleHandleMessage();
     return;
   }
 
   GpuChannelMessage* m = message_queue_->GetNextMessage();
 
   // TODO(sunnyps): This could be a DCHECK maybe?
   if (!m)
     return;
 
-  current_order_num_ = m->order_number;
   const IPC::Message& message = m->message;
+  message_queue_->BeginMessageProcessing(m);
   int32_t routing_id = message.routing_id();
   GpuCommandBufferStub* stub = stubs_.get(routing_id);
 
   DCHECK(!stub || stub->IsScheduled());
 
   DVLOG(1) << "received message @" << &message << " on channel @" << this
            << " with type " << message.type();
 
   bool handled = false;
 
@@ skipping 228 matching lines @@
     }
   }
 }
 
 void GpuChannel::HandleUpdateValueState(
     unsigned int target, const gpu::ValueState& state) {
   pending_valuebuffer_state_->UpdateState(target, state);
 }
 
 }  // namespace content