gpu: Add SequenceId for identifying sync point sequences.

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 71 matching lines @@
     "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()),
-        sync_point_order_data_(SyncPointOrderData::Create()),
+        sync_point_order_data_(sync_point_manager_->CreateSyncPointOrderData()),
         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,
                                     gl::kGLImplementationANGLEName);
@@ skipping 10 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_ = base::MakeUnique<SyncPointClient>(
-        sync_point_manager_.get(), sync_point_order_data_,
-        CommandBufferNamespace::IN_PROCESS, command_buffer_id_);
+    sync_point_client_state_ = sync_point_manager_->CreateSyncPointClientState(
+        CommandBufferNamespace::IN_PROCESS, command_buffer_id_,
+        sync_point_order_data_->sequence_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(
@@ skipping 44 matching lines @@
     }
   }
 
   void ResetDecoder() {
     decoder_->Destroy(true);
     decoder_.reset();
     command_buffer_.reset();
   }
 
   ~CommandBufferSetup() {
-    sync_point_client_ = nullptr;
     if (sync_point_order_data_) {
       sync_point_order_data_->Destroy();
       sync_point_order_data_ = nullptr;
     }
+    if (sync_point_client_state_) {
+      sync_point_client_state_->Destroy();
+      sync_point_client_state_ = nullptr;
+    }
   }
 
   void RunCommandBuffer(const uint8_t* data, size_t size) {
     // The commands are flushed at a uint32_t granularity. If the data is not
     // a full command, we zero-pad it.
     size_t padded_size = (size + 3) & ~3;
     // crbug.com/638836 The -max_len argument is sometimes not respected, so the
     // fuzzer may give us too much data. Bail ASAP in that case.
     if (padded_size > kCommandBufferSize)
       return;
@@ skipping 11 matching lines @@
   }
 
  private:
   void PumpCommands() {
     if (!decoder_->MakeCurrent()) {
       command_buffer_->SetContextLostReason(decoder_->GetContextLostReason());
       command_buffer_->SetParseError(::gpu::error::kLostContext);
       return;
     }
 
-    uint32_t order_num = sync_point_order_data_->GenerateUnprocessedOrderNumber(
-        sync_point_manager_.get());
+    uint32_t order_num =
+        sync_point_order_data_->GenerateUnprocessedOrderNumber();
     sync_point_order_data_->BeginProcessingOrderNumber(order_num);
 
     executor_->PutChanged();
 
     sync_point_order_data_->FinishProcessingOrderNumber(order_num);
   }
 
   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);
+    CHECK(sync_point_client_state_);
+    sync_point_client_state_->ReleaseFenceSync(release);
   }
 
   bool OnWaitSyncToken(const SyncToken& sync_token) {
     CHECK(sync_point_manager_);
     if (sync_point_manager_->IsSyncTokenReleased(sync_token))
       return false;
     executor_->SetScheduled(false);
     return true;
   }
 
@@ skipping 16 matching lines @@
     CreateTransferBuffer(kTransferBufferSize, 4);
     CreateTransferBuffer(kTinyTransferBufferSize, 5);
   }
 
   base::AtExitManager atexit_manager_;
 
   GpuPreferences gpu_preferences_;
 
   std::unique_ptr<SyncPointManager> sync_point_manager_;
   scoped_refptr<SyncPointOrderData> sync_point_order_data_;
-  std::unique_ptr<SyncPointClient> sync_point_client_;
+  scoped_refptr<SyncPointClientState> sync_point_client_state_;
   scoped_refptr<gles2::MailboxManager> mailbox_manager_;
   scoped_refptr<gl::GLShareGroup> share_group_;
   const gpu::CommandBufferId command_buffer_id_;
 
   scoped_refptr<gl::GLSurface> surface_;
   scoped_refptr<gl::GLContext> context_;
 
   scoped_refptr<gles2::ShaderTranslatorCache> translator_cache_;
   scoped_refptr<gles2::FramebufferCompletenessCache> completeness_cache_;
 
@@ skipping 16 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;
 }