Fix the mac hangup when force-compositing-mode is enabled

chrome/browser/renderer_host/render_widget_host_view_mac.mm

 // 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 <QuartzCore/QuartzCore.h>
 
 #include "chrome/browser/renderer_host/render_widget_host_view_mac.h"
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
@@ skipping 556 matching lines @@
     HandleDelayedGpuViewHiding();
 }
 
 void RenderWidgetHostViewMac::RenderViewGone(base::TerminationStatus status,
                                              int error_code) {
   // TODO(darin): keep this around, and draw sad-tab into it.
   Destroy();
 }
 
 void RenderWidgetHostViewMac::Destroy() {
+  TRACE_EVENT0("browser", "RenderWidgetHostViewMac::Destroy");
   // On Windows, popups are implemented with a popup window style, so that when
   // an event comes in that would "cancel" it, it receives the OnCancelMode
   // message and can kill itself. Alas, on the Mac, views cannot capture events
   // outside of themselves. On Windows, if Destroy is being called on a view,
   // then the event causing the destroy had also cancelled any popups by the
   // time Destroy() was called. On the Mac we have to destroy all the popups
   // ourselves.
 
   // Depth-first destroy all popups. Use ShutdownHost() to enforce
   // deepest-first ordering.
@@ skipping 109 matching lines @@
 
   // |render_widget_host_| is set to NULL when |RWHVMac::Destroy()| has
   // completed. If |AllocateFakePluginWindowHandle()| is called after that,
   // we will crash when the AcceleratedPluginView we allocate below is
   // destroyed.
   DCHECK(render_widget_host_);
 
   // Create an NSView to host the plugin's/compositor's pixels.
   gfx::PluginWindowHandle handle =
       plugin_container_manager_.AllocateFakePluginWindowHandle(opaque, root);
+  TRACE_EVENT1("browser",
+               "RenderWidgetHostViewMac::AllocateFakePluginWindowHandle",
+               "window", handle);
 
   scoped_nsobject<AcceleratedPluginView> plugin_view(
       [[AcceleratedPluginView alloc] initWithRenderWidgetHostViewMac:this
                                                         pluginHandle:handle]);
   [plugin_view setHidden:YES];
 
   [cocoa_view_ addSubview:plugin_view];
   plugin_views_[handle] = plugin_view;
 
   return handle;
 }
 
 void RenderWidgetHostViewMac::DestroyFakePluginWindowHandle(
     gfx::PluginWindowHandle window) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  TRACE_EVENT1("browser",
+               "RenderWidgetHostViewMac::DestroyFakePluginWindowHandle",
+               "window", window);
   PluginViewMap::iterator it = plugin_views_.find(window);
   DCHECK(plugin_views_.end() != it);
   if (plugin_views_.end() == it) {
     return;
   }
   [it->second removeFromSuperview];
   plugin_views_.erase(it);
 
   // The view's dealloc will call DeallocFakePluginWindowHandle(), which will
   // remove the handle from |plugin_container_manager_|. This code path is
   // taken if a plugin is removed, but the RWHVMac itself stays alive.
 }
 
 // This is called by AcceleratedPluginView's -dealloc.
 void RenderWidgetHostViewMac::DeallocFakePluginWindowHandle(
     gfx::PluginWindowHandle window) {
+  TRACE_EVENT1("browser",
+               "RenderWidgetHostViewMac::DeallocFakePluginWindowHandle",
+               "window", window);
   // When a browser window with a GpuScheduler is closed, the render process
   // will attempt to finish all GL commands. It will busy-wait on the GPU
   // process until the command queue is empty. If a paint is pending, the GPU
   // process won't process any GL commands until the browser sends a paint ack,
   // but since the browser window is already closed, it will never arrive.
   // To resolve this we ask the GPU process to destroy the command buffer
   // associated with the given render widget.  Once the command buffer is
   // destroyed, all GL commands from the renderer will immediately receive
   // channel error.
   if (render_widget_host_ &&
       plugin_container_manager_.IsRootContainer(window)) {
     GpuProcessHost::SendOnIO(
         render_widget_host_->process()->id(),
         content::CAUSE_FOR_GPU_LAUNCH_NO_LAUNCH,
         new GpuMsg_DestroyCommandBuffer(
             render_widget_host_->process()->id(),
             render_widget_host_->routing_id()));
   }
 
   plugin_container_manager_.DestroyFakePluginWindowHandle(window);
 }
 
 AcceleratedPluginView* RenderWidgetHostViewMac::ViewForPluginWindowHandle(
     gfx::PluginWindowHandle window) {
   PluginViewMap::iterator it = plugin_views_.find(window);
-  DCHECK(plugin_views_.end() != it);
   if (plugin_views_.end() == it)
     return nil;
   return it->second;
 }
 
 void RenderWidgetHostViewMac::AcceleratedSurfaceSetIOSurface(
     gfx::PluginWindowHandle window,
     int32 width,
     int32 height,
     uint64 io_surface_identifier) {
@@ skipping 30 matching lines @@
                                                    transport_dib);
 }
 
 void RenderWidgetHostViewMac::AcceleratedSurfaceBuffersSwapped(
     gfx::PluginWindowHandle window,
     uint64 surface_id,
     int renderer_id,
     int32 route_id,
     int gpu_host_id,
     uint64 swap_buffers_count) {
-  TRACE_EVENT0("browser",
-      "RenderWidgetHostViewMac::AcceleratedSurfaceBuffersSwapped");
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   AcceleratedPluginView* view = ViewForPluginWindowHandle(window);
-  DCHECK(view);
-  if (!view)
+  TRACE_EVENT1("browser",
+      "RenderWidgetHostViewMac::AcceleratedSurfaceBuffersSwapped",
+      "view", view);
+  if (!view) {
+    // This happens, and we can't let the GPU go without an ack.
+    // TODO: Why does this happen? Does it matter?

[jbates, 2011/06/07 16:47:52]

Looks like this may be a recent ToT bug. It does not seem to happen in the
latest m13 branch.

+    AcknowledgeSwapBuffers(renderer_id,
+                           route_id,
+                           gpu_host_id,
+                           swap_buffers_count);
     return;
+  }
 
   plugin_container_manager_.SetSurfaceWasPaintedTo(window, surface_id);
 
   // The surface is hidden until its first paint, to not show gargabe.
   if (plugin_container_manager_.SurfaceShouldBeVisible(window))
     [view setHidden:NO];
   [view updateSwapBuffersCount:swap_buffers_count
                   fromRenderer:renderer_id
                        routeId:route_id
                      gpuHostId:gpu_host_id];
@@ skipping 26 matching lines @@
     UpdateRootGpuViewVisibility(false);
     needs_gpu_visibility_update_after_repaint_ = false;
   }
 }
 
 void RenderWidgetHostViewMac::AcknowledgeSwapBuffers(
     int renderer_id,
     int32 route_id,
     int gpu_host_id,
     uint64 swap_buffers_count) {
-  TRACE_EVENT1("gpu", "RenderWidgetHostViewMac::AcknowledgeSwapBuffers",
+  TRACE_EVENT1("browser", "RenderWidgetHostViewMac::AcknowledgeSwapBuffers",
       "swap_buffers_count", swap_buffers_count);
   // Called on the display link thread. Hand actual work off to the IO thread,
   // because |GpuProcessHost::Get()| can only be called there.
   // Currently, this is never called for plugins.
   if (render_widget_host_) {
     DCHECK_EQ(render_widget_host_->process()->id(), renderer_id);
     // |render_widget_host_->routing_id()| and |route_id| are usually not
     // equal: The former identifies the channel from the RWH in the browser
     // process to the corresponding render widget in the renderer process, while
     // the latter identifies the channel from the GpuCommandBufferStub in the
@@ skipping 1692 matching lines @@
   if (!string) return NO;
 
   // If the user is currently using an IME, confirm the IME input,
   // and then insert the text from the service, the same as TextEdit and Safari.
   [self confirmComposition];
   [self insertText:string];
   return YES;
 }
 
 @end