gpu: reference target surfaces through a globally unique surface id.

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.
 
 #if defined(ENABLE_GPU)
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 12 matching lines @@
 GpuCommandBufferStub::GpuCommandBufferStub(
     GpuChannel* channel,
     GpuCommandBufferStub* share_group,
     gfx::PluginWindowHandle handle,
     const gfx::Size& size,
     const gpu::gles2::DisallowedFeatures& disallowed_features,
     const std::string& allowed_extensions,
     const std::vector<int32>& attribs,
     gfx::GpuPreference gpu_preference,
     int32 route_id,
-    int32 client_id,
-    int32 render_view_id,
+    int32 surface_id,
     GpuWatchdog* watchdog,
     bool software)
     : channel_(channel),
       handle_(handle),
       initial_size_(size),
       disallowed_features_(disallowed_features),
       allowed_extensions_(allowed_extensions),
       requested_attribs_(attribs),
       gpu_preference_(gpu_preference),
       route_id_(route_id),
       software_(software),
       last_flush_count_(0),
-      client_id_(client_id),
-      render_view_id_(render_view_id),
+      surface_id_(surface_id),
       parent_stub_for_initialization_(),
       parent_texture_for_initialization_(0),
       watchdog_(watchdog) {
   if (share_group) {
     context_group_ = share_group->context_group_;
   } else {
     // TODO(gman): this needs to be false for everything but Pepper.
     bool bind_generates_resource = true;
     context_group_ = new gpu::gles2::ContextGroup(bind_generates_resource);
   }
 }
 
 GpuCommandBufferStub::~GpuCommandBufferStub() {
   Destroy();
 
   GpuChannelManager* gpu_channel_manager = channel_->gpu_channel_manager();
-  gpu_channel_manager->Send(new GpuHostMsg_DestroyCommandBuffer(
-      handle_, client_id_, render_view_id_));
+  gpu_channel_manager->Send(new GpuHostMsg_DestroyCommandBuffer(surface_id_));
 }
 
 bool GpuCommandBufferStub::OnMessageReceived(const IPC::Message& message) {
   // Ensure the appropriate GL context is current before handling any IPC
   // messages directed at the command buffer. This ensures that the message
   // handler can assume that the context is current.
   if (decoder_.get()) {
     if (!decoder_->MakeCurrent()) {
       DLOG(ERROR) << "Context lost because MakeCurrent failed.";
       command_buffer_->SetContextLostReason(decoder_->GetContextLostReason());
@@ skipping 111 matching lines @@
 #if defined(OS_MACOSX) || defined(UI_COMPOSITOR_IMAGE_TRANSPORT)
     if (software_) {
       DLOG(ERROR) << "No software support.\n";
       OnInitializeFailed(reply_message);
       return;
     }
 #endif
 
     surface_ = ImageTransportSurface::CreateSurface(
         channel_->gpu_channel_manager(),
-        render_view_id_,
-        client_id_,
-        route_id_,
+        this,

[jonathan.backer, 2012/01/16 19:47:26]

Thanks for replacing the lookup with a WeakPtr.

         handle_);
   } else {
     surface_ = gfx::GLSurface::CreateOffscreenGLSurface(software_,
                                                         gfx::Size(1, 1));
   }
 
   if (!surface_.get()) {
     // Ensure the decoder is not destroyed if it is not initialized.
     decoder_.reset();
 
@@ skipping 298 matching lines @@
   GPUCommandBufferConsoleMessage console_message;
   console_message.id = id;
   console_message.message = message;
   IPC::Message* msg = new GpuCommandBufferMsg_ConsoleMsg(
       route_id_, console_message);
   msg->set_unblock(true);
   Send(msg);
 }
 
 #endif  // defined(ENABLE_GPU)