content/gpu: Remove separate queue for out-of-order messages.

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 162 matching lines @@
   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();
 
+  // Some messages such as WaitForGetOffsetInRange and WaitForTokenInRange are
+  // processed as soon as possible because the client is blocked until they
+  // are completed.
+  void HandleOutOfOrderMessage(const IPC::Message& msg);
+
  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:
@@ skipping 102 matching lines @@
 //   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(GpuChannelMessageQueue* message_queue,
+  GpuChannelMessageFilter(const base::WeakPtr<GpuChannel>& gpu_channel,
+                          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;
@@ skipping 39 matching lines @@
   void TransitionToChecking();
   void TransitionToPreempting();
   void TransitionToWouldPreemptDescheduled();
 
   PreemptionState preemption_state_;
 
   // Maximum amount of time that we can spend in PREEMPTING.
   // It is reset when we transition to IDLE.
   base::TimeDelta max_preemption_time_;
 
+  base::WeakPtr<GpuChannel> gpu_channel_;
   // The message_queue_ is used to handle messages on the main thread.
   scoped_refptr<GpuChannelMessageQueue> message_queue_;
   IPC::Sender* sender_;
   base::ProcessId peer_pid_;
   gpu::SyncPointManager* sync_point_manager_;
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   scoped_refptr<gpu::PreemptionFlag> preempting_flag_;
   std::vector<scoped_refptr<IPC::MessageFilter>> channel_filters_;
 
   // This timer is created and destroyed on the IO thread.
   scoped_ptr<base::OneShotTimer<GpuChannelMessageFilter>> timer_;
 
   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()),
+  GpuChannelMessage(const IPC::Message& msg)
+      : order_number(0),
+        time_received(base::TimeTicks()),
         message(msg),
         retire_sync_point(false),
         sync_point(0) {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(GpuChannelMessage);
 };
 
 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);
+  bool MessageProcessed();
 
-  void PushBackMessage(uint32_t order_number, const IPC::Message& message);
+  void PushBackMessage(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;
+  // This number is only ever incremented/read on the IO thread.
+  static uint32_t global_order_counter_;
 
   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.
+  // This lock protects enabled_, unprocessed_order_num_, and channel_messages_.
   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_