content/gpu: Simplify gpu channel message handling.

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 <string>
 
 #include "base/containers/hash_tables.h"
@@ skipping 88 matching lines @@
     return io_task_runner_;
   }
 
   // IPC::Listener implementation:
   bool OnMessageReceived(const IPC::Message& msg) override;
   void OnChannelError() override;
 
   // IPC::Sender implementation:
   bool Send(IPC::Message* msg) override;
 
-  // Requeue the message that is currently being processed to the beginning of
-  // the queue. Used when the processing of a message gets aborted because of
-  // unscheduling conditions.
-  void RequeueMessage();
-
   // SubscriptionRefSet::Observer implementation
   void OnAddSubscription(unsigned int target) override;
   void OnRemoveSubscription(unsigned int target) override;
 
   // This is called when a command buffer transitions from the unscheduled
   // state to the scheduled state, which potentially means the channel
   // transitions from the unscheduled to the scheduled state. When this occurs
   // deferred IPC messaged are handled.
   void OnScheduled();
 
@@ skipping 48 matching lines @@
                               const gpu::ValueState& state);
 
   // Visible for testing.
   const gpu::ValueStateMap* pending_valuebuffer_state() const {
     return pending_valuebuffer_state_.get();
   }
 
   // Visible for testing.
   GpuChannelMessageFilter* filter() const { return filter_.get(); }
 
-  uint32_t GetCurrentOrderNum() const { return current_order_num_; }
-  uint32_t GetProcessedOrderNum() const { return processed_order_num_; }
+  // Returns the global order number of the IPC message that started processing
+  // last.
+  uint32_t current_order_num() const { return current_order_num_; }
+
+  // Returns the global order number for the last processed IPC message.
+  uint32_t GetProcessedOrderNum() const;
+
+  // Returns the global order number for the last unprocessed IPC message.
   uint32_t GetUnprocessedOrderNum() const;
 
+  void HandleMessage();
+
  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:
   class StreamState {
    public:
     StreamState(int32 id, GpuStreamPriority priority);
     ~StreamState();
 
     int32 id() const { return id_; }
     GpuStreamPriority priority() const { return priority_; }
 
     void AddRoute(int32 route_id);
     void RemoveRoute(int32 route_id);
     bool HasRoute(int32 route_id) const;
     bool HasRoutes() const;
 
    private:
     int32 id_;
     GpuStreamPriority priority_;
     base::hash_set<int32> routes_;
   };
 
-  friend class GpuChannelMessageFilter;
-  friend class GpuChannelMessageQueue;
-
   void OnDestroy();
 
   bool OnControlMessageReceived(const IPC::Message& msg);
 
-  void HandleMessage();
+  void ScheduleHandleMessage();
 
   // 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);
 
-  // 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_;
 
@@ skipping 29 matching lines @@
   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_;
 
-  // 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_;
 
   // Map of stream id to stream state.
   base::hash_map<int32, StreamState> streams_;
 
+  uint32_t current_order_num_;
+
   bool allow_future_sync_points_;
   bool allow_real_time_streams_;
 
   // 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);
 };
 
 // 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,
-      gpu::SyncPointManager* sync_point_manager,
-      scoped_refptr<base::SingleThreadTaskRunner> task_runner,
-      bool future_sync_points);
+  GpuChannelMessageFilter(GpuChannelMessageQueue* message_queue,
+                          gpu::SyncPointManager* sync_point_manager,
+                          base::SingleThreadTaskRunner* task_runner,
+                          bool future_sync_points);
 
   // IPC::MessageFilter implementation.
   void OnFilterAdded(IPC::Sender* sender) override;
   void OnFilterRemoved() override;
   void OnChannelConnected(int32 peer_pid) override;
   void OnChannelError() override;
   void OnChannelClosing() override;
   bool OnMessageReceived(const IPC::Message& message) override;
 
   void AddChannelFilter(scoped_refptr<IPC::MessageFilter> filter);
@@ skipping 57 matching lines @@
 
   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_;
 };
 
+struct GpuChannelMessage {
+  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;
+
+  GpuChannelMessage(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(0) {}
+};
+
+class GpuChannelMessageQueue
+    : public base::RefCountedThreadSafe<GpuChannelMessageQueue> {
+ public:
+  static scoped_refptr<GpuChannelMessageQueue> Create(
+      const base::WeakPtr<GpuChannel>& gpu_channel,
+      base::SingleThreadTaskRunner* task_runner);
+
+  // Returns the global order number for the last processed IPC message.
+  uint32_t GetUnprocessedOrderNum() const;
+
+  // Returns the global order number for the last unprocessed IPC message.
+  uint32_t processed_order_num() const { return processed_order_num_; }
+
+  bool HasQueuedMessages() const;
+
+  base::TimeTicks GetNextMessageTimeTick() const;
+
+  GpuChannelMessage* GetNextMessage() const;
+
+  // Should be called after a message returned by GetNextMessage is processed.
+  // Returns true if there are more messages on the queue.
+  bool MessageProcessed(uint32_t order_number);
+
+  void PushBackMessage(uint32_t order_number, const IPC::Message& message);
+
+  bool GenerateSyncPointMessage(gpu::SyncPointManager* sync_point_manager,
+                                uint32_t order_number,
+                                const IPC::Message& message,
+                                bool retire_sync_point,
+                                uint32_t* sync_point_number);
+
+  void DeleteAndDisableMessages(GpuChannelManager* gpu_channel_manager);
+
+ private:
+  friend class base::RefCountedThreadSafe<GpuChannelMessageQueue>;
+
+  GpuChannelMessageQueue(const base::WeakPtr<GpuChannel>& gpu_channel,
+                         base::SingleThreadTaskRunner* task_runner);
+  ~GpuChannelMessageQueue();
+
+  void ScheduleHandleMessage();
+
+  void PushMessageHelper(scoped_ptr<GpuChannelMessage> msg);
+
+  bool HasQueuedMessagesHelper() const;
+
+  bool enabled_;
+
+  // Highest IPC order number seen, set when queued on the IO thread.
+  uint32_t unprocessed_order_num_;
+  // Both deques own the messages.
+  std::deque<GpuChannelMessage*> channel_messages_;
+  std::deque<GpuChannelMessage*> out_of_order_messages_;
+
+  // This lock protects enabled_, unprocessed_order_num_, and both deques.
+  mutable base::Lock channel_messages_lock_;
+
+  // Last finished IPC order number. Not protected by a lock as it's only
+  // accessed on the main thread.
+  uint32_t processed_order_num_;
+
+  base::WeakPtr<GpuChannel> gpu_channel_;
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
+
+  DISALLOW_COPY_AND_ASSIGN(GpuChannelMessageQueue);
+};
+
 }  // namespace content
 
 #endif  // CONTENT_COMMON_GPU_GPU_CHANNEL_H_