Progress towards fixing 77536

chrome/browser/gpu_process_host_ui_shim.cc

 // TODO(jam): move this file to src/content once we have an interface that the
 // embedder provides.  We can then use it to get the resource and resize the
 // window.
 // 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 "chrome/browser/gpu_process_host_ui_shim.h"
 
 #include "base/command_line.h"
@@ skipping 94 matching lines @@
 
 RouteToGpuProcessHostUIShimTask::~RouteToGpuProcessHostUIShimTask() {
 }
 
 void RouteToGpuProcessHostUIShimTask::Run() {
   GpuProcessHostUIShim* ui_shim = GpuProcessHostUIShim::FromID(host_id_);
   if (ui_shim)
     ui_shim->OnMessageReceived(msg_);
 }
 
-class GpuProcessHostUIShim::ViewSurface {
+#if defined(OS_LINUX)
+// Used to put a lock on surfaces so that the window to which the GPU
+// process is drawing to doesn't disappear while it is drawing when
+// a tab is closed.
+class GpuProcessHostUIShim::SurfaceLock {

[jam, 2011/04/14 22:42:00]

nit: lock implies that locking is taking place, where this looks like a
reference.  How about SurfaceReference?

[jonathan.backer, 2011/04/15 19:02:51]

Done.

  public:
-  explicit ViewSurface(ViewID view_id);
-  ~ViewSurface();
-  gfx::PluginWindowHandle surface() { return surface_; }
+  explicit SurfaceLock(gfx::PluginWindowHandle surface);
+  ~SurfaceLock();
  private:
-  RenderWidgetHostView* GetRenderWidgetHostView();
-  ViewID view_id_;
   gfx::PluginWindowHandle surface_;
 };
 
-GpuProcessHostUIShim::ViewSurface::ViewSurface(ViewID view_id)
-    : view_id_(view_id), surface_(gfx::kNullPluginWindow) {
-  RenderWidgetHostView* view = GetRenderWidgetHostView();
-  if (view)
-    surface_ = view->AcquireCompositingSurface();
+GpuProcessHostUIShim::SurfaceLock::SurfaceLock(gfx::PluginWindowHandle surface)
+    : surface_(surface) {
+  GtkNativeViewManager* manager = GtkNativeViewManager::GetInstance();
+  DCHECK(manager->AddRefPermanentXID(surface_));

[jam, 2011/04/14 22:42:00]

DCHECK is compiled away in release builds, so you'll either want to use CHECK,
or get the rv and DCHECK it

[jonathan.backer, 2011/04/15 19:02:51]

Good catch! Done.

 }
 
-GpuProcessHostUIShim::ViewSurface::~ViewSurface() {
-  if (!surface_)
-    return;
-
-  RenderWidgetHostView* view = GetRenderWidgetHostView();
-  if (view)
-    view->ReleaseCompositingSurface(surface_);
+GpuProcessHostUIShim::SurfaceLock::~SurfaceLock() {
+  // TODO(backer): ReleasePermanentXID has to be done on the UI thread.
+  // Post task to release once we move this code to the IO thread.
+  GtkNativeViewManager* manager = GtkNativeViewManager::GetInstance();
+  manager->ReleasePermanentXID(surface_);
 }
-
-// We do separate lookups for the RenderWidgetHostView when acquiring
-// and releasing surfaces (rather than caching) because the
-// RenderWidgetHostView could die without warning. In such a case,
-// it's the RenderWidgetHostView's responsibility to cleanup.
-RenderWidgetHostView* GpuProcessHostUIShim::ViewSurface::
-    GetRenderWidgetHostView() {
-  RenderProcessHost* process = RenderProcessHost::FromID(view_id_.first);
-  RenderWidgetHost* host = NULL;
-  if (process) {
-    host = static_cast<RenderWidgetHost*>(
-        process->GetListenerByID(view_id_.second));
-  }
-
-  RenderWidgetHostView* view = NULL;
-  if (host)
-    view = host->view();
-
-  return view;
-}
+#endif  // defined(OS_LINUX)
 
 GpuProcessHostUIShim::GpuProcessHostUIShim(int host_id,
     content::CauseForGpuLaunch cause_for_gpu_launch)
     : host_id_(host_id),
       gpu_process_(base::kNullProcessHandle),
       gpu_channel_manager_(NULL),
       ui_thread_sender_(NULL) {
   g_hosts_by_id.AddWithID(this, host_id_);
   gpu_data_manager_ = GpuDataManager::GetInstance();
   DCHECK(gpu_data_manager_);
@@ skipping 237 matching lines @@
   linked_ptr<SynchronizeCallback> wrapped_callback(callback);
 
   if (Send(new GpuMsg_Synchronize())) {
     synchronize_requests_.push(wrapped_callback);
   } else {
     SynchronizeError(wrapped_callback.release());
   }
 }
 
 void GpuProcessHostUIShim::CreateViewCommandBuffer(
+    gfx::PluginWindowHandle compositing_surface,
     int32 render_view_id,
     int32 renderer_id,
     const GPUCreateCommandBufferConfig& init_params,
     CreateCommandBufferCallback* callback) {
+  // FIXME(backer): We're gonna have to fix the ref counting on the
+  // compositing_surface being passed in (at least for Linux).
   DCHECK(CalledOnValidThread());
   linked_ptr<CreateCommandBufferCallback> wrapped_callback(callback);
+
+#if defined(OS_LINUX)
   ViewID view_id(renderer_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<ViewSurface> view_surface;
-  ViewSurfaceMap::iterator it = acquired_surfaces_.find(view_id);
-  if (it != acquired_surfaces_.end())
-    view_surface = (*it).second;
+  linked_ptr<SurfaceLock> surface_lock;
+  SurfaceLockMap::iterator it = surface_locks_.find(view_id);
+  if (it != surface_locks_.end())
+    surface_lock = (*it).second;
   else
-    view_surface.reset(new ViewSurface(view_id));
+    surface_lock.reset(new SurfaceLock(compositing_surface));
+#endif  // defined(OS_LINUX)
 
-  if (view_surface->surface() != gfx::kNullPluginWindow &&
+  if (compositing_surface != gfx::kNullPluginWindow &&
       Send(new GpuMsg_CreateViewCommandBuffer(
-          view_surface->surface(), render_view_id, renderer_id, init_params))) {
+          compositing_surface, render_view_id, renderer_id, init_params))) {
     create_command_buffer_requests_.push(wrapped_callback);
-    acquired_surfaces_.insert(std::pair<ViewID, linked_ptr<ViewSurface> >(
-        view_id, view_surface));
+#if defined(OS_LINUX)
+    surface_locks_.insert(std::pair<ViewID, linked_ptr<SurfaceLock> >(
+        view_id, surface_lock));
+#endif  // defined(OS_LINUX)
   } else {
     CreateCommandBufferError(wrapped_callback.release(), MSG_ROUTING_NONE);
   }
 }
 
 #if defined(OS_MACOSX)
 
 void GpuProcessHostUIShim::DidDestroyAcceleratedSurface(int renderer_id,
                                                         int render_view_id) {
   // Destroy the command buffer that owns the accelerated surface.
@@ skipping 131 matching lines @@
     if (route_id == MSG_ROUTING_NONE)
       CreateCommandBufferError(callback.release(), route_id);
     else
       callback->Run(route_id);
   }
 }
 
 void GpuProcessHostUIShim::OnDestroyCommandBuffer(
     gfx::PluginWindowHandle window, int32 renderer_id,
     int32 render_view_id) {
+#if defined(OS_LINUX)
   ViewID view_id(renderer_id, render_view_id);
-  ViewSurfaceMap::iterator it = acquired_surfaces_.find(view_id);
-  if (it != acquired_surfaces_.end())
-    acquired_surfaces_.erase(it);
+  SurfaceLockMap::iterator it = surface_locks_.find(view_id);
+  if (it != surface_locks_.end())
+    surface_locks_.erase(it);
+#endif  // defined(OS_LINUX)
 }
 
 void GpuProcessHostUIShim::OnGraphicsInfoCollected(const GPUInfo& gpu_info) {
   gpu_data_manager_->UpdateGpuInfo(gpu_info);
 }
 
 void GpuProcessHostUIShim::OnLogMessage(int level,
     const std::string& header,
     const std::string& message) {
   DictionaryValue* dict = new DictionaryValue();
@@ skipping 61 matching lines @@
     int render_view_id) {
   RenderViewHost* host = RenderViewHost::FromID(renderer_id,
                                                 render_view_id);
   if (!host) {
     return;
   }
   host->ScheduleComposite();
 }
 
 #endif