Converted video frame and image callbacks to use new sync tokens.

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 <functional>
 #include <queue>
 #include <vector>
 
 #include "base/atomic_sequence_num.h"
 #include "base/callback.h"
 #include "base/containers/hash_tables.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread_checker.h"
 #include "gpu/command_buffer/common/constants.h"
 #include "gpu/gpu_export.h"
 
 namespace base {
 class SingleThreadTaskRunner;
@@ skipping 104 matching lines @@
   }
 
   uint64_t fence_sync_release() {
     base::AutoLock auto_lock(fence_sync_lock_);
     return fence_sync_release_;
   }
 
  private:
   friend class base::RefCountedThreadSafe<SyncPointClientState>;
   friend class SyncPointClient;
+  friend class SyncPointClientWaiter;
   friend class SyncPointOrderData;
 
   struct ReleaseCallback {
     uint64_t release_count;
     base::Closure callback_closure;
 
     ReleaseCallback(uint64_t release, const base::Closure& callback);
     ~ReleaseCallback();
 
     bool operator>(const ReleaseCallback& rhs) const {
@@ skipping 75 matching lines @@
   // Keep the state that is sharable across multiple threads.
   scoped_refptr<SyncPointClientState> client_state_;
 
   // Unique namespace/client id pair for this sync point client.
   const CommandBufferNamespace namespace_id_;
   const uint64_t client_id_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncPointClient);
 };
 
+// A SyncPointClientWaiter is a Sync Point Client which can only wait and on
+// fence syncs and not release any fence syncs itself. Because they cannot
+// release any fence syncs they do not need an associated order number since
+// deadlocks cannot happen. Note that it is important that this class does
+// not exist in the same execution thread as a SyncPointClient, or else a
+// deadlock could occur.
+class SyncPointClientWaiter {
+ public:
+  SyncPointClientWaiter();
+  ~SyncPointClientWaiter();
+
+  bool Wait(SyncPointClientState* release_state,
+            uint64_t release_count,
+            const base::Closure& wait_complete_callback);
+
+  bool WaitNonThreadSafe(SyncPointClientState* release_state,
+                         uint64_t release_count,
+                         scoped_refptr<base::SingleThreadTaskRunner> runner,
+                         const base::Closure& wait_complete_callback);
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(SyncPointClientWaiter);
+};
+
 // This class manages the sync points, which allow cross-channel
 // synchronization.
 class GPU_EXPORT SyncPointManager {
  public:
   explicit SyncPointManager(bool allow_threaded_wait);
   ~SyncPointManager();
 
   // Creates/Destroy a sync point client which message processors should hold.
   scoped_ptr<SyncPointClient> CreateSyncPointClient(
       scoped_refptr<SyncPointOrderData> order_data,
@@ skipping 52 matching lines @@
   SyncPointMap sync_point_map_;
   uint32 next_sync_point_;
   base::ConditionVariable retire_cond_var_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncPointManager);
 };
 
 }  // namespace gpu
 
 #endif  // GPU_COMMAND_BUFFER_SERVICE_SYNC_POINT_MANAGER_H_