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

content/common/gpu/gpu_command_buffer_stub.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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/hash.h"
 #include "base/json/json_writer.h"
 #include "base/memory/shared_memory.h"
@@ skipping 181 matching lines @@
       use_virtualized_gl_context_(use_virtualized_gl_context),
       stream_id_(stream_id),
       route_id_(route_id),
       surface_id_(surface_id),
       software_(software),
       last_flush_count_(0),
       last_memory_allocation_valid_(false),
       watchdog_(watchdog),
       sync_point_wait_count_(0),
       delayed_work_scheduled_(false),
-      previous_messages_processed_(0),
+      previous_processed_num_(0),
       active_url_(active_url),
       total_gpu_memory_(0) {
   active_url_hash_ = base::Hash(active_url.possibly_invalid_spec());
   FastSetActiveURL(active_url_, active_url_hash_);
 
   gpu::gles2::ContextCreationAttribHelper attrib_parser;
   attrib_parser.Parse(requested_attribs_);
 
   if (share_group) {
     context_group_ = share_group->context_group_;
@@ skipping 121 matching lines @@
 }
 
 void GpuCommandBufferStub::PollWork() {
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::PollWork");
   delayed_work_scheduled_ = false;
   FastSetActiveURL(active_url_, active_url_hash_);
   if (decoder_.get() && !MakeCurrent())
     return;
 
   if (scheduler_) {
-    uint64 current_messages_processed =
-        channel()->gpu_channel_manager()->MessagesProcessed();
+    const uint32_t current_processed_num =
+        channel()->gpu_channel_manager()->ProcessedOrderNumber();
     // We're idle when no messages were processed or scheduled.
     bool is_idle =
-        (previous_messages_processed_ == current_messages_processed) &&
+        (previous_processed_num_ == current_processed_num) &&
         !channel()->gpu_channel_manager()->HandleMessagesScheduled();
     if (!is_idle && !last_idle_time_.is_null()) {
       base::TimeDelta time_since_idle =
           base::TimeTicks::Now() - last_idle_time_;
       base::TimeDelta max_time_since_idle =
           base::TimeDelta::FromMilliseconds(kMaxTimeSinceIdleMs);
 
       // Force idle when it's been too long since last time we were idle.
       if (time_since_idle > max_time_since_idle)
         is_idle = true;
@@ skipping 21 matching lines @@
     last_idle_time_ = base::TimeTicks();
     return;
   }
 
   if (delayed_work_scheduled_)
     return;
   delayed_work_scheduled_ = true;
 
   // Idle when no messages are processed between now and when
   // PollWork is called.
-  previous_messages_processed_ =
-      channel()->gpu_channel_manager()->MessagesProcessed();
+
+  previous_processed_num_ =
+      channel()->gpu_channel_manager()->ProcessedOrderNumber();
   if (last_idle_time_.is_null())
     last_idle_time_ = base::TimeTicks::Now();
 
   // IsScheduled() returns true after passing all unschedule fences
   // and this is when we can start performing idle work. Idle work
   // is done synchronously so we can set delay to 0 and instead poll
   // for more work at the rate idle work is performed. This also ensures
   // that idle work is done as efficiently as possible without any
   // unnecessary delays.
   if (scheduler_.get() &&
@@ skipping 777 matching lines @@
                                                     result));
 }
 
 void GpuCommandBufferStub::SendUpdateVSyncParameters(base::TimeTicks timebase,
                                                      base::TimeDelta interval) {
   Send(new GpuCommandBufferMsg_UpdateVSyncParameters(route_id_, timebase,
                                                      interval));
 }
 
 }  // namespace content