content/gpu: Remove separate queue for out-of-order messages.

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 50 matching lines @@
 const int64 kPreemptWaitTimeMs = 2 * kVsyncIntervalMs;
 
 // 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;
 
-const uint32_t kOutOfOrderNumber = static_cast<uint32_t>(-1);
+}  // anonymous namespace
 
-}  // 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);
 }
 
 GpuChannelMessageQueue::GpuChannelMessageQueue(
     const base::WeakPtr<GpuChannel>& gpu_channel,
     base::SingleThreadTaskRunner* task_runner)
     : enabled_(true),
       unprocessed_order_num_(0),
       processed_order_num_(0),
       gpu_channel_(gpu_channel),
       task_runner_(task_runner) {}
 
 GpuChannelMessageQueue::~GpuChannelMessageQueue() {
   DCHECK(channel_messages_.empty());
-  DCHECK(out_of_order_messages_.empty());
 }
 
 uint32_t GpuChannelMessageQueue::GetUnprocessedOrderNum() const {
   base::AutoLock auto_lock(channel_messages_lock_);
   return unprocessed_order_num_;
 }
 
-void GpuChannelMessageQueue::PushBackMessage(uint32_t order_number,
-                                             const IPC::Message& message) {
+void GpuChannelMessageQueue::PushBackMessage(const IPC::Message& message) {
   base::AutoLock auto_lock(channel_messages_lock_);
-  if (enabled_) {
-    PushMessageHelper(
-        make_scoped_ptr(new GpuChannelMessage(order_number, message)));
-  }
+  if (enabled_)
+    PushMessageHelper(make_scoped_ptr(new GpuChannelMessage(message)));
 }
 
 bool GpuChannelMessageQueue::GenerateSyncPointMessage(
     gpu::SyncPointManager* sync_point_manager,
-    uint32_t order_number,
     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(order_number, message));
+    scoped_ptr<GpuChannelMessage> msg(new GpuChannelMessage(message));
     msg->retire_sync_point = retire_sync_point;
     msg->sync_point = *sync_point;
 
     PushMessageHelper(msg.Pass());
     return true;
   }
   return false;
 }
 
 bool GpuChannelMessageQueue::HasQueuedMessages() const {
   base::AutoLock auto_lock(channel_messages_lock_);
-  return HasQueuedMessagesHelper();
+  return !channel_messages_.empty();
 }
 
 base::TimeTicks GpuChannelMessageQueue::GetNextMessageTimeTick() const {
   base::AutoLock auto_lock(channel_messages_lock_);
-
-  base::TimeTicks next_message_tick;
   if (!channel_messages_.empty())
-    next_message_tick = channel_messages_.front()->time_received;
-
-  base::TimeTicks next_out_of_order_tick;
-  if (!out_of_order_messages_.empty())
-    next_out_of_order_tick = out_of_order_messages_.front()->time_received;
-
-  if (next_message_tick.is_null())
-    return next_out_of_order_tick;
-  else if (next_out_of_order_tick.is_null())
-    return next_message_tick;
-  else
-    return std::min(next_message_tick, next_out_of_order_tick);
+    return channel_messages_.front()->time_received;
+  return base::TimeTicks();
 }
 
 GpuChannelMessage* GpuChannelMessageQueue::GetNextMessage() const {
   base::AutoLock auto_lock(channel_messages_lock_);
-  if (!out_of_order_messages_.empty()) {
-    DCHECK_EQ(out_of_order_messages_.front()->order_number, kOutOfOrderNumber);
-    return out_of_order_messages_.front();
-  } else if (!channel_messages_.empty()) {
+  if (!channel_messages_.empty()) {
     DCHECK_GT(channel_messages_.front()->order_number, processed_order_num_);
     DCHECK_LE(channel_messages_.front()->order_number, unprocessed_order_num_);
     return channel_messages_.front();
-  } else {
-    return nullptr;
   }
+  return nullptr;
 }
 
-bool GpuChannelMessageQueue::MessageProcessed(uint32_t order_number) {
+bool GpuChannelMessageQueue::MessageProcessed() {
   base::AutoLock auto_lock(channel_messages_lock_);
-  if (order_number != kOutOfOrderNumber) {
-    DCHECK(!channel_messages_.empty());
-    scoped_ptr<GpuChannelMessage> msg(channel_messages_.front());
-    channel_messages_.pop_front();
-    DCHECK_EQ(order_number, msg->order_number);
-    processed_order_num_ = order_number;
-  } else {
-    DCHECK(!out_of_order_messages_.empty());
-    scoped_ptr<GpuChannelMessage> msg(out_of_order_messages_.front());
-    out_of_order_messages_.pop_front();
-  }
-  return HasQueuedMessagesHelper();
+  DCHECK(!channel_messages_.empty());
+  scoped_ptr<GpuChannelMessage> msg(channel_messages_.front());
+  channel_messages_.pop_front();
+  processed_order_num_ = 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;
   }
 
   // We guarantee that the queues will no longer be modified after enabled_
   // is set to false, it is now safe to modify the queue without the lock.
   // All public facing modifying functions check enabled_ while all
   // private modifying functions DCHECK(enabled_) to enforce this.
   while (!channel_messages_.empty()) {
     scoped_ptr<GpuChannelMessage> msg(channel_messages_.front());
     channel_messages_.pop_front();
     // This needs to clean up both GpuCommandBufferMsg_InsertSyncPoint and
     // GpuCommandBufferMsg_RetireSyncPoint messages, safer to just check
     // if we have a sync point number here.
     if (msg->sync_point) {
       gpu_channel_manager->sync_point_manager()->RetireSyncPoint(
           msg->sync_point);
     }
   }
-  STLDeleteElements(&out_of_order_messages_);
 }
 
 void GpuChannelMessageQueue::ScheduleHandleMessage() {
   task_runner_->PostTask(FROM_HERE,
                          base::Bind(&GpuChannel::HandleMessage, gpu_channel_));
 }
 
 void GpuChannelMessageQueue::PushMessageHelper(
     scoped_ptr<GpuChannelMessage> msg) {
   channel_messages_lock_.AssertAcquired();
   DCHECK(enabled_);
-  bool had_messages = HasQueuedMessagesHelper();
-  if (msg->order_number != kOutOfOrderNumber) {
-    unprocessed_order_num_ = msg->order_number;
-    channel_messages_.push_back(msg.release());
-  } else {
-    out_of_order_messages_.push_back(msg.release());
-  }
+
+  msg->order_number = global_order_counter_++;
+  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();
 }
 
-bool GpuChannelMessageQueue::HasQueuedMessagesHelper() const {
-  channel_messages_lock_.AssertAcquired();
-  return !channel_messages_.empty() || !out_of_order_messages_.empty();
-}
-
-// Begin order numbers at 1 so 0 can mean no orders.
-uint32_t GpuChannelMessageFilter::global_order_counter_ = 1;
-
 GpuChannelMessageFilter::GpuChannelMessageFilter(
+    const base::WeakPtr<GpuChannel>& gpu_channel,
     GpuChannelMessageQueue* message_queue,
     gpu::SyncPointManager* sync_point_manager,
     base::SingleThreadTaskRunner* task_runner,
     bool future_sync_points)
     : preemption_state_(IDLE),
+      gpu_channel_(gpu_channel),
       message_queue_(message_queue),
       sender_(nullptr),
       peer_pid_(base::kNullProcessId),
       sync_point_manager_(sync_point_manager),
       task_runner_(task_runner),
       a_stub_is_descheduled_(false),
       future_sync_points_(future_sync_points) {}
 
 GpuChannelMessageFilter::~GpuChannelMessageFilter() {}
 
@@ skipping 48 matching lines @@
 void GpuChannelMessageFilter::RemoveChannelFilter(
     scoped_refptr<IPC::MessageFilter> filter) {
   if (sender_)
     filter->OnFilterRemoved();
   channel_filters_.erase(
       std::find(channel_filters_.begin(), channel_filters_.end(), filter));
 }
 
 bool GpuChannelMessageFilter::OnMessageReceived(const IPC::Message& message) {
   DCHECK(sender_);
+  DCHECK(!message.should_unblock() && !message.is_reply());

[piman, 2015/09/18 03:44:15]

nit: it's not really a valid DCHECK, a compromised renderer can send one of this
type of message. We shouldn't make the assumption that they can't happen.

[sunnyps, 2015/09/18 18:47:28]

Done.

   for (scoped_refptr<IPC::MessageFilter>& filter : channel_filters_) {
     if (filter->OnMessageReceived(message)) {
       return true;
     }
   }
 
-  const uint32_t order_number = global_order_counter_++;
   bool handled = false;
   if ((message.type() == GpuCommandBufferMsg_RetireSyncPoint::ID) &&
       !future_sync_points_) {
     DLOG(ERROR) << "Untrusted client should not send "
                    "GpuCommandBufferMsg_RetireSyncPoint message";
     return true;
   }
 
   if (message.type() == GpuCommandBufferMsg_InsertSyncPoint::ID) {
     base::Tuple<bool> params;
     IPC::Message* reply = IPC::SyncMessage::GenerateReply(&message);
     if (!GpuCommandBufferMsg_InsertSyncPoint::ReadSendParam(&message,
                                                             &params)) {
       reply->set_reply_error();
       Send(reply);
       return true;
     }
     bool retire_sync_point = base::get<0>(params);
     if (!future_sync_points_ && !retire_sync_point) {
       LOG(ERROR) << "Untrusted contexts can't create future sync points";
       reply->set_reply_error();
       Send(reply);
       return true;
     }
 
     // Message queue must handle the entire sync point generation because the
     // message queue could be disabled from the main thread during generation.
     uint32_t sync_point = 0u;
     if (!message_queue_->GenerateSyncPointMessage(
-            sync_point_manager_, order_number, message, retire_sync_point,
-            &sync_point)) {
+            sync_point_manager_, message, retire_sync_point, &sync_point)) {
       LOG(ERROR) << "GpuChannel has been destroyed.";
       reply->set_reply_error();
       Send(reply);
       return true;
     }
 
     DCHECK_NE(sync_point, 0u);
     GpuCommandBufferMsg_InsertSyncPoint::WriteReplyParams(reply, sync_point);
     Send(reply);
     handled = true;
   }
 
   // Forward all other messages to the GPU Channel.
-  if (!handled && !message.is_reply() && !message.should_unblock()) {
+  if (!handled) {
     if (message.type() == GpuCommandBufferMsg_WaitForTokenInRange::ID ||
         message.type() == GpuCommandBufferMsg_WaitForGetOffsetInRange::ID) {
-      // Move Wait commands to the head of the queue, so the renderer
-      // doesn't have to wait any longer than necessary.
-      message_queue_->PushBackMessage(kOutOfOrderNumber, message);
+      task_runner_->PostTask(FROM_HERE,
+                             base::Bind(&GpuChannel::HandleOutOfOrderMessage,
+                                        gpu_channel_, message));
     } else {
-      message_queue_->PushBackMessage(order_number, message);
+      message_queue_->PushBackMessage(message);
     }
     handled = true;
   }
 
   UpdatePreemptionState();
   return handled;
 }
 
 void GpuChannelMessageFilter::OnMessageProcessed() {
   UpdatePreemptionState();
@@ skipping 205 matching lines @@
       allow_future_sync_points_(allow_future_sync_points),
       allow_real_time_streams_(allow_real_time_streams),
       weak_factory_(this) {
   DCHECK(gpu_channel_manager);
   DCHECK(client_id);
 
   message_queue_ =
       GpuChannelMessageQueue::Create(weak_factory_.GetWeakPtr(), task_runner);
 
   filter_ = new GpuChannelMessageFilter(
-      message_queue_.get(), gpu_channel_manager_->sync_point_manager(),
-      task_runner_.get(), allow_future_sync_points_);
+      weak_factory_.GetWeakPtr(), message_queue_.get(),
+      gpu_channel_manager_->sync_point_manager(), task_runner_.get(),
+      allow_future_sync_points_);
 
   subscription_ref_set_->AddObserver(this);
 }
 
 GpuChannel::~GpuChannel() {
   // Clear stubs first because of dependencies.
   stubs_.clear();
 
   message_queue_->DeleteAndDisableMessages(gpu_channel_manager_);
 
@@ skipping 232 matching lines @@
     ScheduleHandleMessage();
     return;
   }
 
   GpuChannelMessage* m = message_queue_->GetNextMessage();
 
   // TODO(sunnyps): This could be a DCHECK maybe?
   if (!m)
     return;
 
-  uint32_t order_number = m->order_number;
+  current_order_num_ = m->order_number;
   const IPC::Message& message = m->message;
   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();
 
-  current_order_num_ = order_number;
-
   bool handled = false;
 
   if (routing_id == MSG_ROUTING_CONTROL) {
     handled = OnControlMessageReceived(message);
   } else if (message.type() == GpuCommandBufferMsg_InsertSyncPoint::ID) {
     // TODO(dyen): Temporary handling of old sync points.
     // This must ensure that the sync point will be retired. Normally we'll
     // find the stub based on the routing ID, and associate the sync point
     // with it, but if that fails for any reason (channel or stub already
     // deleted, invalid routing id), we need to retire the sync point
@@ skipping 12 matching lines @@
   // Respond to sync messages even if router failed to route.
   if (!handled && message.is_sync()) {
     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() &&
-      order_number != kOutOfOrderNumber) {
+  if (stub && stub->HasUnprocessedCommands()) {
     DCHECK_EQ((uint32_t)GpuCommandBufferMsg_AsyncFlush::ID, message.type());
     // 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(order_number)) {
+  if (message_queue_->MessageProcessed())
     ScheduleHandleMessage();
-  }
 
   if (preempting_flag_) {
     io_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&GpuChannelMessageFilter::OnMessageProcessed, filter_));
   }
 }
 
 void GpuChannel::ScheduleHandleMessage() {
   task_runner_->PostTask(FROM_HERE, base::Bind(&GpuChannel::HandleMessage,
                                                weak_factory_.GetWeakPtr()));
 }
 
+void GpuChannel::HandleOutOfOrderMessage(const IPC::Message& msg) {
+  DCHECK((msg.type() ==
+          (uint32_t)GpuCommandBufferMsg_WaitForGetOffsetInRange::ID) ||

[piman, 2015/09/18 03:44:15]

nit: no c-style cast

[sunnyps, 2015/09/18 18:47:28]

Replaced this with a switch statement which doesn't need a cast.

+         (msg.type() == (uint32_t)GpuCommandBufferMsg_WaitForTokenInRange::ID));
+  router_.RouteMessage(msg);
+}
+
 void GpuChannel::OnCreateOffscreenCommandBuffer(
     const gfx::Size& size,
     const GPUCreateCommandBufferConfig& init_params,
     int32 route_id,
     bool* succeeded) {
   TRACE_EVENT1("gpu", "GpuChannel::OnCreateOffscreenCommandBuffer", "route_id",
                route_id);
 
   int32 share_group_id = init_params.share_group_id;
   GpuCommandBufferStub* share_group = stubs_.get(share_group_id);
@@ skipping 151 matching lines @@
     }
   }
 }
 
 void GpuChannel::HandleUpdateValueState(
     unsigned int target, const gpu::ValueState& state) {
   pending_valuebuffer_state_->UpdateState(target, state);
 }
 
 }  // namespace content