Introducing gpu::CommandBufferId as a distinct, IdType<...>-based type.

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 107 matching lines @@
       lose_context_when_out_of_memory(false),
       context_lost_allowed(false),
       context_type(gles2::CONTEXT_TYPE_OPENGLES2),
       force_shader_name_hashing(false) {}
 
 GLManager::GLManager()
     : sync_point_manager_(nullptr),
       context_lost_allowed_(false),
       pause_commands_(false),
       paused_order_num_(0),
-      command_buffer_id_(g_next_command_buffer_id++),
+      command_buffer_id_(
+          CommandBufferId::FromUnsafeValue(g_next_command_buffer_id++)),
       next_fence_sync_release_(1) {
   SetupBaseContext();
 }
 
 GLManager::~GLManager() {
   --use_count_;
   if (!use_count_) {
     if (base_share_group_) {
       delete base_context_;
       base_context_ = NULL;
@@ skipping 199 matching lines @@
   ++use_count_;
 }
 
 void GLManager::OnFenceSyncRelease(uint64_t release) {
   DCHECK(sync_point_client_);
   DCHECK(!sync_point_client_->client_state()->IsFenceSyncReleased(release));
   sync_point_client_->ReleaseFenceSync(release);
 }
 
 bool GLManager::OnWaitFenceSync(gpu::CommandBufferNamespace namespace_id,
-                                uint64_t command_buffer_id,
+                                gpu::CommandBufferId command_buffer_id,
                                 uint64_t release) {
   DCHECK(sync_point_client_);
   scoped_refptr<gpu::SyncPointClientState> release_state =
       sync_point_manager_->GetSyncPointClientState(namespace_id,
                                                    command_buffer_id);
   if (!release_state)
     return true;
 
   // GLManager does not support being multithreaded at this point, so the fence
   // sync must be released by the time wait is called.
@@ skipping 139 matching lines @@
 }
 
 void GLManager::EnsureWorkVisible() {
   // This is only relevant for out-of-process command buffers.
 }
 
 gpu::CommandBufferNamespace GLManager::GetNamespaceID() const {
   return gpu::CommandBufferNamespace::IN_PROCESS;
 }
 
-uint64_t GLManager::GetCommandBufferID() const {
+CommandBufferId GLManager::GetCommandBufferID() const {
   return command_buffer_id_;
 }
 
 int32_t GLManager::GetExtraCommandBufferData() const {
   return 0;
 }
 
 uint64_t GLManager::GenerateFenceSyncRelease() {
   return next_fence_sync_release_++;
 }
@@ skipping 26 matching lines @@
 
   // Something went wrong, just run the callback now.
   callback.Run();
 }
 
 bool GLManager::CanWaitUnverifiedSyncToken(const gpu::SyncToken* sync_token) {
   return false;
 }
 
 }  // namespace gpu