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

content/common/gpu/gpu_channel_manager.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_manager.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 21 matching lines @@
     GpuWatchdog* watchdog,
     base::SingleThreadTaskRunner* task_runner,
     base::SingleThreadTaskRunner* io_task_runner,
     base::WaitableEvent* shutdown_event,
     IPC::AttachmentBroker* broker,
     gpu::SyncPointManager* sync_point_manager,
     GpuMemoryBufferFactory* gpu_memory_buffer_factory)
     : task_runner_(task_runner),
       io_task_runner_(io_task_runner),
       channel_(channel),
+      global_order_counter_(0),
       watchdog_(watchdog),
       shutdown_event_(shutdown_event),
       gpu_memory_manager_(
           this,
           GpuMemoryManager::kDefaultMaxSurfacesWithFrontbufferSoftLimit),
       sync_point_manager_(sync_point_manager),
       gpu_memory_buffer_factory_(gpu_memory_buffer_factory),
       attachment_broker_(broker),
       weak_factory_(this) {
   DCHECK(task_runner);
   DCHECK(io_task_runner);
+  io_thread_checker_.DetachFromThread();
 }
 
 GpuChannelManager::~GpuChannelManager() {
   // Destroy channels before anything else because of dependencies.
   gpu_channels_.clear();
   if (default_offscreen_surface_.get()) {
     default_offscreen_surface_->Destroy();
     default_offscreen_surface_ = NULL;
   }
 }
@@ skipping 35 matching lines @@
 }
 
 void GpuChannelManager::AddRoute(int32 routing_id, IPC::Listener* listener) {
   router_.AddRoute(routing_id, listener);
 }
 
 void GpuChannelManager::RemoveRoute(int32 routing_id) {
   router_.RemoveRoute(routing_id);
 }
 
+uint32_t GpuChannelManager::GenerateGlobalOrderNumber() {
+  DCHECK(io_thread_checker_.CalledOnValidThread());
+  return global_order_counter_++;
+}
+
 GpuChannel* GpuChannelManager::LookupChannel(int32 client_id) {
   const auto& it = gpu_channels_.find(client_id);
   return it != gpu_channels_.end() ? it->second : nullptr;
 }
 
 bool GpuChannelManager::OnControlMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(GpuChannelManager, msg)
     IPC_MESSAGE_HANDLER(GpuMsg_EstablishChannel, OnEstablishChannel)
     IPC_MESSAGE_HANDLER(GpuMsg_CloseChannel, OnCloseChannel)
@@ skipping 130 matching lines @@
 }
 
 bool GpuChannelManager::HandleMessagesScheduled() {
   for (auto& kv : gpu_channels_) {
     if (kv.second->handle_messages_scheduled())
       return true;
   }
   return false;
 }
 
-uint64 GpuChannelManager::MessagesProcessed() {
-  uint64 messages_processed = 0;
+uint32_t GpuChannelManager::ProcessedOrderNumber() {
+  uint32_t processed_order_num = 0;
   for (auto& kv : gpu_channels_)

[piman, 2015/08/31 23:15:04]

nit: needs brackets per style guide

[David Yen, 2015/09/01 02:01:52]

Done, although I was following the style in the below function :). I changed the
function below as well.

-    messages_processed += kv.second->messages_processed();
-  return messages_processed;
+    processed_order_num = std::max(processed_order_num,
+                                   kv.second->GetProcessedOrderNum());
+  return processed_order_num;
 }
 
 void GpuChannelManager::LoseAllContexts() {
   for (auto& kv : gpu_channels_)
     kv.second->MarkAllContextsLost();
   task_runner_->PostTask(FROM_HERE,
                          base::Bind(&GpuChannelManager::OnLoseAllContexts,
                                     weak_factory_.GetWeakPtr()));
 }
 
 void GpuChannelManager::OnLoseAllContexts() {
   gpu_channels_.clear();
 }
 
 gfx::GLSurface* GpuChannelManager::GetDefaultOffscreenSurface() {
   if (!default_offscreen_surface_.get()) {
     default_offscreen_surface_ =
         gfx::GLSurface::CreateOffscreenGLSurface(gfx::Size());
   }
   return default_offscreen_surface_.get();
 }
 
 }  // namespace content