Invalid sync token waits now automatically get released.

gpu/command_buffer/service/sync_point_manager.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 GPU_COMMAND_BUFFER_SERVICE_SYNC_POINT_MANAGER_H_
 #define GPU_COMMAND_BUFFER_SERVICE_SYNC_POINT_MANAGER_H_
 
 #include <stdint.h>
 
 #include <functional>
@@ skipping 55 matching lines @@
     return !paused_ && current_order_num_ > processed_order_num();
   }
 
  private:
   friend class base::RefCountedThreadSafe<SyncPointOrderData>;
   friend class SyncPointClientState;
 
   struct OrderFence {
     uint32_t order_num;
     uint64_t fence_release;
+    base::Closure release_callback;
     scoped_refptr<SyncPointClientState> client_state;
 
     OrderFence(uint32_t order,
                uint64_t release,
+               const base::Closure& release_callback,
                scoped_refptr<SyncPointClientState> state);
     OrderFence(const OrderFence& other);
     ~OrderFence();
 
     bool operator>(const OrderFence& rhs) const {
       return (order_num > rhs.order_num) ||
              ((order_num == rhs.order_num) &&
               (fence_release > rhs.fence_release));
     }
   };
   typedef std::priority_queue<OrderFence,
                               std::vector<OrderFence>,
                               std::greater<OrderFence>> OrderFenceQueue;
 
   SyncPointOrderData();
   ~SyncPointOrderData();
 
   bool ValidateReleaseOrderNumber(
       scoped_refptr<SyncPointClientState> client_state,
       uint32_t wait_order_num,
-      uint64_t fence_release);
+      uint64_t fence_release,
+      const base::Closure& release_callback);
 
   // Non thread-safe functions need to be called from a single thread.
   base::ThreadChecker processing_thread_checker_;
 
   // Current IPC order number being processed (only used on processing thread).
   uint32_t current_order_num_;
 
   // Whether or not the current order number is being processed or paused.
   bool paused_;
 
@@ skipping 64 matching lines @@
 
   // Queues the callback to be called if the release is valid. If the release
   // is invalid this function will return False and the callback will never
   // be called.
   bool WaitForRelease(CommandBufferNamespace namespace_id,
                       CommandBufferId client_id,
                       uint32_t wait_order_num,
                       uint64_t release,
                       const base::Closure& callback);
 
+  // Releases a fence sync and all fence syncs below.
   void ReleaseFenceSync(uint64_t release);
-  void EnsureReleased(uint64_t release);
-  void ReleaseFenceSyncLocked(uint64_t release,
-                              std::vector<base::Closure>* callback_list);
+
+  // Does not release the fence sync, but releases callbacks waiting on that
+  // fence sync.
+  void EnsureWaitReleased(uint64_t release, const base::Closure& callback);
 
   typedef base::Callback<void(CommandBufferNamespace, CommandBufferId)>
       OnWaitCallback;
   void SetOnWaitCallback(const OnWaitCallback& callback);
 
   // Global order data where releases will originate from.
   scoped_refptr<SyncPointOrderData> order_data_;
 
   // Protects fence_sync_release_, fence_callback_queue_.
   base::Lock fence_sync_lock_;
@@ skipping 124 matching lines @@
   // Client map holds a map of clients id to client for each namespace.
   base::Lock client_maps_lock_;
   ClientMap client_maps_[NUM_COMMAND_BUFFER_NAMESPACES];
 
   DISALLOW_COPY_AND_ASSIGN(SyncPointManager);
 };
 
 }  // namespace gpu
 
 #endif  // GPU_COMMAND_BUFFER_SERVICE_SYNC_POINT_MANAGER_H_