Implemented new fence syncs which replaces the old sync points.

content/common/gpu/gpu_command_buffer_stub.cc

 // 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.
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/hash.h"
 #include "base/json/json_writer.h"
 #include "base/memory/shared_memory.h"
@@ skipping 528 matching lines @@
 
   gpu::SyncPointManager* sync_point_manager = manager->sync_point_manager();
   DCHECK(sync_point_manager);
 
   decoder_.reset(::gpu::gles2::GLES2Decoder::Create(context_group_.get()));
   scheduler_.reset(new gpu::GpuScheduler(command_buffer_.get(),
                                          decoder_.get(),
                                          decoder_.get()));
   sync_point_client_ =
       sync_point_manager->CreateSyncPointClient(
-          channel_->GetSyncPointClientState(),
+          channel_->GetSyncPointOrderData(),
           gpu::CommandBufferNamespace::GPU_IO,
           command_buffer_id_);
 
   if (preemption_flag_.get())
     scheduler_->SetPreemptByFlag(preemption_flag_);
 
   decoder_->set_engine(scheduler_.get());
 
   if (!handle_.is_null()) {
     surface_ = ImageTransportSurface::CreateSurface(
@@ skipping 86 matching lines @@
 
   decoder_->GetLogger()->SetMsgCallback(
       base::Bind(&GpuCommandBufferStub::SendConsoleMessage,
                  base::Unretained(this)));
   decoder_->SetShaderCacheCallback(
       base::Bind(&GpuCommandBufferStub::SendCachedShader,
                  base::Unretained(this)));
   decoder_->SetWaitSyncPointCallback(
       base::Bind(&GpuCommandBufferStub::OnWaitSyncPoint,
                  base::Unretained(this)));
+  decoder_->SetFenceSyncReleaseCallback(base::Bind(
+      &GpuCommandBufferStub::OnFenceSyncRelease, base::Unretained(this)));
+  decoder_->SetWaitFenceSyncCallback(base::Bind(
+      &GpuCommandBufferStub::OnWaitFenceSync, base::Unretained(this)));
 
   command_buffer_->SetPutOffsetChangeCallback(
       base::Bind(&GpuCommandBufferStub::PutChanged, base::Unretained(this)));
   command_buffer_->SetGetBufferChangeCallback(
       base::Bind(&gpu::GpuScheduler::SetGetBuffer,
                  base::Unretained(scheduler_.get())));
   command_buffer_->SetParseErrorCallback(
       base::Bind(&GpuCommandBufferStub::OnParseError, base::Unretained(this)));
   scheduler_->SetSchedulingChangedCallback(base::Bind(
       &GpuCommandBufferStub::OnSchedulingChanged, base::Unretained(this)));
@@ skipping 269 matching lines @@
   if (retire)
     OnRetireSyncPoint(sync_point);
 }
 
 void GpuCommandBufferStub::OnRetireSyncPoint(uint32 sync_point) {
   DCHECK(!sync_points_.empty() && sync_points_.front() == sync_point);
   sync_points_.pop_front();
 
   gpu::gles2::MailboxManager* mailbox_manager =
       context_group_->mailbox_manager();
-  if (mailbox_manager->UsesSync() && MakeCurrent())
-    mailbox_manager->PushTextureUpdates(sync_point);
+  if (mailbox_manager->UsesSync() && MakeCurrent()) {
+    // Old sync points are global and do not have a command buffer ID,
+    // We can simply use the global sync point number as the release count 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.
+    gpu::gles2::SyncToken sync_token = {
+      gpu::CommandBufferNamespace::GPU_IO,
+      0,
+      sync_point
+    };
+    mailbox_manager->PushTextureUpdates(sync_token);
+  }
 
   GpuChannelManager* manager = channel_->gpu_channel_manager();
   manager->sync_point_manager()->RetireSyncPoint(sync_point);
 }
 
 bool GpuCommandBufferStub::OnWaitSyncPoint(uint32 sync_point) {
   DCHECK(!waiting_for_sync_point_);
   DCHECK(scheduler_->scheduled());
   if (!sync_point)
     return true;
   GpuChannelManager* manager = channel_->gpu_channel_manager();
   if (manager->sync_point_manager()->IsSyncPointRetired(sync_point)) {
-    PullTextureUpdates(sync_point);
+    // Old sync points are global and do not have a command buffer ID,
+    // We can simply use the global sync point number as the release count 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.
+    PullTextureUpdates(gpu::CommandBufferNamespace::GPU_IO, 0, sync_point);
     return true;
   }
 
   TRACE_EVENT_ASYNC_BEGIN1("gpu", "WaitSyncPoint", this, "GpuCommandBufferStub",
                            this);
 
   scheduler_->SetScheduled(false);
   waiting_for_sync_point_ = true;
   manager->sync_point_manager()->AddSyncPointCallback(
       sync_point,
       base::Bind(&RunOnThread, task_runner_,
                  base::Bind(&GpuCommandBufferStub::OnWaitSyncPointCompleted,
                             this->AsWeakPtr(), sync_point)));
   return !waiting_for_sync_point_;
 }
 
 void GpuCommandBufferStub::OnWaitSyncPointCompleted(uint32 sync_point) {
   DCHECK(waiting_for_sync_point_);
   DCHECK(!scheduler_->scheduled());
   TRACE_EVENT_ASYNC_END1("gpu", "WaitSyncPoint", this, "GpuCommandBufferStub",
                          this);
-  PullTextureUpdates(sync_point);
+  // Old sync points are global and do not have a command buffer ID,
+  // We can simply use the global sync point number as the release count 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.
+  PullTextureUpdates(gpu::CommandBufferNamespace::GPU_IO, 0, sync_point);
   waiting_for_sync_point_ = false;
   scheduler_->SetScheduled(true);
 }
 
-void GpuCommandBufferStub::PullTextureUpdates(uint32 sync_point) {
+void GpuCommandBufferStub::PullTextureUpdates(
+    gpu::CommandBufferNamespace namespace_id,
+    uint64_t command_buffer_id,
+    uint32_t release) {
   gpu::gles2::MailboxManager* mailbox_manager =
       context_group_->mailbox_manager();
-  if (mailbox_manager->UsesSync() && MakeCurrent())
-    mailbox_manager->PullTextureUpdates(sync_point);
+  if (mailbox_manager->UsesSync() && MakeCurrent()) {
+    gpu::gles2::SyncToken sync_token = {
+      namespace_id,
+      command_buffer_id,
+      release
+    };
+    mailbox_manager->PullTextureUpdates(sync_token);
+  }
 }
 
 void GpuCommandBufferStub::OnSignalSyncPoint(uint32 sync_point, uint32 id) {
   GpuChannelManager* manager = channel_->gpu_channel_manager();
   manager->sync_point_manager()->AddSyncPointCallback(
       sync_point,
       base::Bind(&RunOnThread, task_runner_,
                  base::Bind(&GpuCommandBufferStub::OnSignalSyncPointAck,
                             this->AsWeakPtr(), id)));
 }
@@ skipping 14 matching lines @@
                      this->AsWeakPtr(),
                      id));
         return;
       }
     }
   }
   // Something went wrong, run callback immediately.
   OnSignalSyncPointAck(id);
 }
 
+void GpuCommandBufferStub::OnFenceSyncRelease(uint64_t release) {
+  if (sync_point_client_->client_state()->IsFenceSyncReleased(release)) {
+    DLOG(ERROR) << "Fence Sync has already been released.";
+    return;
+  }
+
+  gpu::gles2::MailboxManager* mailbox_manager =
+      context_group_->mailbox_manager();
+  if (mailbox_manager->UsesSync() && MakeCurrent()) {
+    gpu::gles2::SyncToken sync_token = {
+      gpu::CommandBufferNamespace::GPU_IO,
+      command_buffer_id_,
+      release
+    };
+    mailbox_manager->PushTextureUpdates(sync_token);
+  }
+
+  sync_point_client_->ReleaseFenceSync(release);
+}
+
+bool GpuCommandBufferStub::OnWaitFenceSync(
+    gpu::CommandBufferNamespace namespace_id,
+    uint64_t command_buffer_id,
+    uint64_t release) {
+  DCHECK(!waiting_for_sync_point_);
+  DCHECK(scheduler_->scheduled());
+
+  GpuChannelManager* manager = channel_->gpu_channel_manager();
+  DCHECK(manager);
+
+  gpu::SyncPointManager* sync_point_manager = manager->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)
+    return true;
+
+  if (release_state->IsFenceSyncReleased(release)) {
+    PullTextureUpdates(namespace_id, command_buffer_id, release);
+    return true;
+  }
+
+  TRACE_EVENT_ASYNC_BEGIN1("gpu", "WaitFenceSync", this,
+                           "GpuCommandBufferStub", this);
+  scheduler_->SetScheduled(false);
+  waiting_for_sync_point_ = true;
+  sync_point_client_->WaitNonThreadSafe(
+      release_state,
+      release,
+      task_runner_,
+      base::Bind(&GpuCommandBufferStub::OnWaitFenceSyncCompleted,
+                 this->AsWeakPtr(), namespace_id, command_buffer_id, release));
+
+  return scheduler_->scheduled();
+}
+
+void GpuCommandBufferStub::OnWaitFenceSyncCompleted(
+    gpu::CommandBufferNamespace namespace_id,
+    uint64_t command_buffer_id,
+    uint64_t release) {
+  DCHECK(waiting_for_sync_point_);
+  DCHECK(!scheduler_->scheduled());
+  TRACE_EVENT_ASYNC_END1("gpu", "WaitFenceSync", this, "GpuCommandBufferStub",
+                           this);
+  PullTextureUpdates(namespace_id, command_buffer_id, release);
+  waiting_for_sync_point_ = false;
+  scheduler_->SetScheduled(true);
+}
 
 void GpuCommandBufferStub::OnSetClientHasMemoryAllocationChangedCallback(
     bool has_callback) {
   TRACE_EVENT0(
       "gpu",
       "GpuCommandBufferStub::OnSetClientHasMemoryAllocationChangedCallback");
   if (has_callback) {
     if (!memory_manager_client_state_) {
       memory_manager_client_state_.reset(
           GetMemoryManager()->CreateClientState(this, !offscreen_, true));
@@ skipping 183 matching lines @@
                                                     result));
 }
 
 void GpuCommandBufferStub::SendUpdateVSyncParameters(base::TimeTicks timebase,
                                                      base::TimeDelta interval) {
   Send(new GpuCommandBufferMsg_UpdateVSyncParameters(route_id_, timebase,
                                                      interval));
 }
 
 }  // namespace content