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

content/browser/renderer_host/render_widget_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/renderer_host/render_widget_host.h"
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/i18n/rtl.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "content/browser/accessibility/browser_accessibility_state.h"
 #include "content/browser/gpu/gpu_process_host.h"
 #include "content/browser/gpu/gpu_process_host_ui_shim.h"
+#include "content/browser/gpu/gpu_surface_tracker.h"
 #include "content/browser/renderer_host/backing_store.h"
 #include "content/browser/renderer_host/backing_store_manager.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/renderer_host/render_widget_helper.h"
 #include "content/browser/renderer_host/render_widget_host_view.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/native_web_keyboard_event.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
@@ skipping 44 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHost
 
 RenderWidgetHost::RenderWidgetHost(content::RenderProcessHost* process,
                                    int routing_id)
     : renderer_initialized_(false),
       renderer_accessible_(false),
       view_(NULL),
       process_(process),
       routing_id_(routing_id),
+      surface_id_(0),
       is_loading_(false),
       is_hidden_(false),
       is_accelerated_compositing_active_(false),
       repaint_ack_pending_(false),
       resize_ack_pending_(false),
       should_auto_resize_(false),
       mouse_move_pending_(false),
       mouse_wheel_pending_(false),
       touch_move_pending_(false),
       touch_event_is_queued_(false),
       needs_repainting_on_restore_(false),
       is_unresponsive_(false),
       in_get_backing_store_(false),
       view_being_painted_(false),
       ignore_input_events_(false),
       text_direction_updated_(false),
       text_direction_(WebKit::WebTextDirectionLeftToRight),
       text_direction_canceled_(false),
       suppress_next_char_events_(false),
       pending_mouse_lock_request_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
-  if (routing_id_ == MSG_ROUTING_NONE)
+  if (routing_id_ == MSG_ROUTING_NONE) {
     routing_id_ = process_->GetNextRoutingID();
+    surface_id_ = GpuSurfaceTracker::Get()->AddSurfaceForRenderer(
+        process_->GetID(),
+        routing_id_);
+  } else {
+    // TODO(piman): This is a O(N) lookup, where we could forward the
+    // information from the RenderWidgetHelper. The problem is that doing so
+    // currently leaks outside of content all the way to chrome classes, and
+    // would be a layering violation. Since we don't expect more than a few
+    // hundreds of RWH, this seems acceptable. Revisit if performance become a
+    // problem, for example by tracking in the RenderWidgetHelper the routing id
+    // (and surface id) that have been created, but whose RWH haven't yet.
+    surface_id_ = GpuSurfaceTracker::Get()->LookupSurfaceForRenderer(
+        process_->GetID(),
+        routing_id_);
+    DCHECK(surface_id_);
+  }
 
   process_->Attach(this, routing_id_);
   // Because the widget initializes as is_hidden_ == false,
   // tell the process host that we're alive.
   process_->WidgetRestored();
 
   // Enable accessibility if it was manually specified or if it was
   // auto-detected.
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kForceRendererAccessibility)) {
     BrowserAccessibilityState::GetInstance()->OnAccessibilityEnabledManually();
     EnableRendererAccessibility();
   } else if (BrowserAccessibilityState::GetInstance()->IsAccessibleBrowser()) {
     EnableRendererAccessibility();
   }
 }
 
 RenderWidgetHost::~RenderWidgetHost() {
   SetView(NULL);
 
   // Clear our current or cached backing store if either remains.
   BackingStoreManager::RemoveBackingStore(this);
 
+  GpuSurfaceTracker::Get()->RemoveSurface(surface_id_);
+  surface_id_ = 0;
+
   process_->Release(routing_id_);
 }
 
 void RenderWidgetHost::SetView(RenderWidgetHostView* view) {
   view_ = view;
 
-  if (!view_)
-    process_->SetCompositingSurface(routing_id_, gfx::kNullPluginWindow);
+  if (!view_) {
+    GpuSurfaceTracker::Get()->SetSurfaceHandle(
+        surface_id_, gfx::kNullPluginWindow);
+  }
 }
 
 gfx::NativeViewId RenderWidgetHost::GetNativeViewId() const {
   if (view_)
     return view_->GetNativeViewId();
   return 0;
 }
 
 gfx::PluginWindowHandle RenderWidgetHost::GetCompositingSurface() {
   if (view_)
     return view_->GetCompositingSurface();
   return gfx::kNullPluginWindow;
 }
 
 bool RenderWidgetHost::PreHandleKeyboardEvent(
     const NativeWebKeyboardEvent& event,
     bool* is_keyboard_shortcut) {
   return false;
 }
 
 void RenderWidgetHost::Init() {
   DCHECK(process_->HasConnection());
 
   renderer_initialized_ = true;
 
-  process_->SetCompositingSurface(routing_id_,
-                                  GetCompositingSurface());
+  GpuSurfaceTracker::Get()->SetSurfaceHandle(
+      surface_id_, GetCompositingSurface());
 
   // Send the ack along with the information on placement.
   Send(new ViewMsg_CreatingNew_ACK(routing_id_, GetNativeViewId()));
   WasResized();
 }
 
 void RenderWidgetHost::Shutdown() {
   if (process_->HasConnection()) {
     // Tell the renderer object to close.
     process_->ReportExpectingClose(routing_id_);
@@ skipping 1353 matching lines @@
     ui_shim->Send(new AcceleratedSurfaceMsg_BuffersSwappedACK(route_id));
 }
 
 // static
 void RenderWidgetHost::AcknowledgePostSubBuffer(int32 route_id,
                                                 int gpu_host_id) {
   GpuProcessHostUIShim* ui_shim = GpuProcessHostUIShim::FromID(gpu_host_id);
   if (ui_shim)
     ui_shim->Send(new AcceleratedSurfaceMsg_PostSubBufferACK(route_id));
 }