Added global order numbers to in process command buffers.

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 18 matching lines @@
 #include "ui/gl/gpu_preference.h"
 
 struct GPUCreateCommandBufferConfig;
 
 namespace base {
 class WaitableEvent;
 }
 
 namespace gpu {
 class PreemptionFlag;
+class SyncPointClientState;
 class SyncPointManager;
 union ValueState;
 class ValueStateMap;
 namespace gles2 {
 class SubscriptionRefSet;
 }
 }
 
 namespace IPC {
 class MessageFilter;
@@ skipping 110 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(); }
 
-  // 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;
 
+  // Returns the shared sync point client state.
+  scoped_refptr<gpu::SyncPointClientState> GetSyncPointClientState();
+
   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_;
@@ skipping 83 matching lines @@
 
   gpu::gles2::DisallowedFeatures disallowed_features_;
   GpuWatchdog* watchdog_;
   bool software_;
 
   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);
 };
@@ skipping 111 matching lines @@
   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.
+  scoped_refptr<gpu::SyncPointClientState> GetSyncPointClientState();
+
+  // Returns the global order number for the last unprocessed 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_; }
+  uint32_t GetProcessedOrderNum() const;
 
   bool HasQueuedMessages() const;
 
   base::TimeTicks GetNextMessageTimeTick() const;
 
   GpuChannelMessage* GetNextMessage() const;
 
+  void BeginMessageProcessing(const GpuChannelMessage* msg);
+
   // Should be called after a message returned by GetNextMessage is processed.
   // Returns true if there are more messages on the queue.
   bool MessageProcessed();
 
-  void PushBackMessage(const IPC::Message& message);
+  void PushBackMessage(gpu::SyncPointManager* sync_point_manager,
+                       const IPC::Message& message);
 
   bool GenerateSyncPointMessage(gpu::SyncPointManager* sync_point_manager,
                                 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);
-
-  // This number is only ever incremented/read on the IO thread.
-  static uint32_t global_order_counter_;
+  void PushMessageHelper(gpu::SyncPointManager* sync_point_manager,
+                         scoped_ptr<GpuChannelMessage> msg);
 
   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_;
 
-  // This lock protects enabled_, unprocessed_order_num_, and channel_messages_.
+  // This lock protects enabled_ 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_;
+  // Keeps track of sync point related state such as message order numbers.
+  scoped_refptr<gpu::SyncPointClientState> sync_point_client_state_;
 
   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_