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

content/browser/gpu/gpu_process_host.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/browser/gpu/gpu_process_host.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/base_switches.h"
 #include "base/command_line.h"
@@ skipping 385 matching lines @@
     channel_requests_.push(callback);
   } else {
     EstablishChannelError(
         callback, IPC::ChannelHandle(),
         base::kNullProcessHandle, content::GPUInfo());
   }
 }
 
 void GpuProcessHost::CreateViewCommandBuffer(
     gfx::PluginWindowHandle compositing_surface,
-    int32 render_view_id,
-    int32 client_id,
+    int surface_id,
+    int client_id,
     const GPUCreateCommandBufferConfig& init_params,
     const CreateCommandBufferCallback& callback) {
   DCHECK(CalledOnValidThread());
 
 #if defined(TOOLKIT_USES_GTK)
-  ViewID view_id(client_id, render_view_id);
-
   // There should only be one such command buffer (for the compositor).  In
   // practice, if the GPU process lost a context, GraphicsContext3D with
   // associated command buffer and view surface will not be gone until new
   // one is in place and all layers are reattached.
   linked_ptr<SurfaceRef> surface_ref;
-  SurfaceRefMap::iterator it = surface_refs_.find(view_id);
+  SurfaceRefMap::iterator it = surface_refs_.find(surface_id);
   if (it != surface_refs_.end())
     surface_ref = (*it).second;
   else
     surface_ref.reset(new SurfaceRef(compositing_surface));
 #endif  // defined(TOOLKIT_USES_GTK)
 
   if (compositing_surface != gfx::kNullPluginWindow &&
       Send(new GpuMsg_CreateViewCommandBuffer(
-          compositing_surface, render_view_id, client_id, init_params))) {
+          compositing_surface, surface_id, client_id, init_params))) {
     create_command_buffer_requests_.push(callback);
 #if defined(TOOLKIT_USES_GTK)
-    surface_refs_.insert(std::pair<ViewID, linked_ptr<SurfaceRef> >(
-        view_id, surface_ref));
+    surface_refs_.insert(std::make_pair(surface_id, surface_ref));
 #endif
   } else {
     CreateCommandBufferError(callback, MSG_ROUTING_NONE);
   }
 }
 
 void GpuProcessHost::OnChannelEstablished(
     const IPC::ChannelHandle& channel_handle) {
   // The GPU process should have launched at this point and this object should
   // have been notified of its process handle.
@@ skipping 27 matching lines @@
     CreateCommandBufferCallback callback =
         create_command_buffer_requests_.front();
     create_command_buffer_requests_.pop();
     if (route_id == MSG_ROUTING_NONE)
       CreateCommandBufferError(callback, route_id);
     else
       callback.Run(route_id);
   }
 }
 
-void GpuProcessHost::OnDestroyCommandBuffer(
-    gfx::PluginWindowHandle window, int32 client_id,
-    int32 render_view_id) {
+void GpuProcessHost::OnDestroyCommandBuffer(int32 surface_id) {
 #if defined(TOOLKIT_USES_GTK)
-  ViewID view_id(client_id, render_view_id);
-  SurfaceRefMap::iterator it = surface_refs_.find(view_id);
+  SurfaceRefMap::iterator it = surface_refs_.find(surface_id);
   if (it != surface_refs_.end())
     surface_refs_.erase(it);
 #endif  // defined(TOOLKIT_USES_GTK)
 }
 
 void GpuProcessHost::OnProcessLaunched() {
   // Send the GPU process handle to the UI thread before it has to
   // respond to any requests to establish a GPU channel. The response
   // to such requests require that the GPU process handle be known.
 
@@ skipping 129 matching lines @@
     const IPC::ChannelHandle& channel_handle,
     base::ProcessHandle renderer_process_for_gpu,
     const content::GPUInfo& gpu_info) {
   callback.Run(channel_handle, renderer_process_for_gpu, gpu_info);
 }
 
 void GpuProcessHost::CreateCommandBufferError(
     const CreateCommandBufferCallback& callback, int32 route_id) {
   callback.Run(route_id);
 }