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

content/common/gpu/gpu_command_buffer_stub.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 "content/common/gpu/gpu_command_buffer_stub.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 138 matching lines @@
 };
 
 scoped_refptr<base::trace_event::ConvertableToTraceFormat>
 DevToolsChannelData::CreateForChannel(GpuChannel* channel) {
   scoped_ptr<base::DictionaryValue> res(new base::DictionaryValue);
   res->SetInteger("renderer_pid", channel->GetClientPID());
   res->SetDouble("used_bytes", channel->GetMemoryUsage());
   return new DevToolsChannelData(res.release());
 }
 
-uint64_t GetCommandBufferID(int channel_id, int32_t route_id) {
-  return (static_cast<uint64_t>(channel_id) << 32) | route_id;
+gpu::CommandBufferId GetCommandBufferID(int channel_id, int32_t route_id) {
+  return gpu::CommandBufferId::FromUnsafeValue(
+      (static_cast<uint64_t>(channel_id) << 32) | route_id);
 }
 
 gfx::GLSurface::Format GetSurfaceFormatFromAttribute(
     const gpu::gles2::ContextCreationAttribHelper& attrib,
     bool use_virtualized_gl_context) {
   gfx::GLSurface::Format format = gfx::GLSurface::SURFACE_DEFAULT;  // ARGB8888
   if (!use_virtualized_gl_context &&
       attrib.red_size <= 5 &&
       attrib.green_size <= 6 &&
       attrib.blue_size <= 5 &&
@@ skipping 49 matching lines @@
 
   gpu::gles2::ContextCreationAttribHelper attrib_parser;
   attrib_parser.Parse(requested_attribs_);
 
   if (share_group) {
     context_group_ = share_group->context_group_;
     DCHECK(context_group_->bind_generates_resource() ==
            attrib_parser.bind_generates_resource);
   } else {
     context_group_ = new gpu::gles2::ContextGroup(
-        mailbox_manager,
-        new GpuCommandBufferMemoryTracker(channel, command_buffer_id_),
+        mailbox_manager, new GpuCommandBufferMemoryTracker(
+                             channel, command_buffer_id_.GetUnsafeValue()),
         channel_->gpu_channel_manager()->shader_translator_cache(),
         channel_->gpu_channel_manager()->framebuffer_completeness_cache(), NULL,
         subscription_ref_set, pending_valuebuffer_state,
         attrib_parser.bind_generates_resource);
   }
 
 // Virtualize PreferIntegratedGpu contexts by default on OS X to prevent
 // performance regressions when enabling FCM.
 // http://crbug.com/180463
 #if defined(OS_MACOSX)
@@ skipping 665 matching lines @@
                       input_visible_size,
                       output_profile,
                       initial_bitrate,
                       reply_message);
   // encoder is registered as a DestructionObserver of this stub and will
   // self-delete during destruction of this stub.
 }
 
 void GpuCommandBufferStub::PullTextureUpdates(
     gpu::CommandBufferNamespace namespace_id,
-    uint64_t command_buffer_id,
+    gpu::CommandBufferId command_buffer_id,
     uint32_t release) {
   gpu::gles2::MailboxManager* mailbox_manager =
       context_group_->mailbox_manager();
   if (mailbox_manager->UsesSync() && MakeCurrent()) {
     gpu::SyncToken sync_token(namespace_id, 0, command_buffer_id, release);
     mailbox_manager->PullTextureUpdates(sync_token);
   }
 }
 
 void GpuCommandBufferStub::OnSignalSyncToken(const gpu::SyncToken& sync_token,
@@ skipping 46 matching lines @@
     gpu::SyncToken sync_token(gpu::CommandBufferNamespace::GPU_IO, 0,
                               command_buffer_id_, release);
     mailbox_manager->PushTextureUpdates(sync_token);
   }
 
   sync_point_client_->ReleaseFenceSync(release);
 }
 
 bool GpuCommandBufferStub::OnWaitFenceSync(
     gpu::CommandBufferNamespace namespace_id,
-    uint64_t command_buffer_id,
+    gpu::CommandBufferId command_buffer_id,
     uint64_t release) {
   DCHECK(!waiting_for_sync_point_);
   DCHECK(scheduler_->scheduled());
 
   scoped_refptr<gpu::SyncPointClientState> release_state =
       sync_point_manager_->GetSyncPointClientState(namespace_id,
                                                    command_buffer_id);
 
   if (!release_state)
     return true;
@@ skipping 13 matching lines @@
 
   if (!waiting_for_sync_point_)
     return true;
 
   scheduler_->SetScheduled(false);
   return false;
 }
 
 void GpuCommandBufferStub::OnWaitFenceSyncCompleted(
     gpu::CommandBufferNamespace namespace_id,
-    uint64_t command_buffer_id,
+    gpu::CommandBufferId command_buffer_id,
     uint64_t release) {
   DCHECK(waiting_for_sync_point_);
   TRACE_EVENT_ASYNC_END1("gpu", "WaitFenceSync", this, "GpuCommandBufferStub",
                          this);
   PullTextureUpdates(namespace_id, command_buffer_id, release);
   waiting_for_sync_point_ = false;
   scheduler_->SetScheduled(true);
 }
 
 void GpuCommandBufferStub::OnCreateImage(
@@ skipping 150 matching lines @@
                                                     result));
 }
 
 void GpuCommandBufferStub::SendUpdateVSyncParameters(base::TimeTicks timebase,
                                                      base::TimeDelta interval) {
   Send(new GpuCommandBufferMsg_UpdateVSyncParameters(route_id_, timebase,
                                                      interval));
 }
 
 }  // namespace content