Added an extra sync token field for extra command buffer identification.

gpu/command_buffer/service/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/command_buffer/service/in_process_command_buffer.h"
 
 #include <queue>
 #include <set>
 #include <utility>
 
@@ skipping 688 matching lines @@
     DCHECK_EQ(fence_sync - 1, flushed_fence_sync_release_);
   }
 
   QueueTask(base::Bind(&InProcessCommandBuffer::CreateImageOnGpuThread,
                        base::Unretained(this), new_id, handle,
                        gfx::Size(width, height), gpu_memory_buffer->GetFormat(),
                        internalformat, order_num, fence_sync));
 
   if (fence_sync) {
     flushed_fence_sync_release_ = fence_sync;
-    SyncToken sync_token(GetNamespaceID(), GetCommandBufferID(), fence_sync);
+    SyncToken sync_token(GetNamespaceID(), GetExtraCommandBufferData(),
+                         GetCommandBufferID(), fence_sync);
     sync_token.SetVerifyFlush();
     gpu_memory_buffer_manager_->SetDestructionSyncToken(gpu_memory_buffer,
                                                         sync_token);
   }
 
   return new_id;
 }
 
 void InProcessCommandBuffer::CreateImageOnGpuThread(
     int32 id,
@@ skipping 125 matching lines @@
     bool make_current_success = false;
     {
       base::AutoLock lock(command_buffer_lock_);
       make_current_success = MakeCurrent();
     }
     if (make_current_success) {
       // Old sync points are global and do not have a command buffer ID,
       // We can simply use the GPUIO namespace with 0 for the command buffer ID
       // (under normal circumstances 0 is  invalid so  will not be used) until
       // the old sync points are replaced.
-      SyncToken sync_token(gpu::CommandBufferNamespace::GPU_IO, 0, sync_point);
+      SyncToken sync_token(gpu::CommandBufferNamespace::GPU_IO, 0, 0,
+                           sync_point);
       mailbox_manager->PushTextureUpdates(sync_token);
     }
   }
   service_->sync_point_manager()->RetireSyncPoint(sync_point);
 }
 
 void InProcessCommandBuffer::SignalSyncPoint(unsigned sync_point,
                                              const base::Closure& callback) {
   service_->sync_point_manager()->AddSyncPointCallback(sync_point,
                                                        WrapCallback(callback));
 }
 
 bool InProcessCommandBuffer::WaitSyncPointOnGpuThread(unsigned sync_point) {
   service_->sync_point_manager()->WaitSyncPoint(sync_point);
   gles2::MailboxManager* mailbox_manager =
       decoder_->GetContextGroup()->mailbox_manager();
   // Old sync points are global and do not have a command buffer ID,
   // We can simply use the GPUIO namespace with 0 for the command buffer ID
   // (under normal circumstances 0 is  invalid so  will not be used) until
   // the old sync points are replaced.
-  SyncToken sync_token(gpu::CommandBufferNamespace::GPU_IO, 0, sync_point);
+  SyncToken sync_token(gpu::CommandBufferNamespace::GPU_IO, 0, 0, sync_point);
   mailbox_manager->PullTextureUpdates(sync_token);
   return true;
 }
 
 void InProcessCommandBuffer::FenceSyncReleaseOnGpuThread(uint64_t release) {
   DCHECK(!sync_point_client_->client_state()->IsFenceSyncReleased(release));
   gles2::MailboxManager* mailbox_manager =
       decoder_->GetContextGroup()->mailbox_manager();
   if (mailbox_manager->UsesSync()) {
     bool make_current_success = false;
     {
       base::AutoLock lock(command_buffer_lock_);
       make_current_success = MakeCurrent();
     }
     if (make_current_success) {
-      SyncToken sync_token(GetNamespaceID(), GetCommandBufferID(), release);
+      SyncToken sync_token(GetNamespaceID(), GetExtraCommandBufferData(),
+                           GetCommandBufferID(), release);
       mailbox_manager->PushTextureUpdates(sync_token);
     }
   }
 
   sync_point_client_->ReleaseFenceSync(release);
 }
 
 bool InProcessCommandBuffer::WaitFenceSyncOnGpuThread(
     gpu::CommandBufferNamespace namespace_id,
     uint64_t command_buffer_id,
@@ skipping 12 matching lines @@
     // Use waitable event which is signalled when the release fence is released.
     sync_point_client_->Wait(
         release_state.get(), release,
         base::Bind(&base::WaitableEvent::Signal,
                    base::Unretained(&fence_sync_wait_event_)));
     fence_sync_wait_event_.Wait();
   }
 
   gles2::MailboxManager* mailbox_manager =
       decoder_->GetContextGroup()->mailbox_manager();
-  SyncToken sync_token(namespace_id, command_buffer_id, release);
+  SyncToken sync_token(namespace_id, 0, command_buffer_id, release);
   mailbox_manager->PullTextureUpdates(sync_token);
   return true;
 }
 
 void InProcessCommandBuffer::SignalSyncTokenOnGpuThread(
     const SyncToken& sync_token, const base::Closure& callback) {
   gpu::SyncPointManager* sync_point_manager = service_->sync_point_manager();
   DCHECK(sync_point_manager);
 
   scoped_refptr<gpu::SyncPointClientState> release_state =
@@ skipping 41 matching lines @@
 }
 
 CommandBufferNamespace InProcessCommandBuffer::GetNamespaceID() const {
   return CommandBufferNamespace::IN_PROCESS;
 }
 
 uint64_t InProcessCommandBuffer::GetCommandBufferID() const {
   return command_buffer_id_;
 }
 
+int32_t InProcessCommandBuffer::GetExtraCommandBufferData() const {
+  return 0;
+}
+
 uint64_t InProcessCommandBuffer::GenerateFenceSyncRelease() {
   return next_fence_sync_release_++;
 }
 
 bool InProcessCommandBuffer::IsFenceSyncRelease(uint64_t release) {
   return release != 0 && release < next_fence_sync_release_;
 }
 
 bool InProcessCommandBuffer::IsFenceSyncFlushed(uint64_t release) {
   return release <= flushed_fence_sync_release_;
@@ skipping 136 matching lines @@
     framebuffer_completeness_cache_ =
         new gpu::gles2::FramebufferCompletenessCache;
   return framebuffer_completeness_cache_;
 }
 
 SyncPointManager* GpuInProcessThread::sync_point_manager() {
   return sync_point_manager_;
 }
 
 }  // namespace gpu