gpu: Implement the new fence syncs in mojo command buffer.

components/mus/gles2/command_buffer_driver.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 "components/mus/gles2/command_buffer_driver.h"
 
+#include "base/atomic_sequence_num.h"
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/shared_memory.h"
 #include "base/process/process_handle.h"
 #include "components/mus/gles2/command_buffer_type_conversions.h"
 #include "components/mus/gles2/gpu_memory_tracker.h"
 #include "components/mus/gles2/gpu_state.h"
 #include "components/mus/gles2/mojo_buffer_backing.h"
 #include "gpu/command_buffer/common/value_state.h"
 #include "gpu/command_buffer/service/command_buffer_service.h"
@@ skipping 11 matching lines @@
 #include "mojo/platform_handle/platform_handle_functions.h"
 #include "ui/gfx/buffer_format_util.h"
 #include "ui/gfx/gpu_memory_buffer.h"
 #include "ui/gfx/vsync_provider.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_image_shared_memory.h"
 #include "ui/gl/gl_surface.h"
 
 namespace mus {
 
+namespace {
+
+base::StaticAtomicSequenceNumber g_next_command_buffer_id;
+
+}
+
 CommandBufferDriver::Client::~Client() {}
 
 CommandBufferDriver::CommandBufferDriver(scoped_refptr<GpuState> gpu_state)
-    : client_(nullptr), gpu_state_(gpu_state), weak_factory_(this) {}
+    : command_buffer_id_(g_next_command_buffer_id.GetNext()),
+      client_(nullptr),
+      gpu_state_(gpu_state),
+      weak_factory_(this) {}
 
 CommandBufferDriver::~CommandBufferDriver() {
   DestroyDecoder();
 }
 
 void CommandBufferDriver::Initialize(
     mojo::InterfacePtrInfo<mojom::CommandBufferSyncClient> sync_client,
     mojo::InterfacePtrInfo<mojom::CommandBufferLostContextObserver>
         loss_observer,
     mojo::ScopedSharedBufferHandle shared_state,
     mojo::Array<int32_t> attribs) {
   sync_client_ = mojo::MakeProxy(sync_client.Pass());
   loss_observer_ = mojo::MakeProxy(loss_observer.Pass());
   bool success = DoInitialize(shared_state.Pass(), attribs.Pass());
   mojom::GpuCapabilitiesPtr capabilities =
       success ? mojom::GpuCapabilities::From(decoder_->GetCapabilities())
               : nullptr;
-  sync_client_->DidInitialize(success, capabilities.Pass());
+  sync_client_->DidInitialize(success,
+                              gpu::CommandBufferNamespace::MOJO,
+                              command_buffer_id_,
+                              capabilities.Pass());
 }
 
 bool CommandBufferDriver::MakeCurrent() {
   if (!decoder_)
     return false;
   if (decoder_->MakeCurrent())
     return true;
   DLOG(ERROR) << "Context lost because MakeCurrent failed.";
   gpu::error::ContextLostReason reason =
       static_cast<gpu::error::ContextLostReason>(
@@ skipping 36 matching lines @@
           nullptr, bind_generates_resource);
 
   command_buffer_.reset(
       new gpu::CommandBufferService(context_group->transfer_buffer_manager()));
   bool result = command_buffer_->Initialize();
   DCHECK(result);
 
   decoder_.reset(::gpu::gles2::GLES2Decoder::Create(context_group.get()));
   scheduler_.reset(new gpu::GpuScheduler(command_buffer_.get(), decoder_.get(),
                                          decoder_.get()));
+  sync_point_order_data_ = gpu::SyncPointOrderData::Create();
+  sync_point_client_ = gpu_state_->sync_point_manager()->CreateSyncPointClient(
+      sync_point_order_data_, gpu::CommandBufferNamespace::MOJO,
+      command_buffer_id_);
   decoder_->set_engine(scheduler_.get());
   decoder_->SetWaitSyncPointCallback(base::Bind(
       &CommandBufferDriver::OnWaitSyncPoint, base::Unretained(this)));
   decoder_->SetFenceSyncReleaseCallback(base::Bind(
       &CommandBufferDriver::OnFenceSyncRelease, base::Unretained(this)));
   decoder_->SetWaitFenceSyncCallback(base::Bind(
       &CommandBufferDriver::OnWaitFenceSync, base::Unretained(this)));
 
   gpu::gles2::DisallowedFeatures disallowed_features;
 
@@ skipping 166 matching lines @@
   if (gpu_state_->sync_point_manager()->IsSyncPointRetired(sync_point))
     return true;
   scheduler_->SetScheduled(false);
   gpu_state_->sync_point_manager()->AddSyncPointCallback(
       sync_point, base::Bind(&CommandBufferDriver::OnSyncPointRetired,
                              weak_factory_.GetWeakPtr()));
   return scheduler_->scheduled();
 }
 
 void CommandBufferDriver::OnFenceSyncRelease(uint64_t release) {
-  // TODO(dyen): Implement once CommandBufferID has been figured out and
-  // we have a SyncPointClient. It would probably look like what is commented
-  // out below:
-  // if (!sync_point_client_->client_state()->IsFenceSyncReleased(release))
-  //   sync_point_client_->ReleaseFenceSync(release);
-  NOTIMPLEMENTED();
+  if (!sync_point_client_->client_state()->IsFenceSyncReleased(release))
+    sync_point_client_->ReleaseFenceSync(release);
 }
 
 bool CommandBufferDriver::OnWaitFenceSync(
     gpu::CommandBufferNamespace namespace_id,
     uint64_t command_buffer_id,
     uint64_t release) {
   gpu::SyncPointManager* sync_point_manager = gpu_state_->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))
     return true;
 
-  // TODO(dyen): Implement once CommandBufferID has been figured out and
-  // we have a SyncPointClient. It would probably look like what is commented
-  // out below:
-  // scheduler_->SetScheduled(false);
-  // sync_point_client_->Wait(
-  //     release_state.get(),
-  //     release,
-  //     base::Bind(&CommandBufferDriver::OnSyncPointRetired,
-  //                weak_factory_.GetWeakPtr()));
-  NOTIMPLEMENTED();
+
+  scheduler_->SetScheduled(false);
+  sync_point_client_->Wait(
+      release_state.get(),
+      release,
+      base::Bind(&CommandBufferDriver::OnSyncPointRetired,
+                 weak_factory_.GetWeakPtr()));
   return scheduler_->scheduled();
 }
 
 void CommandBufferDriver::OnSyncPointRetired() {
   scheduler_->SetScheduled(true);
   gpu_state_->command_buffer_task_runner()->OnScheduled(this);
 }
 
 void CommandBufferDriver::OnContextLost(uint32_t reason) {
   loss_observer_->DidLoseContext(reason);
   client_->DidLoseContext();
 }
 
 void CommandBufferDriver::DestroyDecoder() {
   if (decoder_) {
     bool have_context = decoder_->MakeCurrent();
     decoder_->Destroy(have_context);
     decoder_.reset();
   }
 }
 
 }  // namespace mus