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

content/browser/renderer_host/gpu_message_filter.cc

 // Copyright (c) 2011 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(OS_WIN)
 #include <windows.h>
 #endif
 
 #include "content/browser/renderer_host/gpu_message_filter.h"
 
 #include "base/bind.h"
 #include "content/browser/gpu/gpu_process_host.h"
+#include "content/browser/gpu/gpu_surface_tracker.h"
 #include "content/browser/renderer_host/render_widget_helper.h"
 #include "content/common/gpu/gpu_messages.h"
 
 using content::BrowserThread;
 
 GpuMessageFilter::GpuMessageFilter(int render_process_id,
                                    RenderWidgetHelper* render_widget_helper)
     : gpu_host_id_(0),
       render_process_id_(render_process_id),
       render_widget_helper_(render_widget_helper) {
@@ skipping 44 matching lines @@
   }
 
   host->EstablishGpuChannel(
       render_process_id_,
       base::Bind(&GpuMessageFilter::EstablishChannelCallback,
                  AsWeakPtr(),
                  reply));
 }
 
 void GpuMessageFilter::OnCreateViewCommandBuffer(
-    int32 render_view_id,
+    int32 surface_id,
     const GPUCreateCommandBufferConfig& init_params,
     IPC::Message* reply) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
+  GpuSurfaceTracker* surface_tracker = GpuSurfaceTracker::Get();
+  gfx::PluginWindowHandle compositing_surface = gfx::kNullPluginWindow;
+
+  int renderer_id = 0;
+  int render_widget_id = 0;
+  bool result = surface_tracker->GetRenderWidgetIDForSurface(
+      surface_id, &renderer_id, &render_widget_id);
+  if (result && renderer_id == render_process_id_) {
+    compositing_surface = surface_tracker->GetSurfaceHandle(surface_id);
+  } else {
+    DLOG(ERROR) << "Renderer " << render_process_id_
+                << " tried to access a surface for renderer " << renderer_id;
+  }
+
   GpuProcessHost* host = GpuProcessHost::FromID(gpu_host_id_);
-
-  gfx::PluginWindowHandle compositing_surface =
-      render_widget_helper_->LookupCompositingSurface(render_view_id);
-
   if (!host || compositing_surface == gfx::kNullPluginWindow) {
     // TODO(apatrick): Eventually, this IPC message will be routed to a
     // GpuProcessStub with a particular routing ID. The error will be set if
     // the GpuProcessStub with that routing ID is not in the MessageRouter.
     reply->set_reply_error();
     Send(reply);
     return;
   }
 
   host->CreateViewCommandBuffer(
       compositing_surface,
-      render_view_id,
+      surface_id,
       render_process_id_,
       init_params,
       base::Bind(&GpuMessageFilter::CreateCommandBufferCallback,
                  AsWeakPtr(),
                  reply));
 }
 
 void GpuMessageFilter::EstablishChannelCallback(
     IPC::Message* reply,
     const IPC::ChannelHandle& channel,
@@ skipping 25 matching lines @@
   Send(reply);
 }
 
 void GpuMessageFilter::CreateCommandBufferCallback(
     IPC::Message* reply, int32 route_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   GpuHostMsg_CreateViewCommandBuffer::WriteReplyParams(reply, route_id);
   Send(reply);
 }