Implemented new fence syncs which replaces the old sync points.

gpu/command_buffer/service/in_process_command_buffer.cc

Index: gpu/command_buffer/service/in_process_command_buffer.cc
diff --git a/gpu/command_buffer/service/in_process_command_buffer.cc b/gpu/command_buffer/service/in_process_command_buffer.cc
index 9711aad60051632cd5b488da0e7a67afb1e9900a..01d48d46ee8c028d8ce7597c4a43da78625ab582 100644
--- a/gpu/command_buffer/service/in_process_command_buffer.cc
+++ b/gpu/command_buffer/service/in_process_command_buffer.cc
@@ -19,6 +19,7 @@
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "gpu/command_buffer/client/gpu_memory_buffer_manager.h"
+#include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/value_state.h"
 #include "gpu/command_buffer/service/command_buffer_service.h"
 #include "gpu/command_buffer/service/context_group.h"
@@ -182,8 +183,11 @@ InProcessCommandBuffer::InProcessCommandBuffer(
       image_factory_(nullptr),
       last_put_offset_(-1),
       gpu_memory_buffer_manager_(nullptr),
+      next_fence_sync_release_(1),
+      flushed_fence_sync_release_(0),
       flush_event_(false, false),
       service_(GetInitialService(service)),
+      fence_sync_wait_event_(false, false),
       gpu_thread_weak_ptr_factory_(this) {
   DCHECK(service_.get());
   next_image_id_.GetNext();
@@ -413,6 +417,12 @@ bool InProcessCommandBuffer::InitializeOnGpuThread(
   decoder_->SetWaitSyncPointCallback(
       base::Bind(&InProcessCommandBuffer::WaitSyncPointOnGpuThread,
                  base::Unretained(this)));
+  decoder_->SetFenceSyncReleaseCallback(
+      base::Bind(&InProcessCommandBuffer::FenceSyncReleaseOnGpuThread,
+                 base::Unretained(this)));
+  decoder_->SetWaitFenceSyncCallback(
+      base::Bind(&InProcessCommandBuffer::WaitFenceSyncOnGpuThread,
+                 base::Unretained(this)));
 
   image_factory_ = params.image_factory;
 
@@ -559,6 +569,8 @@ void InProcessCommandBuffer::Flush(int32 put_offset) {
                                   put_offset,
                                   order_num);
   QueueTask(task);
+
+  flushed_fence_sync_release_ = next_fence_sync_release_ - 1;
 }
 
 void InProcessCommandBuffer::OrderingBarrier(int32 put_offset) {
@@ -797,8 +809,18 @@ void InProcessCommandBuffer::RetireSyncPointOnGpuThread(uint32 sync_point) {
       base::AutoLock lock(command_buffer_lock_);
       make_current_success = MakeCurrent();
     }
-    if (make_current_success)
-      mailbox_manager->PushTextureUpdates(sync_point);
+    if (make_current_success) {
+      // Old sync points are global and do not have a command buffer ID,
+      // We can simply use the GPUIO namespace with 0 for the command buffer ID
+      // (under normal circumstances 0 is  invalid so  will not be used) until
+      // the old sync points are replaced.
+      gles2::SyncToken sync_token = {
+        gpu::CommandBufferNamespace::GPU_IO,
+        0,
+        sync_point
+      };
+      mailbox_manager->PushTextureUpdates(sync_token);
+    }
   }
   service_->sync_point_manager()->RetireSyncPoint(sync_point);
 }
@@ -816,7 +838,75 @@ bool InProcessCommandBuffer::WaitSyncPointOnGpuThread(unsigned sync_point) {
   service_->sync_point_manager()->WaitSyncPoint(sync_point);
   gles2::MailboxManager* mailbox_manager =
       decoder_->GetContextGroup()->mailbox_manager();
-  mailbox_manager->PullTextureUpdates(sync_point);
+  // Old sync points are global and do not have a command buffer ID,
+  // We can simply use the GPUIO namespace with 0 for the command buffer ID
+  // (under normal circumstances 0 is  invalid so  will not be used) until
+  // the old sync points are replaced.
+  gles2::SyncToken sync_token = {
+    gpu::CommandBufferNamespace::GPU_IO,
+    0,
+    sync_point
+  };
+  mailbox_manager->PullTextureUpdates(sync_token);
+  return true;
+}
+
+void InProcessCommandBuffer::FenceSyncReleaseOnGpuThread(uint32_t release) {
+  if (!sync_point_client_state_->IsFenceSyncReleased(release)) {
+    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) {
+        gles2::SyncToken sync_token = {
+          GetNamespaceID(),
+          GetCommandBufferID(),
+          release
+        };
+        mailbox_manager->PushTextureUpdates(sync_token);
+      }
+    }
+
+    sync_point_client_->ReleaseFenceSync(release);
+  }
+}
+
+bool InProcessCommandBuffer::WaitFenceSyncOnGpuThread(
+    gpu::CommandBufferNamespace namespace_id,
+    uint64_t command_buffer_id,
+    uint32_t release) {
+  gpu::SyncPointManager* sync_point_manager = service_->sync_point_manager();
+  DCHECK(sync_point_manager);
+
+  scoped_refptr<gpu::SyncPointClientState> release_state =
+      sync_point_manager->GetSyncPointClientState(namespace_id,
+                                                  command_buffer_id);
+
+  if (!release_state.get())

[dcheng, 2015/09/28 07:39:33]

No .get()

[David Yen, 2015/09/28 17:38:18]

Done.

+    return true;
+
+  if (!release_state->IsFenceSyncReleased(release)) {
+    // Use waitable event which is signalled when the release fence is released.
+    sync_point_client_->Wait(
+        release_state,
+        release,
+        base::Bind(&base::WaitableEvent::Signal,
+                   base::Unretained(&fence_sync_wait_event_)));
+    fence_sync_wait_event_.Wait();
+  }
+
+  gles2::MailboxManager* mailbox_manager =
+      decoder_->GetContextGroup()->mailbox_manager();
+  gles2::SyncToken sync_token = {
+    namespace_id,
+    command_buffer_id,
+    release
+  };
+  mailbox_manager->PullTextureUpdates(sync_token);
   return true;
 }
 
@@ -880,6 +970,18 @@ uint64_t InProcessCommandBuffer::GetCommandBufferID() const {
   return command_buffer_id_;
 }
 
+uint32_t InProcessCommandBuffer::GenerateFenceSyncRelease() {
+  return next_fence_sync_release_++;
+}
+
+bool InProcessCommandBuffer::IsFenceSyncRelease(uint32_t release) {
+  return release != 0 && release < next_fence_sync_release_;
+}
+
+bool InProcessCommandBuffer::IsFenceSyncFlushed(uint32_t release) {
+  return release <= flushed_fence_sync_release_;
+}
+
 uint32 InProcessCommandBuffer::CreateStreamTextureOnGpuThread(
     uint32 client_texture_id) {
 #if defined(OS_ANDROID)