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

gpu/command_buffer/service/sync_point_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/service/sync_point_manager.h"
 
 #include <limits.h>
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 309 matching lines @@
 void SyncPointClient::ReleaseFenceSync(uint64_t release) {
   // Validate that this Release call is between BeginProcessingOrderNumber() and
   // FinishProcessingOrderNumber(), or else we may deadlock.
   DCHECK(client_state_->order_data()->IsProcessingOrderNumber());
   client_state_->ReleaseFenceSync(release);
 }
 
 SyncPointClient::SyncPointClient()
     : sync_point_manager_(nullptr),
       namespace_id_(gpu::CommandBufferNamespace::INVALID),
-      client_id_(0) {}
+      client_id_() {}
 
 SyncPointClient::SyncPointClient(SyncPointManager* sync_point_manager,
                                  scoped_refptr<SyncPointOrderData> order_data,
                                  CommandBufferNamespace namespace_id,
-                                 uint64_t client_id)
+                                 CommandBufferId client_id)
     : sync_point_manager_(sync_point_manager),
       client_state_(new SyncPointClientState(order_data)),
       namespace_id_(namespace_id),
       client_id_(client_id) {}
 
 SyncPointManager::SyncPointManager(bool allow_threaded_wait) {
   global_order_num_.GetNext();
 }
 
 SyncPointManager::~SyncPointManager() {
   for (const ClientMap& client_map : client_maps_) {
     DCHECK(client_map.empty());
   }
 }
 
 scoped_ptr<SyncPointClient> SyncPointManager::CreateSyncPointClient(
     scoped_refptr<SyncPointOrderData> order_data,
     CommandBufferNamespace namespace_id,
-    uint64_t client_id) {
+    CommandBufferId client_id) {
   DCHECK_GE(namespace_id, 0);
   DCHECK_LT(static_cast<size_t>(namespace_id), arraysize(client_maps_));
   base::AutoLock auto_lock(client_maps_lock_);
 
   ClientMap& client_map = client_maps_[namespace_id];
   std::pair<ClientMap::iterator, bool> result = client_map.insert(
       std::make_pair(client_id, new SyncPointClient(this, order_data,
                                                     namespace_id, client_id)));
   DCHECK(result.second);
 
   return make_scoped_ptr(result.first->second);
 }
 
 scoped_ptr<SyncPointClient> SyncPointManager::CreateSyncPointClientWaiter() {
   return make_scoped_ptr(new SyncPointClient);
 }
 
 scoped_refptr<SyncPointClientState> SyncPointManager::GetSyncPointClientState(
-    CommandBufferNamespace namespace_id, uint64_t client_id) {
+    CommandBufferNamespace namespace_id,
+    CommandBufferId client_id) {
   if (namespace_id >= 0) {
     DCHECK_LT(static_cast<size_t>(namespace_id), arraysize(client_maps_));
     base::AutoLock auto_lock(client_maps_lock_);
     ClientMap& client_map = client_maps_[namespace_id];
     ClientMap::iterator it = client_map.find(client_id);
     if (it != client_map.end()) {
       return it->second->client_state();
     }
   }
   return nullptr;
 }
 
 uint32_t SyncPointManager::GenerateOrderNumber() {
   return global_order_num_.GetNext();
 }
 
 void SyncPointManager::DestroySyncPointClient(
-    CommandBufferNamespace namespace_id, uint64_t client_id) {
+    CommandBufferNamespace namespace_id,
+    CommandBufferId client_id) {
   DCHECK_GE(namespace_id, 0);
   DCHECK_LT(static_cast<size_t>(namespace_id), arraysize(client_maps_));
 
   base::AutoLock auto_lock(client_maps_lock_);
   ClientMap& client_map = client_maps_[namespace_id];
   ClientMap::iterator it = client_map.find(client_id);
   DCHECK(it != client_map.end());
   client_map.erase(it);
 }
 
 }  // namespace gpu