gpu: Add SequenceId for identifying sync point sequences.

gpu/ipc/in_process_command_buffer.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 "gpu/ipc/in_process_command_buffer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <queue>
@@ skipping 162 matching lines @@
     program_cache_.reset(new gles2::MemoryProgramCache(
         gpu_preferences_.gpu_program_cache_size,
         disable_disk_cache,
         workarounds.disable_program_caching_for_transform_feedback));
   }
   return program_cache_.get();
 }
 
 InProcessCommandBuffer::InProcessCommandBuffer(
     const scoped_refptr<Service>& service)
-    : command_buffer_id_(
-          CommandBufferId::FromUnsafeValue(g_next_command_buffer_id.GetNext())),
+    : command_buffer_id_(CommandBufferId::FromUnsafeValue(
+          g_next_command_buffer_id.GetNext() + 1)),
       delayed_work_pending_(false),
       image_factory_(nullptr),
       gpu_control_client_(nullptr),
 #if DCHECK_IS_ON()
       context_lost_(false),
 #endif
       last_put_offset_(-1),
       gpu_memory_buffer_manager_(nullptr),
       next_fence_sync_release_(1),
       flushed_fence_sync_release_(0),
@@ skipping 145 matching lines @@
       }
     }
   }
 
   if (!surface_.get()) {
     LOG(ERROR) << "Could not create GLSurface.";
     DestroyOnGpuThread();
     return false;
   }
 
-  sync_point_order_data_ = SyncPointOrderData::Create();
-  sync_point_client_ = base::MakeUnique<SyncPointClient>(
-      service_->sync_point_manager(), sync_point_order_data_, GetNamespaceID(),
-      GetCommandBufferID());
+  sync_point_order_data_ =
+      service_->sync_point_manager()->CreateSyncPointOrderData();
+  sync_point_client_state_ =
+      service_->sync_point_manager()->CreateSyncPointClientState(
+          GetNamespaceID(), GetCommandBufferID(),
+          sync_point_order_data_->sequence_id());
 
   if (service_->UseVirtualizedGLContexts() ||
       decoder_->GetContextGroup()
           ->feature_info()
           ->workarounds()
           .use_virtualized_gl_contexts) {
     context_ = gl_share_group_->GetSharedContext(surface_.get());
     if (!context_.get()) {
       context_ = gl::init::CreateGLContext(
           gl_share_group_.get(), surface_.get(),
@@ skipping 88 matching lines @@
   gpu_thread_weak_ptr_factory_.InvalidateWeakPtrs();
   command_buffer_.reset();
   // Clean up GL resources if possible.
   bool have_context = context_.get() && context_->MakeCurrent(surface_.get());
   if (decoder_) {
     decoder_->Destroy(have_context);
     decoder_.reset();
   }
   context_ = nullptr;
   surface_ = 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;
+  }
   gl_share_group_ = nullptr;
   context_group_ = nullptr;
 
   base::AutoLock lock(task_queue_lock_);
   std::queue<std::unique_ptr<GpuTask>> empty;
   task_queue_.swap(empty);
 
   return true;
 }
 
@@ skipping 23 matching lines @@
 }
 
 void InProcessCommandBuffer::QueueTask(bool out_of_order,
                                        const base::Closure& task) {
   if (out_of_order) {
     service_->ScheduleTask(task);
     return;
   }
   // Release the |task_queue_lock_| before calling ScheduleTask because
   // the callback may get called immediately and attempt to acquire the lock.
-  SyncPointManager* sync_manager = service_->sync_point_manager();
-  uint32_t order_num =
-      sync_point_order_data_->GenerateUnprocessedOrderNumber(sync_manager);
+  uint32_t order_num = sync_point_order_data_->GenerateUnprocessedOrderNumber();
   {
     base::AutoLock lock(task_queue_lock_);
     task_queue_.push(base::MakeUnique<GpuTask>(task, order_num));
   }
   service_->ScheduleTask(base::Bind(
       &InProcessCommandBuffer::ProcessTasksOnGpuThread, gpu_thread_weak_ptr_));
 }
 
 void InProcessCommandBuffer::ProcessTasksOnGpuThread() {
   while (executor_->scheduled()) {
@@ skipping 272 matching lines @@
         LOG(ERROR) << "Failed to create image for buffer.";
         return;
       }
 
       image_manager->AddImage(image.get(), id);
       break;
     }
   }
 
   if (fence_sync)
-    sync_point_client_->ReleaseFenceSync(fence_sync);
+    sync_point_client_state_->ReleaseFenceSync(fence_sync);
 }
 
 void InProcessCommandBuffer::DestroyImage(int32_t id) {
   CheckSequencedThread();
 
   QueueTask(false, base::Bind(&InProcessCommandBuffer::DestroyImageOnGpuThread,
                               base::Unretained(this), id));
 }
 
 void InProcessCommandBuffer::DestroyImageOnGpuThread(int32_t id) {
@@ skipping 11 matching lines @@
 }
 
 void InProcessCommandBuffer::FenceSyncReleaseOnGpuThread(uint64_t release) {
   SyncToken sync_token(GetNamespaceID(), GetExtraCommandBufferData(),
                        GetCommandBufferID(), release);
 
   gles2::MailboxManager* mailbox_manager =
       decoder_->GetContextGroup()->mailbox_manager();
   mailbox_manager->PushTextureUpdates(sync_token);
 
-  sync_point_client_->ReleaseFenceSync(release);
+  sync_point_client_state_->ReleaseFenceSync(release);
 }
 
 bool InProcessCommandBuffer::WaitSyncTokenOnGpuThread(
     const SyncToken& sync_token) {
   DCHECK(!waiting_for_sync_point_);
   gpu::SyncPointManager* sync_point_manager = service_->sync_point_manager();
   DCHECK(sync_point_manager);
 
   gles2::MailboxManager* mailbox_manager =
       decoder_->GetContextGroup()->mailbox_manager();
   DCHECK(mailbox_manager);
 
   if (service_->BlockThreadOnWaitSyncToken()) {
     // Wait if sync point wait is valid.
-    if (sync_point_client_->Wait(
+    if (sync_point_client_state_->Wait(
             sync_token,
             base::Bind(&base::WaitableEvent::Signal,
                        base::Unretained(&fence_sync_wait_event_)))) {
       fence_sync_wait_event_.Wait();
     }
 
     mailbox_manager->PullTextureUpdates(sync_token);
     return false;
   }
 
-  waiting_for_sync_point_ = sync_point_client_->Wait(
+  waiting_for_sync_point_ = sync_point_client_state_->Wait(
       sync_token,
       base::Bind(&InProcessCommandBuffer::OnWaitSyncTokenCompleted,
                  gpu_thread_weak_ptr_factory_.GetWeakPtr(), sync_token));
   if (!waiting_for_sync_point_) {
     mailbox_manager->PullTextureUpdates(sync_token);
     return false;
   }
 
   executor_->SetScheduled(false);
   return true;
@@ skipping 25 matching lines @@
     DCHECK(!executor_->scheduled());
 
     executor_->SetScheduled(true);
     ProcessTasksOnGpuThread();
   }
 }
 
 void InProcessCommandBuffer::SignalSyncTokenOnGpuThread(
     const SyncToken& sync_token,
     const base::Closure& callback) {
-  if (!sync_point_client_->Wait(sync_token, WrapCallback(callback)))
+  if (!sync_point_client_state_->Wait(sync_token, WrapCallback(callback)))
     callback.Run();
 }
 
 void InProcessCommandBuffer::SignalQuery(unsigned query_id,
                                          const base::Closure& callback) {
   CheckSequencedThread();
   QueueTask(false, base::Bind(&InProcessCommandBuffer::SignalQueryOnGpuThread,
                               base::Unretained(this), query_id,
                               WrapCallback(callback)));
 }
@@ skipping 201 matching lines @@
   return wrapped_callback;
 }
 
 InProcessCommandBuffer::GpuTask::GpuTask(const base::Closure& callback,
                                          uint32_t order_number)
     : callback(callback), order_number(order_number) {}
 
 InProcessCommandBuffer::GpuTask::~GpuTask() {}
 
 }  // namespace gpu