gpu: Allow waiting on sync tokens without sync token client.

gpu/command_buffer/tests/fuzzer_main.cc

 // Copyright 2016 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 <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <vector>
 
 #include "base/at_exit.h"
@@ skipping 70 matching lines @@
     "GL_OES_texture_float "
     "GL_OES_texture_float_linear "
     "GL_OES_texture_half_float "
     "GL_OES_texture_half_float_linear";
 #endif
 
 class CommandBufferSetup {
  public:
   CommandBufferSetup()
       : atexit_manager_(),
-        sync_point_manager_(new SyncPointManager(false)),
+        sync_point_manager_(new SyncPointManager()),
         sync_point_order_data_(SyncPointOrderData::Create()),
         mailbox_manager_(new gles2::MailboxManagerImpl),
         share_group_(new gl::GLShareGroup),
         command_buffer_id_(CommandBufferId::FromUnsafeValue(1)) {
     logging::SetMinLogLevel(logging::LOG_FATAL);
     base::CommandLine::Init(0, NULL);
 
 #if defined(GPU_FUZZER_USE_ANGLE)
     auto* command_line = base::CommandLine::ForCurrentProcess();
     command_line->AppendSwitchASCII(switches::kUseGL,
@@ skipping 11 matching lines @@
     surface_ = new gl::GLSurfaceStub;
     scoped_refptr<gl::GLContextStub> context_stub =
         new gl::GLContextStub(share_group_.get());
     context_stub->SetGLVersionString("OpenGL ES 3.1");
     context_stub->SetExtensionsString(kExtensions);
     context_stub->SetUseStubApi(true);
     context_ = context_stub;
     gl::GLSurfaceTestSupport::InitializeOneOffWithMockBindings();
 #endif
 
-    sync_point_client_ = sync_point_manager_->CreateSyncPointClient(
-        sync_point_order_data_, CommandBufferNamespace::IN_PROCESS,
-        command_buffer_id_);
+    sync_point_client_ = base::MakeUnique<SyncPointClient>(
+        sync_point_manager_.get(), sync_point_order_data_,
+        CommandBufferNamespace::IN_PROCESS, command_buffer_id_);
 
     translator_cache_ = new gles2::ShaderTranslatorCache(gpu_preferences_);
     completeness_cache_ = new gles2::FramebufferCompletenessCache;
   }
 
   void InitDecoder() {
     context_->MakeCurrent(surface_.get());
     scoped_refptr<gles2::FeatureInfo> feature_info =
         new gles2::FeatureInfo();
     scoped_refptr<gles2::ContextGroup> context_group = new gles2::ContextGroup(
         gpu_preferences_, mailbox_manager_.get(), nullptr, translator_cache_,
         completeness_cache_, feature_info, true /* bind_generates_resource */,
         nullptr /* image_factory */, nullptr /* progress_reporter */,
         GpuFeatureInfo());
     command_buffer_.reset(
         new CommandBufferService(context_group->transfer_buffer_manager()));
     command_buffer_->SetPutOffsetChangeCallback(
         base::Bind(&CommandBufferSetup::PumpCommands, base::Unretained(this)));
     command_buffer_->SetGetBufferChangeCallback(base::Bind(
         &CommandBufferSetup::GetBufferChanged, base::Unretained(this)));
     InitializeInitialCommandBuffer();
 
     decoder_.reset(gles2::GLES2Decoder::Create(context_group.get()));
     executor_.reset(new CommandExecutor(command_buffer_.get(), decoder_.get(),
                                         decoder_.get()));
     decoder_->set_engine(executor_.get());
     decoder_->SetFenceSyncReleaseCallback(base::Bind(
         &CommandBufferSetup::OnFenceSyncRelease, base::Unretained(this)));
-    decoder_->SetWaitFenceSyncCallback(base::Bind(
-        &CommandBufferSetup::OnWaitFenceSync, base::Unretained(this)));
+    decoder_->SetWaitSyncTokenCallback(base::Bind(
+        &CommandBufferSetup::OnWaitSyncToken, base::Unretained(this)));
     decoder_->GetLogger()->set_log_synthesized_gl_errors(false);
 
     gles2::ContextCreationAttribHelper attrib_helper;
     attrib_helper.offscreen_framebuffer_size = gfx::Size(16, 16);
     attrib_helper.red_size = 8;
     attrib_helper.green_size = 8;
     attrib_helper.blue_size = 8;
     attrib_helper.alpha_size = 8;
     attrib_helper.depth_size = 0;
     attrib_helper.stencil_size = 0;
@@ skipping 68 matching lines @@
 
   bool GetBufferChanged(int32_t transfer_buffer_id) {
     return executor_->SetGetBuffer(transfer_buffer_id);
   }
 
   void OnFenceSyncRelease(uint64_t release) {
     CHECK(sync_point_client_);
     sync_point_client_->ReleaseFenceSync(release);
   }
 
-  bool OnWaitFenceSync(CommandBufferNamespace namespace_id,
-                       CommandBufferId command_buffer_id,
-                       uint64_t release) {
-    CHECK(sync_point_client_);
-    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;
-
+  bool OnWaitSyncToken(const SyncToken& sync_token) {
+    CHECK(sync_point_manager_);
+    if (sync_point_manager_->IsSyncTokenReleased(sync_token))
+      return false;
     executor_->SetScheduled(false);
-    return false;
+    return true;
   }
 
   void CreateTransferBuffer(size_t size, int32_t id) {
     scoped_refptr<Buffer> buffer =
         command_buffer_->CreateTransferBufferWithId(size, id);
     memset(buffer->memory(), 0, size);
   }
 
   void InitializeInitialCommandBuffer() {
     buffer_id_ = 1;
@@ skipping 45 matching lines @@
 // registered, causing crashes.
 CommandBufferSetup* g_setup = new CommandBufferSetup();
 
 }  // anonymous namespace
 }  // namespace gpu
 
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
   gpu::g_setup->RunCommandBuffer(data, size);
   return 0;
 }