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

content/browser/renderer_host/render_widget_helper.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.
 
 #include "content/browser/renderer_host/render_widget_helper.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/eintr_wrapper.h"
 #include "base/threading/thread.h"
+#include "content/browser/gpu/gpu_surface_tracker.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/renderer_host/resource_dispatcher_host.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/browser_thread.h"
 
 using content::BrowserThread;
 
 // A helper used with DidReceiveUpdateMsg that we hold a pointer to in
 // pending_paints_.
@@ skipping 184 matching lines @@
 }
 
 void RenderWidgetHelper::OnCrossSiteSwapOutACK(
     const ViewMsg_SwapOut_Params& params) {
   resource_dispatcher_host_->OnSwapOutACK(params);
 }
 
 void RenderWidgetHelper::CreateNewWindow(
     const ViewHostMsg_CreateWindow_Params& params,
     base::ProcessHandle render_process,
-    int* route_id) {
+    int* route_id,
+    int* surface_id) {
   *route_id = GetNextRoutingID();
+  *surface_id = GpuSurfaceTracker::Get()->AddSurfaceForRenderer(
+      render_process_id_, *route_id);
   // Block resource requests until the view is created, since the HWND might be
   // needed if a response ends up creating a plugin.
   resource_dispatcher_host_->BlockRequestsForRoute(
       render_process_id_, *route_id);
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(
-          &RenderWidgetHelper::OnCreateWindowOnUI, this, params, *route_id));
+      base::Bind(&RenderWidgetHelper::OnCreateWindowOnUI,
+                 this, params, *route_id));
 }
 
 void RenderWidgetHelper::OnCreateWindowOnUI(
     const ViewHostMsg_CreateWindow_Params& params,
     int route_id) {
   RenderViewHost* host =
       RenderViewHost::FromID(render_process_id_, params.opener_id);
   if (host)
     host->CreateNewWindow(route_id, params);
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&RenderWidgetHelper::OnCreateWindowOnIO, this, route_id));
 }
 
 void RenderWidgetHelper::OnCreateWindowOnIO(int route_id) {
   resource_dispatcher_host_->ResumeBlockedRequestsForRoute(
       render_process_id_, route_id);
 }
 
 void RenderWidgetHelper::CreateNewWidget(int opener_id,
                                          WebKit::WebPopupType popup_type,
-                                         int* route_id) {
+                                         int* route_id,
+                                         int* surface_id) {
   *route_id = GetNextRoutingID();
+  *surface_id = GpuSurfaceTracker::Get()->AddSurfaceForRenderer(
+      render_process_id_, *route_id);
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(
           &RenderWidgetHelper::OnCreateWidgetOnUI, this, opener_id, *route_id,
           popup_type));
 }
 
 void RenderWidgetHelper::CreateNewFullscreenWidget(int opener_id,
-                                                   int* route_id) {
+                                                   int* route_id,
+                                                   int* surface_id) {
   *route_id = GetNextRoutingID();
+  *surface_id = GpuSurfaceTracker::Get()->AddSurfaceForRenderer(
+      render_process_id_, *route_id);
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(
           &RenderWidgetHelper::OnCreateFullscreenWidgetOnUI, this,
           opener_id, *route_id));
 }
 
 void RenderWidgetHelper::OnCreateWidgetOnUI(
     int opener_id, int route_id, WebKit::WebPopupType popup_type) {
   RenderViewHost* host = RenderViewHost::FromID(render_process_id_, opener_id);
@@ skipping 57 matching lines @@
 void RenderWidgetHelper::ClearAllocatedDIBs() {
   for (std::map<TransportDIB::Id, int>::iterator
        i = allocated_dibs_.begin(); i != allocated_dibs_.end(); ++i) {
     if (HANDLE_EINTR(close(i->second)) < 0)
       PLOG(ERROR) << "close: " << i->first;
   }
 
   allocated_dibs_.clear();
 }
 #endif
-
-void RenderWidgetHelper::SetCompositingSurface(
-    int render_widget_id,
-    gfx::PluginWindowHandle compositing_surface) {
-  base::AutoLock locked(view_compositing_surface_map_lock_);
-  if (compositing_surface != gfx::kNullPluginWindow)
-    view_compositing_surface_map_[render_widget_id] = compositing_surface;
-  else
-    view_compositing_surface_map_.erase(render_widget_id);
-}
-
-gfx::PluginWindowHandle RenderWidgetHelper::LookupCompositingSurface(
-    int render_widget_id) {
-  base::AutoLock locked(view_compositing_surface_map_lock_);
-  ViewCompositingSurfaceMap::iterator it =
-      view_compositing_surface_map_.find(render_widget_id);
-  if (it == view_compositing_surface_map_.end())
-    return gfx::kNullPluginWindow;
-
-  return it->second;
-}