gpu: Add SequenceId for identifying sync point sequences.

gpu/command_buffer/tests/gl_manager.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 "gpu/command_buffer/tests/gl_manager.h"
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
 #include <stddef.h>
@@ skipping 37 matching lines @@
 #include "ui/gl/init/gl_factory.h"
 
 #if defined(OS_MACOSX)
 #include "ui/gfx/mac/io_surface.h"
 #include "ui/gl/gl_image_io_surface.h"
 #endif
 
 namespace gpu {
 namespace {
 
-uint64_t g_next_command_buffer_id = 0;
+uint64_t g_next_command_buffer_id = 1;
 
 void InitializeGpuPreferencesForTestingFromCommandLine(
     const base::CommandLine& command_line,
     GpuPreferences* preferences) {
   // Only initialize specific GpuPreferences members used for testing.
   preferences->use_passthrough_cmd_decoder =
       command_line.HasSwitch(switches::kUsePassthroughCmdDecoder);
 }
 
 class GpuMemoryBufferImpl : public gfx::GpuMemoryBuffer {
@@ skipping 273 matching lines @@
 
   ASSERT_TRUE(context_->MakeCurrent(surface_.get()));
 
   if (!decoder_->Initialize(surface_.get(), context_.get(), true,
                             ::gpu::gles2::DisallowedFeatures(), attribs)) {
     return;
   }
 
   if (options.sync_point_manager) {
     sync_point_manager_ = options.sync_point_manager;
-    sync_point_order_data_ = SyncPointOrderData::Create();
-    sync_point_client_ = base::MakeUnique<SyncPointClient>(
-        sync_point_manager_, sync_point_order_data_, GetNamespaceID(),
-        GetCommandBufferID());
+    sync_point_order_data_ = sync_point_manager_->CreateSyncPointOrderData();
+    sync_point_client_state_ = sync_point_manager_->CreateSyncPointClientState(
+        GetNamespaceID(), GetCommandBufferID(),
+        sync_point_order_data_->sequence_id());
 
     decoder_->SetFenceSyncReleaseCallback(
         base::Bind(&GLManager::OnFenceSyncRelease, base::Unretained(this)));
     decoder_->SetWaitSyncTokenCallback(
         base::Bind(&GLManager::OnWaitSyncToken, base::Unretained(this)));
   } else {
     sync_point_manager_ = nullptr;
     sync_point_order_data_ = nullptr;
-    sync_point_client_ = nullptr;
+    sync_point_client_state_ = nullptr;
   }
 
   command_buffer_->SetPutOffsetChangeCallback(
       base::Bind(&GLManager::PumpCommands, base::Unretained(this)));
   command_buffer_->SetGetBufferChangeCallback(
       base::Bind(&GLManager::GetBufferChanged, base::Unretained(this)));
 
   // Create the GLES2 helper, which writes the command buffer protocol.
   gles2_helper_.reset(new gles2::GLES2CmdHelper(command_buffer_.get()));
   ASSERT_TRUE(gles2_helper_->Initialize(kCommandBufferSize));
@@ skipping 27 matching lines @@
         gl::init::CreateOffscreenGLSurface(size));
     base_context_ = new scoped_refptr<gl::GLContext>(gl::init::CreateGLContext(
         base_share_group_->get(), base_surface_->get(),
         gl::GLContextAttribs()));
     #endif
   }
   ++use_count_;
 }
 
 void GLManager::OnFenceSyncRelease(uint64_t release) {
-  DCHECK(sync_point_client_);
+  DCHECK(sync_point_client_state_);
   command_buffer_->SetReleaseCount(release);
-  sync_point_client_->ReleaseFenceSync(release);
+  sync_point_client_state_->ReleaseFenceSync(release);
 }
 
 bool GLManager::OnWaitSyncToken(const SyncToken& sync_token) {
   DCHECK(sync_point_manager_);
   // GLManager does not support being multithreaded at this point, so the fence
   // sync must be released by the time wait is called.
   DCHECK(sync_point_manager_->IsSyncTokenReleased(sync_token));
   return false;
 }
 
@@ skipping 13 matching lines @@
   if (gles2_implementation_.get()) {
     MakeCurrent();
     EXPECT_TRUE(glGetError() == GL_NONE);
     gles2_implementation_->Flush();
     gles2_implementation_.reset();
   }
   transfer_buffer_.reset();
   gles2_helper_.reset();
   command_buffer_.reset();
   sync_point_manager_ = nullptr;
-  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;
+  }
   if (decoder_.get()) {
     bool have_context = decoder_->GetGLContext() &&
                         decoder_->GetGLContext()->MakeCurrent(surface_.get());
     decoder_->Destroy(have_context);
     decoder_.reset();
   }
 }
 
 const GpuDriverBugWorkarounds& GLManager::workarounds() const {
   return decoder_->GetContextGroup()->feature_info()->workarounds();
 }
 
 void GLManager::PumpCommands() {
   if (!decoder_->MakeCurrent()) {
     command_buffer_->SetContextLostReason(decoder_->GetContextLostReason());
     command_buffer_->SetParseError(::gpu::error::kLostContext);
     return;
   }
   uint32_t order_num = 0;
   if (sync_point_manager_) {
     // If sync point manager is supported, assign order numbers to commands.
     if (paused_order_num_) {
       // Was previous paused, continue to process the order number.
       order_num = paused_order_num_;
       paused_order_num_ = 0;
     } else {
-      order_num = sync_point_order_data_->GenerateUnprocessedOrderNumber(
-          sync_point_manager_);
+      order_num = sync_point_order_data_->GenerateUnprocessedOrderNumber();
     }
     sync_point_order_data_->BeginProcessingOrderNumber(order_num);
   }
 
   if (pause_commands_) {
     // Do not process commands, simply store the current order number.
     paused_order_num_ = order_num;
 
     sync_point_order_data_->PauseProcessingOrderNumber(order_num);
     return;
@@ skipping 112 matching lines @@
 }
 
 bool GLManager::IsFenceSyncReleased(uint64_t release) {
   return release <= command_buffer_->GetLastState().release_count;
 }
 
 void GLManager::SignalSyncToken(const gpu::SyncToken& sync_token,
                                 const base::Closure& callback) {
   if (sync_point_manager_) {
     DCHECK(!paused_order_num_);
-    uint32_t order_num = sync_point_order_data_->GenerateUnprocessedOrderNumber(
-        sync_point_manager_);
+    uint32_t order_num =
+        sync_point_order_data_->GenerateUnprocessedOrderNumber();
     sync_point_order_data_->BeginProcessingOrderNumber(order_num);
-    if (!sync_point_client_->Wait(sync_token, callback))
+    if (!sync_point_client_state_->Wait(sync_token, callback))
       callback.Run();
     sync_point_order_data_->FinishProcessingOrderNumber(order_num);
   } else {
     callback.Run();
   }
 }
 
 void GLManager::WaitSyncTokenHint(const gpu::SyncToken& sync_token) {}
 
 bool GLManager::CanWaitUnverifiedSyncToken(const gpu::SyncToken& sync_token) {
   return false;
 }
 
 }  // namespace gpu