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

content/common/gpu/gpu_channel_manager.h

 // 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.
 
 #ifndef CONTENT_COMMON_GPU_GPU_CHANNEL_MANAGER_H_
 #define CONTENT_COMMON_GPU_GPU_CHANNEL_MANAGER_H_
 
 #include <deque>
 #include <string>
 #include <vector>
 
 #include "base/containers/scoped_ptr_hash_map.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
+#include "base/threading/thread_checker.h"
 #include "build/build_config.h"
 #include "content/common/content_export.h"
 #include "content/common/content_param_traits.h"
 #include "content/common/gpu/gpu_memory_manager.h"
 #include "content/common/message_router.h"
 #include "ipc/ipc_listener.h"
 #include "ipc/ipc_sender.h"
 #include "ui/gfx/gpu_memory_buffer.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gl/gl_surface.h"
@@ skipping 50 matching lines @@
   // Remove the channel for a particular renderer.
   void RemoveChannel(int client_id);
 
   // Listener overrides.
   bool OnMessageReceived(const IPC::Message& msg) override;
 
   // Sender overrides.
   bool Send(IPC::Message* msg) override;
 
   bool HandleMessagesScheduled();
-  uint64 MessagesProcessed();
+  uint32_t ProcessedOrderNumber();
 
   void LoseAllContexts();
 
   int GenerateRouteID();
   void AddRoute(int32 routing_id, IPC::Listener* listener);
   void RemoveRoute(int32 routing_id);
 
+  uint32_t GenerateGlobalOrderNumber();
+
   gpu::gles2::ProgramCache* program_cache();
   gpu::gles2::ShaderTranslatorCache* shader_translator_cache();
   gpu::gles2::FramebufferCompletenessCache* framebuffer_completeness_cache();
 
   GpuMemoryManager* gpu_memory_manager() { return &gpu_memory_manager_; }
 
   GpuChannel* LookupChannel(int32 client_id);
 
   gpu::SyncPointManager* sync_point_manager() {
     return sync_point_manager_;
@@ skipping 42 matching lines @@
   void DestroyGpuMemoryBufferOnIO(gfx::GpuMemoryBufferId id, int client_id);
   void OnDestroyGpuMemoryBuffer(gfx::GpuMemoryBufferId id,
                                 int client_id,
                                 int32 sync_point);
 
   void OnUpdateValueState(int client_id,
                           unsigned int target,
                           const gpu::ValueState& state);
   void OnLoseAllContexts();
 
+  // Thread Checkers.
+  base::ThreadChecker io_thread_checker_;
+
   // Used to send and receive IPC messages from the browser process.
   IPC::SyncChannel* const channel_;
   MessageRouter router_;
+  uint32_t global_order_counter_;

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

Use a AtomicSequenceNumber, then you don't need extra thread checks.

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

This number is only operated on from the IO thread so it doesn't need to be
atomic. But since I've moved it to the GpuChannelMessageFilter as a private
static number, I don't think the thread checker is necessary anymore since it's
easier to verify that it is only called from the IO thread.

 
   GpuWatchdog* watchdog_;
 
   base::WaitableEvent* shutdown_event_;
 
   scoped_refptr<gfx::GLShareGroup> share_group_;
   scoped_refptr<gpu::gles2::MailboxManager> mailbox_manager_;
   GpuMemoryManager gpu_memory_manager_;
   // SyncPointManager guaranteed to outlive running MessageLoop.
   gpu::SyncPointManager* sync_point_manager_;
@@ skipping 10 matching lines @@
   // that any WeakPtrs to Controller are invalidated before its members
   // variable's destructors are executed, rendering them invalid.
   base::WeakPtrFactory<GpuChannelManager> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(GpuChannelManager);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_COMMON_GPU_GPU_CHANNEL_MANAGER_H_