Implemented new fence syncs which replaces the old sync points.

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 97 matching lines @@
 
   // 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;
 
+  // Add callback when a specific order number has been processed.
+  void AddProcessedOrderNumberCallback(uint32_t order_number,
+                                       const base::Closure& callback);
+
   // 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();
 
   // This is called when a command buffer transitions between scheduled and
   // descheduled states. When any stub is descheduled, we stop preempting
   // other channels.
   void StubSchedulingChanged(bool scheduled);
@@ skipping 75 matching lines @@
     void RemoveRoute(int32 route_id);
     bool HasRoute(int32 route_id) const;
     bool HasRoutes() const;
 
    private:
     int32 id_;
     GpuStreamPriority priority_;
     base::hash_set<int32> routes_;
   };
 
+  struct OrderCallback {
+    uint32_t order_number;
+    base::Closure callback_closure;
+
+    OrderCallback(uint32_t order_num, const base::Closure& callback);
+    ~OrderCallback();
+
+    bool operator>(const OrderCallback& rhs) const {
+      return order_number > rhs.order_number;
+    }
+  };
+  typedef std::priority_queue<OrderCallback,
+                              std::vector<OrderCallback>,
+                              std::greater<OrderCallback>> OrderCallbackQueue;
+
   friend class GpuChannelMessageFilter;
   friend class GpuChannelMessageQueue;
 
   void OnDestroy();
 
   bool OnControlMessageReceived(const IPC::Message& msg);
 
   void HandleMessage();
 
   // Message handlers.
@@ skipping 61 matching lines @@
   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_;
 
+  // Callbacks as each order number is processed.
+  OrderCallbackQueue processed_order_callbacks_;
+
   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 89 matching lines @@
   // 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_;
 };
 
 }  // namespace content
 
 #endif  // CONTENT_COMMON_GPU_GPU_CHANNEL_H_