Share SyncPointManager implementation in in-process cmd buffer

gpu/command_buffer/service/in_process_command_buffer.cc

 // Copyright 2013 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.
 
 #include "gpu/command_buffer/service/in_process_command_buffer.h"
 
 #include <queue>
 #include <set>
 #include <utility>
 
@@ skipping 13 matching lines @@
 #include "gpu/command_buffer/service/context_group.h"
 #include "gpu/command_buffer/service/gl_context_virtual.h"
 #include "gpu/command_buffer/service/gpu_scheduler.h"
 #include "gpu/command_buffer/service/gpu_switches.h"
 #include "gpu/command_buffer/service/image_factory.h"
 #include "gpu/command_buffer/service/image_manager.h"
 #include "gpu/command_buffer/service/mailbox_manager_impl.h"
 #include "gpu/command_buffer/service/mailbox_manager_sync.h"
 #include "gpu/command_buffer/service/memory_tracking.h"
 #include "gpu/command_buffer/service/query_manager.h"
+#include "gpu/command_buffer/service/sync_point_manager.h"
 #include "gpu/command_buffer/service/transfer_buffer_manager.h"
 #include "gpu/command_buffer/service/valuebuffer_manager.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_image.h"
 #include "ui/gl/gl_share_group.h"
 
 #if defined(OS_ANDROID)
 #include "gpu/command_buffer/service/stream_texture_manager_in_process_android.h"
 #include "ui/gl/android/surface_texture.h"
@@ skipping 78 matching lines @@
 
 class ScopedEvent {
  public:
   ScopedEvent(base::WaitableEvent* event) : event_(event) {}
   ~ScopedEvent() { event_->Signal(); }
 
  private:
   base::WaitableEvent* event_;
 };
 
-class SyncPointManager {
- public:
-  SyncPointManager();
-  ~SyncPointManager();
-
-  uint32 GenerateSyncPoint();
-  void RetireSyncPoint(uint32 sync_point);
-
-  bool IsSyncPointPassed(uint32 sync_point);
-  void WaitSyncPoint(uint32 sync_point);
-
-private:
-  // This lock protects access to pending_sync_points_ and next_sync_point_ and
-  // is used with the ConditionVariable to signal when a sync point is retired.
-  base::Lock lock_;
-  std::set<uint32> pending_sync_points_;
-  uint32 next_sync_point_;
-  base::ConditionVariable cond_var_;
-};
-
-SyncPointManager::SyncPointManager() : next_sync_point_(1), cond_var_(&lock_) {}
-
-SyncPointManager::~SyncPointManager() {
-  DCHECK_EQ(pending_sync_points_.size(), 0U);
+SyncPointManager* GetSyncPointManager() {
+  static base::LazyInstance<scoped_refptr<SyncPointManager>>
+      g_sync_point_manager = LAZY_INSTANCE_INITIALIZER;
+  if (!g_sync_point_manager.Get().get())

[no sievers, 2015/01/15 20:10:47]

not thread-safe. you can probably just wrap the reference in a class that you
instantiate through LazyInstance here.

+    g_sync_point_manager.Get() = new SyncPointManager;
+  return g_sync_point_manager.Get().get();
 }
 
-uint32 SyncPointManager::GenerateSyncPoint() {
-  base::AutoLock lock(lock_);
-  uint32 sync_point = next_sync_point_++;
-  DCHECK_EQ(pending_sync_points_.count(sync_point), 0U);
-  pending_sync_points_.insert(sync_point);
-  return sync_point;
-}
-
-void SyncPointManager::RetireSyncPoint(uint32 sync_point) {
-  base::AutoLock lock(lock_);
-  DCHECK(pending_sync_points_.count(sync_point));
-  pending_sync_points_.erase(sync_point);
-  cond_var_.Broadcast();
-}
-
-bool SyncPointManager::IsSyncPointPassed(uint32 sync_point) {
-  base::AutoLock lock(lock_);
-  return pending_sync_points_.count(sync_point) == 0;
-}
-
-void SyncPointManager::WaitSyncPoint(uint32 sync_point) {
-  base::AutoLock lock(lock_);
-  while (pending_sync_points_.count(sync_point)) {
-    cond_var_.Wait();
-  }
-}
-
-base::LazyInstance<SyncPointManager> g_sync_point_manager =
-    LAZY_INSTANCE_INITIALIZER;
-
 base::SharedMemoryHandle ShareToGpuThread(
     base::SharedMemoryHandle source_handle) {
 #if defined(OS_WIN)
   // Windows needs to explicitly duplicate the handle to current process.
   base::SharedMemoryHandle target_handle;
   if (!DuplicateHandle(GetCurrentProcess(),
                        source_handle,
                        GetCurrentProcess(),
                        &target_handle,
                        FILE_GENERIC_READ | FILE_GENERIC_WRITE,
@@ skipping 585 matching lines @@
           gfx::Size(width, height),
           gpu::ImageFactory::ImageFormatToGpuMemoryBufferFormat(internalformat),
           gpu::ImageFactory::ImageUsageToGpuMemoryBufferUsage(usage)));
   if (!buffer)
     return -1;
 
   return CreateImage(buffer->AsClientBuffer(), width, height, internalformat);
 }
 
 uint32 InProcessCommandBuffer::InsertSyncPoint() {
-  uint32 sync_point = g_sync_point_manager.Get().GenerateSyncPoint();
+  uint32 sync_point = GetSyncPointManager()->GenerateSyncPoint();
   QueueTask(base::Bind(&InProcessCommandBuffer::RetireSyncPointOnGpuThread,
                        base::Unretained(this),
                        sync_point));
   return sync_point;
 }
 
 uint32 InProcessCommandBuffer::InsertFutureSyncPoint() {
-  return g_sync_point_manager.Get().GenerateSyncPoint();
+  return GetSyncPointManager()->GenerateSyncPoint();
 }
 
 void InProcessCommandBuffer::RetireSyncPoint(uint32 sync_point) {
   QueueTask(base::Bind(&InProcessCommandBuffer::RetireSyncPointOnGpuThread,
                        base::Unretained(this),
                        sync_point));
 }
 
 void InProcessCommandBuffer::RetireSyncPointOnGpuThread(uint32 sync_point) {
   gles2::MailboxManager* mailbox_manager =
       decoder_->GetContextGroup()->mailbox_manager();
   if (mailbox_manager->UsesSync()) {
     bool make_current_success = false;
     {
       base::AutoLock lock(command_buffer_lock_);
       make_current_success = MakeCurrent();
     }
     if (make_current_success)
       mailbox_manager->PushTextureUpdates(sync_point);
   }
-  g_sync_point_manager.Get().RetireSyncPoint(sync_point);
+  GetSyncPointManager()->RetireSyncPoint(sync_point);
 }
 
 void InProcessCommandBuffer::SignalSyncPoint(unsigned sync_point,
                                              const base::Closure& callback) {
   CheckSequencedThread();
   QueueTask(base::Bind(&InProcessCommandBuffer::SignalSyncPointOnGpuThread,
                        base::Unretained(this),
                        sync_point,
                        WrapCallback(callback)));
 }
 
 bool InProcessCommandBuffer::WaitSyncPointOnGpuThread(unsigned sync_point) {
-  g_sync_point_manager.Get().WaitSyncPoint(sync_point);
+  // GetSyncPointManager()->WaitSyncPoint(sync_point); TODO(boliu)
   gles2::MailboxManager* mailbox_manager =
       decoder_->GetContextGroup()->mailbox_manager();
   mailbox_manager->PullTextureUpdates(sync_point);
   return true;
 }
 
 void InProcessCommandBuffer::SignalSyncPointOnGpuThread(
     unsigned sync_point,
     const base::Closure& callback) {
-  if (g_sync_point_manager.Get().IsSyncPointPassed(sync_point)) {
-    callback.Run();
-  } else {
-    service_->ScheduleIdleWork(
-        base::Bind(&InProcessCommandBuffer::SignalSyncPointOnGpuThread,
-                   gpu_thread_weak_ptr_,
-                   sync_point,
-                   callback));
-  }
+  GetSyncPointManager()->AddSyncPointCallback(sync_point, callback);
 }
 
 void InProcessCommandBuffer::SignalQuery(unsigned query_id,
                                          const base::Closure& callback) {
   CheckSequencedThread();
   QueueTask(base::Bind(&InProcessCommandBuffer::SignalQueryOnGpuThread,
                        base::Unretained(this),
                        query_id,
                        WrapCallback(callback)));
 }
@@ skipping 81 matching lines @@
 
 #if defined(OS_ANDROID)
 scoped_refptr<gfx::SurfaceTexture>
 InProcessCommandBuffer::GetSurfaceTexture(uint32 stream_id) {
   DCHECK(stream_texture_manager_);
   return stream_texture_manager_->GetSurfaceTexture(stream_id);
 }
 #endif
 
 }  // namespace gpu