GPU Channel's now maintain a global order number for each processed IPC.

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"
 
 #include <algorithm>
-#include <queue>
+#include <deque>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
+#include "base/synchronization/lock.h"
 #include "base/thread_task_runner_handle.h"
-#include "base/timer/timer.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "base/trace_event/process_memory_dump.h"
 #include "base/trace_event/trace_event.h"
 #include "content/common/gpu/gpu_channel_manager.h"
 #include "content/common/gpu/gpu_memory_buffer_factory.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/common/gpu/media/gpu_jpeg_decode_accelerator.h"
 #include "content/public/common/content_switches.h"
 #include "gpu/command_buffer/common/mailbox.h"
 #include "gpu/command_buffer/common/value_state.h"
@@ skipping 27 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
 
+struct ChannelMessage {
+  uint32_t order_number;
+  base::TimeTicks time_received;
+  IPC::Message message;
+
+  // TODO(dyen): Temporary sync point data, remove once new sync point lands.
+  bool retire_sync_point;
+  uint32 sync_point_number;
+
+  ChannelMessage(uint32_t order_num, const IPC::Message& msg)
+    : order_number(order_num),
+      time_received(base::TimeTicks::Now()),
+      message(msg),
+      retire_sync_point(false),
+      sync_point_number(0) {}
+};
+
+class GpuChannelMessageQueue : public base::RefCounted<GpuChannelMessageQueue> {

[piman, 2015/09/01 03:55:26]

Needs to be RefCountedThreadSafe

[David Yen, 2015/09/01 19:08:02]

Done.

+ public:
+  static scoped_refptr<GpuChannelMessageQueue> Create(
+      GpuChannelManager* gpu_channel_manager,
+      base::WeakPtr<GpuChannel> gpu_channel,
+      scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
+    return new GpuChannelMessageQueue(gpu_channel_manager, gpu_channel,
+                                     task_runner);
+  }
+
+  void PushBackMessage(uint32_t order_number,
+                                   const IPC::Message& message) {

[piman, 2015/09/01 03:55:26]

nit: indent, here and below (run git cl format)

[David Yen, 2015/09/01 19:08:02]

Done.

+    base::subtle::Release_Store(&unprocessed_order_num_, order_number);
+
+    base::AutoLock auto_lock(channel_messages_lock_);
+    const bool was_empty = channel_messages_.empty();
+    channel_messages_.push_back(new ChannelMessage(order_number, message));
+    if (was_empty)
+      ScheduleHandleMessageLocked();
+  }
+
+  void PushFrontMessage(const IPC::Message& message) {
+    // These are pushed out of order so should not have any order messages.
+    base::AutoLock auto_lock(channel_messages_lock_);
+    const bool was_empty = channel_messages_.empty();
+    channel_messages_.push_front(new ChannelMessage(static_cast<uint32_t>(-1),

[piman, 2015/09/01 03:55:26]

nit: maybe define a const uint32_t kOutOfOrderNumer = -1u; and use here and
below.

[David Yen, 2015/09/01 19:08:02]

Done.

+                                                    message));
+    if (was_empty)
+      ScheduleHandleMessageLocked();
+  }
+
+  void PushSyncPointMessage(uint32_t order_number,
+                                        const IPC::Message& message,
+                                        bool retire_sync_point,
+                                        uint32_t sync_point_num) {
+    DCHECK(message.type() == GpuCommandBufferMsg_InsertSyncPoint::ID);
+
+    base::subtle::Release_Store(&unprocessed_order_num_, order_number);
+    ChannelMessage* msg = new ChannelMessage(order_number, message);
+    msg->retire_sync_point = retire_sync_point;
+    msg->sync_point_number = sync_point_num;
+
+    base::AutoLock auto_lock(channel_messages_lock_);
+    const bool was_empty = channel_messages_.empty();
+    channel_messages_.push_back(msg);
+    if (was_empty)
+      ScheduleHandleMessageLocked();
+  }

[piman, 2015/09/01 03:55:26]

nit: all 3 functions (and PushUnfinishedMessage) could maybe use a helper:

void PushMessageAndSchedule(ChannelMessage* message) {
  base::AutoLock auto_lock(channel_messages_lock_);
  const bool was_empty = channel_messages_.empty();
  channel_messages_.push_back(message);
  if (was_empty)
    ScheduleHandleMessageLocked();
}

[David Yen, 2015/09/01 19:08:02]

Done.

+
+  bool HasQueuedMessages() {
+    base::AutoLock auto_lock(channel_messages_lock_);
+    return !channel_messages_.empty();
+  }
+
+  base::TimeTicks GetNextMessageTimeTick() {
+    // We have to account for messages that are pushed out of order, the out
+    // of order messages are pushed back to front and have order numbers of -1.
+    base::TimeTicks next_time_tick;
+    base::AutoLock auto_lock(channel_messages_lock_);
+    for (const auto& msg : channel_messages_) {
+      if (msg->order_number != static_cast<uint32_t>(-1)) {
+        // Return the earliest time tick if we have some out of order ones.
+        return next_time_tick.is_null() ?
+               msg->time_received :
+               std::min(msg->time_received, next_time_tick);
+      } else {
+        // Store the last out of order message in next_time_tick.
+        next_time_tick = msg->time_received;
+      }
+    }
+    return next_time_tick;
+  }
+
+ protected:
+  virtual ~GpuChannelMessageQueue() {

[piman, 2015/09/01 03:55:26]

This logic needs to happen on the main thread.

Since this is refcounted by both the filter and the GpuChannel, you have no
guarantee where the destructor is run.


Instead, cleaning up the sync point messages should probably happen by an
explicit call from GpuChannel in its destructor. This could also set a flag so
that the filter stops creating sync point numbers, and allocating
ChannelMessages.

[David Yen, 2015/09/01 19:08:02]

Ah, I just noticed that too. I've moved it to the main thread and added an
"enabled_" boolean. I also had to move the sync point generating code to be
behind the lock to or else there would be a race condition, it is all handled
within the GpuChannelMessageQueue::GenerateSyncPointMessage() now.

+    base::AutoLock auto_lock(channel_messages_lock_);
+    for (const auto& msg : channel_messages_) {

[piman, 2015/09/01 03:55:26]

I'd suggest making this ChannelMessage* msg for clarity. auto& makes it sound
like it's a ChannelMessage reference.

Also, you can simply delete msg in this loop, rather than running a second loop
in STLDeleteElements.

[David Yen, 2015/09/01 19:08:02]

Done.

+      const uint32_t sync_point = msg->sync_point_number;
+      gpu_channel_manager_->sync_point_manager()->RetireSyncPoint(sync_point);

[piman, 2015/09/01 03:55:26]

if (sync_point)
  gpu_channel_manager_->sync_point_manager()->RetireSyncPoint(sync_point);

(RetireSyncPoint is non-trivial, you don't want to run it on 0 for every
non-InsertSyncPoint message).

[David Yen, 2015/09/01 19:08:02]

Done.

+    }
+    STLDeleteElements(&channel_messages_);
+  }
+
+ private:
+  friend class GpuChannel;
+  friend class base::RefCounted<GpuChannelMessageQueue>;
+
+  GpuChannelMessageQueue(
+      GpuChannelManager* gpu_channel_manager,
+      base::WeakPtr<GpuChannel> gpu_channel,
+      scoped_refptr<base::SingleThreadTaskRunner> task_runner)
+      : unprocessed_order_num_(0),
+        handle_messages_scheduled_(false),
+        gpu_channel_manager_(gpu_channel_manager),
+        gpu_channel_(gpu_channel),
+        task_runner_(task_runner) {
+  }
+
+  void PushUnfinishedMessage(uint32_t order_number,
+                             const IPC::Message& message) {
+    // This is pushed only if it was unfinished, so order number is kept.
+    base::AutoLock auto_lock(channel_messages_lock_);
+    const bool was_empty = channel_messages_.empty();
+    channel_messages_.push_front(new ChannelMessage(order_number, message));
+    if (was_empty)
+      ScheduleHandleMessageLocked();
+  }
+
+  void ScheduleHandleMessage() {
+    base::AutoLock auto_lock(channel_messages_lock_);
+    ScheduleHandleMessageLocked();
+  }
+
+  void ScheduleHandleMessageLocked() {
+    channel_messages_lock_.AssertAcquired();
+    if (!handle_messages_scheduled_) {
+      task_runner_->PostTask(
+          FROM_HERE,
+          base::Bind(&GpuChannel::HandleMessage, gpu_channel_));
+      handle_messages_scheduled_ = true;
+    }
+  }
+
+  // Highest IPC order number seen, set when queued on the IO thread.
+  base::subtle::Atomic32 unprocessed_order_num_;

[piman, 2015/09/01 03:55:26]

If we really need this, I'd prefer it to be a uint32_t, and accessed under the
lock. Other access patterns are incorrect unless proven correct - it encodes the
highest global order in the queue, but that's racy if you don't have the lock
held.

[David Yen, 2015/09/01 19:08:02]

Done.

+
+  std::deque<ChannelMessage*> channel_messages_;
+  bool handle_messages_scheduled_;
+
+  // This lock protects both handle_messages_scheduled_ and channel_messages_.
+  base::Lock channel_messages_lock_;
+
+  GpuChannelManager* gpu_channel_manager_;
+  base::WeakPtr<GpuChannel> gpu_channel_;
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
+
+  DISALLOW_COPY_AND_ASSIGN(GpuChannelMessageQueue);
+};
+
 // This filter does three things:
 // - it counts and timestamps each message forwarded to the channel
 //   so that we can preempt other channels if a message takes too long to
 //   process. To guarantee fairness, we must wait a minimum amount of time
 //   before preempting and we limit the amount of time that we can preempt in
 //   one shot (see constants above).
 // - it handles the GpuCommandBufferMsg_InsertSyncPoint message on the IO
 //   thread, generating the sync point ID and responding immediately, and then
 //   posting a task to insert the GpuCommandBufferMsg_RetireSyncPoint message
 //   into the channel's queue.
 // - it generates mailbox names for clients of the GPU process on the IO thread.
 class GpuChannelMessageFilter : public IPC::MessageFilter {
  public:
   GpuChannelMessageFilter(
+      scoped_refptr<GpuChannelMessageQueue> message_queue,
       base::WeakPtr<GpuChannel> gpu_channel,
       gpu::SyncPointManager* sync_point_manager,
       scoped_refptr<base::SingleThreadTaskRunner> task_runner,
       bool future_sync_points)
       : preemption_state_(IDLE),
+        message_queue_(message_queue),
         gpu_channel_(gpu_channel),
         sender_(nullptr),
         sync_point_manager_(sync_point_manager),
         task_runner_(task_runner),
-        messages_forwarded_to_channel_(0),
         a_stub_is_descheduled_(false),
         future_sync_points_(future_sync_points) {}
 
   void OnFilterAdded(IPC::Sender* sender) override {
     DCHECK(!sender_);
     sender_ = sender;
     timer_ = make_scoped_ptr(new base::OneShotTimer<GpuChannelMessageFilter>);
   }
 
   void OnFilterRemoved() override {
     DCHECK(sender_);
     sender_ = nullptr;
     timer_ = nullptr;
   }
 
   bool OnMessageReceived(const IPC::Message& message) override {
     DCHECK(sender_);
 
+    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> retire;
       IPC::Message* reply = IPC::SyncMessage::GenerateReply(&message);
       if (!GpuCommandBufferMsg_InsertSyncPoint::ReadSendParam(&message,
                                                               &retire)) {
         reply->set_reply_error();
         Send(reply);
         return true;
       }
       if (!future_sync_points_ && !base::get<0>(retire)) {
         LOG(ERROR) << "Untrusted contexts can't create future sync points";
         reply->set_reply_error();
         Send(reply);
         return true;
       }
       uint32 sync_point = sync_point_manager_->GenerateSyncPoint();
       GpuCommandBufferMsg_InsertSyncPoint::WriteReplyParams(reply, sync_point);
       Send(reply);
-      task_runner_->PostTask(
-          FROM_HERE,
-          base::Bind(&GpuChannelMessageFilter::InsertSyncPointOnMainThread,
-                     gpu_channel_, sync_point_manager_, message.routing_id(),
-                     base::get<0>(retire), sync_point));
+
+      message_queue_->PushSyncPointMessage(order_number, message,
+                                           base::get<0>(retire), sync_point);
       handled = true;
     }
 
     // These are handled by GpuJpegDecodeAccelerator and
     // GpuVideoDecodeAccelerator.
     // TODO(kcwu) Modify GpuChannel::AddFilter to handle additional filters by
     // GpuChannelMessageFilter instead of by IPC::SyncChannel directly. Then we
     // don't need to exclude them one by one here.
     if (message.type() == AcceleratedJpegDecoderMsg_Decode::ID ||
         message.type() == AcceleratedJpegDecoderMsg_Destroy::ID ||
         message.type() == AcceleratedVideoDecoderMsg_Decode::ID) {
       return false;
     }
 
-    // All other messages get processed by the GpuChannel.
-    messages_forwarded_to_channel_++;
-    if (preempting_flag_.get())
-      pending_messages_.push(PendingMessage(messages_forwarded_to_channel_));
+    // Forward all other messages to the GPU Channel.
+    if (!handled && !message.is_reply() && !message.should_unblock()) {
+      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_->PushFrontMessage(message);
+      } else {
+        message_queue_->PushBackMessage(order_number, message);
+      }
+      handled = true;
+    }
+
     UpdatePreemptionState();
-
     return handled;
   }
 
-  void MessageProcessed(uint64 messages_processed) {
-    while (!pending_messages_.empty() &&
-           pending_messages_.front().message_number <= messages_processed)
-      pending_messages_.pop();
+  void OnMessageProcessed() {
     UpdatePreemptionState();
   }
 
   void SetPreemptingFlagAndSchedulingState(
       gpu::PreemptionFlag* preempting_flag,
       bool a_stub_is_descheduled) {
     preempting_flag_ = preempting_flag;
     a_stub_is_descheduled_ = a_stub_is_descheduled;
   }
 
@@ skipping 25 matching lines @@
     // We would like to preempt, but some stub is descheduled.
     WOULD_PREEMPT_DESCHEDULED,
   };
 
   PreemptionState preemption_state_;
 
   // Maximum amount of time that we can spend in PREEMPTING.
   // It is reset when we transition to IDLE.
   base::TimeDelta max_preemption_time_;
 
-  struct PendingMessage {
-    uint64 message_number;
-    base::TimeTicks time_received;
-
-    explicit PendingMessage(uint64 message_number)
-        : message_number(message_number),
-          time_received(base::TimeTicks::Now()) {
-    }
-  };
-
   void UpdatePreemptionState() {
     switch (preemption_state_) {
       case IDLE:
-        if (preempting_flag_.get() && !pending_messages_.empty())
+        if (preempting_flag_.get() && message_queue_->HasQueuedMessages())
           TransitionToWaiting();
         break;
       case WAITING:
         // A timer will transition us to CHECKING.
         DCHECK(timer_->IsRunning());
         break;
       case CHECKING:
-        if (!pending_messages_.empty()) {
-          base::TimeDelta time_elapsed =
-              base::TimeTicks::Now() - pending_messages_.front().time_received;
-          if (time_elapsed.InMilliseconds() < kPreemptWaitTimeMs) {
-            // Schedule another check for when the IPC may go long.
-            timer_->Start(
-                FROM_HERE,
-                base::TimeDelta::FromMilliseconds(kPreemptWaitTimeMs) -
-                    time_elapsed,
-                this, &GpuChannelMessageFilter::UpdatePreemptionState);
-          } else {
-            if (a_stub_is_descheduled_)
-              TransitionToWouldPreemptDescheduled();
-            else
-              TransitionToPreempting();
+        {
+          base::TimeTicks time_tick = message_queue_->GetNextMessageTimeTick();
+          if (!time_tick.is_null()) {
+            base::TimeDelta time_elapsed = base::TimeTicks::Now() - time_tick;
+            if (time_elapsed.InMilliseconds() < kPreemptWaitTimeMs) {
+              // Schedule another check for when the IPC may go long.
+              timer_->Start(
+                  FROM_HERE,
+                  base::TimeDelta::FromMilliseconds(kPreemptWaitTimeMs) -
+                      time_elapsed,
+                  this, &GpuChannelMessageFilter::UpdatePreemptionState);
+            } else {
+              if (a_stub_is_descheduled_)
+                TransitionToWouldPreemptDescheduled();
+              else
+                TransitionToPreempting();
+            }
           }
         }
         break;
       case PREEMPTING:
         // A TransitionToIdle() timer should always be running in this state.
         DCHECK(timer_->IsRunning());
         if (a_stub_is_descheduled_)
           TransitionToWouldPreemptDescheduled();
         else
           TransitionToIdleIfCaughtUp();
         break;
       case WOULD_PREEMPT_DESCHEDULED:
         // A TransitionToIdle() timer should never be running in this state.
         DCHECK(!timer_->IsRunning());
         if (!a_stub_is_descheduled_)
           TransitionToPreempting();
         else
           TransitionToIdleIfCaughtUp();
         break;
       default:
         NOTREACHED();
     }
   }
 
   void TransitionToIdleIfCaughtUp() {
     DCHECK(preemption_state_ == PREEMPTING ||
            preemption_state_ == WOULD_PREEMPT_DESCHEDULED);
-    if (pending_messages_.empty()) {
+    base::TimeTicks next_tick = message_queue_->GetNextMessageTimeTick();
+    if (next_tick.is_null()) {
       TransitionToIdle();
     } else {
-      base::TimeDelta time_elapsed =
-          base::TimeTicks::Now() - pending_messages_.front().time_received;
+      base::TimeDelta time_elapsed = base::TimeTicks::Now() - next_tick;
       if (time_elapsed.InMilliseconds() < kStopPreemptThresholdMs)
         TransitionToIdle();
     }
   }
 
   void TransitionToIdle() {
     DCHECK(preemption_state_ == PREEMPTING ||
            preemption_state_ == WOULD_PREEMPT_DESCHEDULED);
     // Stop any outstanding timer set to force us from PREEMPTING to IDLE.
     timer_->Stop();
@@ skipping 65 matching lines @@
       }
     }
 
     preemption_state_ = WOULD_PREEMPT_DESCHEDULED;
     preempting_flag_->Reset();
     TRACE_COUNTER_ID1("gpu", "GpuChannel::Preempting", this, 0);
 
     UpdatePreemptionState();
   }
 
-  static void InsertSyncPointOnMainThread(
-      base::WeakPtr<GpuChannel> gpu_channel,
-      gpu::SyncPointManager* manager,
-      int32 routing_id,
-      bool retire,
-      uint32 sync_point) {
-    // This function 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
-    // immediately.
-    if (gpu_channel) {
-      GpuCommandBufferStub* stub = gpu_channel->LookupCommandBuffer(routing_id);
-      if (stub) {
-        stub->AddSyncPoint(sync_point);
-        if (retire) {
-          GpuCommandBufferMsg_RetireSyncPoint message(routing_id, sync_point);
-          gpu_channel->OnMessageReceived(message);
-        }
-        return;
-      } else {
-        gpu_channel->MessageProcessed();
-      }
-    }
-    manager->RetireSyncPoint(sync_point);
-  }
-
-  // NOTE: this weak pointer is never dereferenced on the IO thread, it's only
-  // passed through - therefore the WeakPtr assumptions are respected.
+  // NOTE: The message_queue_ is used to handle messages on the main thread.
+  // The gpu_channel_ weak pointer is only dereferenced on the
+  // main thread - therefore the WeakPtr assumptions are respected.
+  scoped_refptr<GpuChannelMessageQueue> message_queue_;
   base::WeakPtr<GpuChannel> gpu_channel_;

[piman, 2015/09/01 03:55:26]

I don't think you need this any more.

[David Yen, 2015/09/01 19:08:02]

Done.

   IPC::Sender* sender_;
   gpu::SyncPointManager* sync_point_manager_;
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   scoped_refptr<gpu::PreemptionFlag> preempting_flag_;
 
-  std::queue<PendingMessage> pending_messages_;
-
-  // Count of the number of IPCs forwarded to the GpuChannel.
-  uint64 messages_forwarded_to_channel_;
-
   // This timer is created and destroyed on the IO thread.
   scoped_ptr<base::OneShotTimer<GpuChannelMessageFilter>> timer_;
 
   bool a_stub_is_descheduled_;
 
   // True if this channel can create future sync points.
   bool future_sync_points_;
+
+  // This number is only ever incremented/read on the IO thread.
+  static uint32_t global_order_counter_;
 };
 
+uint32_t GpuChannelMessageFilter::global_order_counter_ = 0;
+
 GpuChannel::GpuChannel(GpuChannelManager* gpu_channel_manager,
                        GpuWatchdog* watchdog,
                        gfx::GLShareGroup* share_group,
                        gpu::gles2::MailboxManager* mailbox,
                        base::SingleThreadTaskRunner* task_runner,
                        base::SingleThreadTaskRunner* io_task_runner,
                        int client_id,
                        uint64_t client_tracing_id,
                        bool software,
                        bool allow_future_sync_points)
     : gpu_channel_manager_(gpu_channel_manager),
       channel_id_(IPC::Channel::GenerateVerifiedChannelID("gpu")),
-      messages_processed_(0),
       client_id_(client_id),
       client_tracing_id_(client_tracing_id),
       task_runner_(task_runner),
       io_task_runner_(io_task_runner),
       share_group_(share_group ? share_group : new gfx::GLShareGroup),
       mailbox_manager_(mailbox
                            ? scoped_refptr<gpu::gles2::MailboxManager>(mailbox)
                            : gpu::gles2::MailboxManager::Create()),
       subscription_ref_set_(new gpu::gles2::SubscriptionRefSet),
       pending_valuebuffer_state_(new gpu::ValueStateMap),
       watchdog_(watchdog),
       software_(software),
-      handle_messages_scheduled_(false),
-      currently_processing_message_(nullptr),
+      current_order_num_(0),
+      processed_order_num_(0),
       num_stubs_descheduled_(0),
       allow_future_sync_points_(allow_future_sync_points),
       weak_factory_(this) {
   DCHECK(gpu_channel_manager);
   DCHECK(client_id);
 
+  message_queue_ = GpuChannelMessageQueue::Create(gpu_channel_manager,
+                                                  weak_factory_.GetWeakPtr(),
+                                                  task_runner);
+
   filter_ = new GpuChannelMessageFilter(
-      weak_factory_.GetWeakPtr(), gpu_channel_manager_->sync_point_manager(),
+      message_queue_, weak_factory_.GetWeakPtr(),
+      gpu_channel_manager_->sync_point_manager(),
       task_runner_, allow_future_sync_points_);
 
   subscription_ref_set_->AddObserver(this);
 }
 
 GpuChannel::~GpuChannel() {
   // Clear stubs first because of dependencies.
   stubs_.clear();
 
-  STLDeleteElements(&deferred_messages_);
   subscription_ref_set_->RemoveObserver(this);
   if (preempting_flag_.get())
     preempting_flag_->Reset();
 }
 
 IPC::ChannelHandle GpuChannel::Init(base::WaitableEvent* shutdown_event,
                                     IPC::AttachmentBroker* attachment_broker) {
   DCHECK(shutdown_event);
   DCHECK(!channel_);
 
@@ skipping 14 matching lines @@
   channel_->AddFilter(filter_.get());
 
   return channel_handle;
 }
 
 base::ProcessId GpuChannel::GetClientPID() const {
   return channel_->GetPeerPID();
 }
 
 bool GpuChannel::OnMessageReceived(const IPC::Message& message) {
-  DVLOG(1) << "received message @" << &message << " on channel @" << this
-           << " with type " << message.type();
-
-  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.
-    deferred_messages_.push_front(new IPC::Message(message));
-  } else {
-    deferred_messages_.push_back(new IPC::Message(message));
-  }
-
-  OnScheduled();
-
-  return true;
+  // All messages should be pushed to channel_messages_ and handled separately.
+  NOTREACHED();
+  return false;
 }
 
 void GpuChannel::OnChannelError() {
   gpu_channel_manager_->RemoveChannel(client_id_);
 }
 
 bool GpuChannel::Send(IPC::Message* message) {
   // The GPU process must never send a synchronous IPC message to the renderer
   // process. This could result in deadlock.
   DCHECK(!message->is_sync());
@@ skipping 12 matching lines @@
 void GpuChannel::OnAddSubscription(unsigned int target) {
   gpu_channel_manager()->Send(
       new GpuHostMsg_AddSubscription(client_id_, target));
 }
 
 void GpuChannel::OnRemoveSubscription(unsigned int target) {
   gpu_channel_manager()->Send(
       new GpuHostMsg_RemoveSubscription(client_id_, target));
 }
 
-void GpuChannel::RequeueMessage() {
-  DCHECK(currently_processing_message_);
-  deferred_messages_.push_front(
-      new IPC::Message(*currently_processing_message_));
-  messages_processed_--;
-  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.
-  task_runner_->PostTask(FROM_HERE, base::Bind(&GpuChannel::HandleMessage,
-                                               weak_factory_.GetWeakPtr()));
-  handle_messages_scheduled_ = true;
-}
-
 void GpuChannel::StubSchedulingChanged(bool scheduled) {
   bool a_stub_was_descheduled = num_stubs_descheduled_ > 0;
   if (scheduled) {
     num_stubs_descheduled_--;
-    OnScheduled();
+    message_queue_->ScheduleHandleMessage();
   } else {
     num_stubs_descheduled_++;
   }
   DCHECK_LE(num_stubs_descheduled_, stubs_.size());
   bool a_stub_is_descheduled = num_stubs_descheduled_ > 0;
 
   if (a_stub_is_descheduled != a_stub_was_descheduled) {
     if (preempting_flag_.get()) {
       io_task_runner_->PostTask(
           FROM_HERE,
@@ skipping 76 matching lines @@
     preempting_flag_ = new gpu::PreemptionFlag;
     io_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(
             &GpuChannelMessageFilter::SetPreemptingFlagAndSchedulingState,
             filter_, preempting_flag_, num_stubs_descheduled_ > 0));
   }
   return preempting_flag_.get();
 }
 
+bool GpuChannel::handle_messages_scheduled() const {
+  base::AutoLock auto_lock(message_queue_->channel_messages_lock_);
+  return message_queue_->handle_messages_scheduled_;
+}
+
 void GpuChannel::SetPreemptByFlag(
     scoped_refptr<gpu::PreemptionFlag> preempted_flag) {
   preempted_flag_ = preempted_flag;
 
   for (auto& kv : stubs_)
     kv.second->SetPreemptByFlag(preempted_flag_);
 }
 
 void GpuChannel::OnDestroy() {
   TRACE_EVENT0("gpu", "GpuChannel::OnDestroy");
   gpu_channel_manager_->RemoveChannel(client_id_);
 }
 
 bool GpuChannel::OnControlMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(GpuChannel, msg)
     IPC_MESSAGE_HANDLER(GpuChannelMsg_CreateOffscreenCommandBuffer,
                         OnCreateOffscreenCommandBuffer)
     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;
 }
 
 void GpuChannel::HandleMessage() {
-  handle_messages_scheduled_ = false;
-  if (deferred_messages_.empty())
-    return;
-
-  IPC::Message* m = NULL;
-  GpuCommandBufferStub* stub = NULL;
-
-  m = deferred_messages_.front();
-  stub = stubs_.get(m->routing_id());
-  if (stub) {
-    if (!stub->IsScheduled())
-      return;
-    if (stub->IsPreempted()) {
-      OnScheduled();
+  ChannelMessage* m = nullptr;
+  GpuCommandBufferStub* stub = nullptr;
+  uint32_t sync_point_retired = 0;
+  {
+    base::AutoLock auto_lock(message_queue_->channel_messages_lock_);
+    message_queue_->handle_messages_scheduled_ = false;
+    if (message_queue_->channel_messages_.empty()) {
       return;
     }
+    m = message_queue_->channel_messages_.front();
+    stub = stubs_.get(m->message.routing_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
+    // immediately.
+    if (m->message.type() == GpuCommandBufferMsg_InsertSyncPoint::ID) {

[piman, 2015/09/01 03:55:26]

Why not move that part of the logic after the lock release too?

In particular, if unscheduled/preempted, we'll go through this multiple times,
which means we'll do AddSyncPoint multiple times - that's bad.

[David Yen, 2015/09/01 19:08:02]

Done.

+      const bool retire = m->retire_sync_point;
+      const uint32_t sync_point = m->sync_point_number;
+      const int32_t routing_id = m->message.routing_id();
+      if (stub) {
+        stub->AddSyncPoint(sync_point);
+        if (retire) {
+          m->message = GpuCommandBufferMsg_RetireSyncPoint(routing_id,
+                                                           sync_point);
+        }
+      } else {
+        sync_point_retired = sync_point;
+      }
+    }
+
+    if (!sync_point_retired && stub) {
+      if (!stub->IsScheduled())
+        return;
+      if (stub->IsPreempted()) {
+        message_queue_->ScheduleHandleMessageLocked();
+        return;
+      }
+    }
+
+    message_queue_->channel_messages_.pop_front();
+    if (!message_queue_->channel_messages_.empty())
+      message_queue_->ScheduleHandleMessageLocked();
   }
 
-  scoped_ptr<IPC::Message> message(m);
-  deferred_messages_.pop_front();
+  // TODO(dyen): Temporary handling of old sync points.
+  if (sync_point_retired) {
+    current_order_num_ = m->order_number;
+    gpu_channel_manager_->sync_point_manager()->RetireSyncPoint(
+        sync_point_retired);
+    MessageProcessed(m->order_number);
+    return;
+  }
+
+  scoped_ptr<ChannelMessage> scoped_message(m);
+  const uint32_t order_number = m->order_number;
+  IPC::Message* message = &m->message;
+
+  DVLOG(1) << "received message @" << message << " on channel @" << this
+           << " with type " << message->type();
+
   bool message_processed = true;
 
-  currently_processing_message_ = message.get();
+  if (order_number != static_cast<uint32_t>(-1)) {
+    // Make sure this is a valid unprocessed order number.
+    DCHECK(order_number <= GetUnprocessedOrderNum() &&
+           order_number >= GetProcessedOrderNum());
+
+    current_order_num_ = order_number;
+  }
   bool result;
   if (message->routing_id() == MSG_ROUTING_CONTROL)
     result = OnControlMessageReceived(*message);
   else
     result = router_.RouteMessage(*message);
-  currently_processing_message_ = NULL;
 
   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.
     if (stub) {
       if (stub->HasUnprocessedCommands()) {
-        deferred_messages_.push_front(new GpuCommandBufferMsg_Rescheduled(
-            stub->route_id()));
+        message_queue_->PushUnfinishedMessage(
+            order_number, GpuCommandBufferMsg_Rescheduled(stub->route_id()));
         message_processed = false;
       }
     }
   }
   if (message_processed)
-    MessageProcessed();
-
-  if (!deferred_messages_.empty()) {
-    OnScheduled();
-  }
+    MessageProcessed(order_number);
 }
 
 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);
 
@@ skipping 48 matching lines @@
   }
 }
 
 void GpuChannel::OnCreateJpegDecoder(int32 route_id, IPC::Message* reply_msg) {
   if (!jpeg_decoder_) {
     jpeg_decoder_.reset(new GpuJpegDecodeAccelerator(this, io_task_runner_));
   }
   jpeg_decoder_->AddClient(route_id, reply_msg);
 }
 
-void GpuChannel::MessageProcessed() {
-  messages_processed_++;
+void GpuChannel::MessageProcessed(uint32_t order_number) {
+  if (order_number != static_cast<uint32_t>(-1)) {
+    DCHECK(current_order_num_ == order_number);
+    processed_order_num_ = order_number;
+  }
   if (preempting_flag_.get()) {
     io_task_runner_->PostTask(
-        FROM_HERE, base::Bind(&GpuChannelMessageFilter::MessageProcessed,
-                              filter_, messages_processed_));
+        FROM_HERE, base::Bind(&GpuChannelMessageFilter::OnMessageProcessed,
+                              filter_));
   }
 }
 
 void GpuChannel::CacheShader(const std::string& key,
                              const std::string& shader) {
   gpu_channel_manager_->Send(
       new GpuHostMsg_CacheShader(client_id_, key, shader));
 }
 
 void GpuChannel::AddFilter(IPC::MessageFilter* filter) {
@@ skipping 48 matching lines @@
                                           client_id_);
     }
   }
 }
 
 void GpuChannel::HandleUpdateValueState(
     unsigned int target, const gpu::ValueState& state) {
   pending_valuebuffer_state_->UpdateState(target, state);
 }
 
+uint32_t GpuChannel::GetUnprocessedOrderNum() const {
+  return base::subtle::Acquire_Load(&message_queue_->unprocessed_order_num_);
+}
+
 }  // namespace content