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

content/common/gpu/gpu_channel.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_H_
 #define CONTENT_COMMON_GPU_GPU_CHANNEL_H_
 
-#include <deque>
 #include <string>
 
 #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/process/process.h"
 #include "base/trace_event/memory_dump_provider.h"
 #include "build/build_config.h"
 #include "content/common/content_export.h"
@@ skipping 24 matching lines @@
 }
 
 namespace IPC {
 class AttachmentBroker;
 class MessageFilter;
 }
 
 namespace content {
 class GpuChannelManager;
 class GpuChannelMessageFilter;
+class GpuChannelMessageQueue;
 class GpuJpegDecodeAccelerator;
 class GpuWatchdog;
 
 // Encapsulates an IPC channel between the GPU process and one renderer
 // process. On the renderer side there's a corresponding GpuChannelHost.
 class CONTENT_EXPORT GpuChannel
     : public IPC::Listener,
       public IPC::Sender,
       public gpu::gles2::SubscriptionRefSet::Observer {
  public:
@@ skipping 74 matching lines @@
 
   // Called to add a listener for a particular message routing ID.
   // Returns true if succeeded.
   bool AddRoute(int32 route_id, IPC::Listener* listener);
 
   // Called to remove a listener for a particular message routing ID.
   void RemoveRoute(int32 route_id);
 
   gpu::PreemptionFlag* GetPreemptionFlag();
 
-  bool handle_messages_scheduled() const { return handle_messages_scheduled_; }
-  uint64 messages_processed() const { return messages_processed_; }
-
   // If |preemption_flag->IsSet()|, any stub on this channel
   // should stop issuing GL commands. Setting this to NULL stops deferral.
   void SetPreemptByFlag(
       scoped_refptr<gpu::PreemptionFlag> preemption_flag);
 
   void CacheShader(const std::string& key, const std::string& shader);
 
   virtual void AddFilter(IPC::MessageFilter* filter);
   virtual void RemoveFilter(IPC::MessageFilter* filter);
 
   uint64 GetMemoryUsage();
 
   scoped_refptr<gfx::GLImage> CreateImageForGpuMemoryBuffer(
       const gfx::GpuMemoryBufferHandle& handle,
       const gfx::Size& size,
       gfx::BufferFormat format,
       uint32 internalformat);
 
   bool allow_future_sync_points() const { return allow_future_sync_points_; }
 
   void HandleUpdateValueState(unsigned int target,
                               const gpu::ValueState& state);
 
   // Visible for testing.
   const gpu::ValueStateMap* pending_valuebuffer_state() const {
     return pending_valuebuffer_state_.get();
   }
 
+  uint32_t GetCurrentOrderNum() const { return current_order_num_; }
+  uint32_t GetProcessedOrderNum() const { return processed_order_num_; }
+  uint32_t GetUnprocessedOrderNum() const;
+
  protected:
   // The message filter on the io thread.
   scoped_refptr<GpuChannelMessageFilter> filter_;
 
   // Map of routing id to command buffer stub.
   base::ScopedPtrHashMap<int32, scoped_ptr<GpuCommandBufferStub>> stubs_;
 
  private:
   friend class GpuChannelMessageFilter;
+  friend class GpuChannelMessageQueue;
 
   void OnDestroy();
 
   bool OnControlMessageReceived(const IPC::Message& msg);
 
   void HandleMessage();
 
   // Message handlers.
   void OnCreateOffscreenCommandBuffer(
       const gfx::Size& size,
       const GPUCreateCommandBufferConfig& init_params,
       int32 route_id,
       bool* succeeded);
   void OnDestroyCommandBuffer(int32 route_id);
   void OnCreateJpegDecoder(int32 route_id, IPC::Message* reply_msg);
 
-  // Decrement the count of unhandled IPC messages and defer preemption.
-  void MessageProcessed();
+  // Update processed order number and defer preemption.
+  void MessageProcessed(uint32_t order_number);
 
   // The lifetime of objects of this class is managed by a GpuChannelManager.
   // The GpuChannelManager destroy all the GpuChannels that they own when they
   // are destroyed. So a raw pointer is safe.
   GpuChannelManager* gpu_channel_manager_;
 
   scoped_ptr<IPC::SyncChannel> channel_;
 
   // Uniquely identifies the channel within this GPU process.
   std::string channel_id_;
 
   // Used to implement message routing functionality to CommandBuffer objects
   MessageRouter router_;
 
-  uint64 messages_processed_;
-
   // Whether the processing of IPCs on this channel is stalled and we should
   // preempt other GpuChannels.
   scoped_refptr<gpu::PreemptionFlag> preempting_flag_;
 
   // If non-NULL, all stubs on this channel should stop processing GL
   // commands (via their GpuScheduler) when preempted_flag_->IsSet()
   scoped_refptr<gpu::PreemptionFlag> preempted_flag_;
 
-  std::deque<IPC::Message*> deferred_messages_;
+  scoped_refptr<GpuChannelMessageQueue> message_queue_;
 
   // The id of the client who is on the other side of the channel.
   int client_id_;
 
   // The tracing ID used for memory allocations associated with this client.
   uint64_t client_tracing_id_;
 
   // The task runners for the main thread and the io thread.
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
 
   // The share group that all contexts associated with a particular renderer
   // process use.
   scoped_refptr<gfx::GLShareGroup> share_group_;
 
   scoped_refptr<gpu::gles2::MailboxManager> mailbox_manager_;
 
   scoped_refptr<gpu::gles2::SubscriptionRefSet> subscription_ref_set_;
 
   scoped_refptr<gpu::ValueStateMap> pending_valuebuffer_state_;
 
   scoped_ptr<GpuJpegDecodeAccelerator> jpeg_decoder_;
 
   gpu::gles2::DisallowedFeatures disallowed_features_;
   GpuWatchdog* watchdog_;
   bool software_;
-  bool handle_messages_scheduled_;
-  IPC::Message* currently_processing_message_;
+
+  // Current IPC order number being processed.
+  uint32_t current_order_num_;
+
+  // Last finished IPC order number.
+  uint32_t processed_order_num_;
 
   size_t num_stubs_descheduled_;
 
   bool allow_future_sync_points_;
 
   // Member variables should appear before the WeakPtrFactory, to ensure
   // that any WeakPtrs to Controller are invalidated before its members
   // variable's destructors are executed, rendering them invalid.
   base::WeakPtrFactory<GpuChannel> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(GpuChannel);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_COMMON_GPU_GPU_CHANNEL_H_