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

chrome/browser/renderer_host/accelerated_plugin_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.
 
 #import "chrome/browser/renderer_host/accelerated_plugin_view_mac.h"
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #import "base/mac/scoped_nsautorelease_pool.h"
 #include "chrome/browser/renderer_host/render_widget_host_view_mac.h"
 #include "chrome/common/chrome_switches.h"
 #include "ui/gfx/gl/gl_switches.h"
 #include "ui/gfx/scoped_ns_graphics_context_save_gstate_mac.h"
 
 @implementation AcceleratedPluginView
 @synthesize cachedSize = cachedSize_;
 
 - (CVReturn)getFrameForTime:(const CVTimeStamp*)outputTime {
+  TRACE_EVENT2("browser", "AcceleratedPluginView::getFrameForTime",
+               "swapBuffersCount_", swapBuffersCount_,
+               "acknowledgedSwapBuffersCount_", acknowledgedSwapBuffersCount_);
   // There is no autorelease pool when this method is called because it will be
   // called from a background thread.
   base::mac::ScopedNSAutoreleasePool pool;
 
   bool sendAck = (rendererId_ != 0 || routeId_ != 0);
   uint64 currentSwapBuffersCount = swapBuffersCount_;
   if (currentSwapBuffersCount == acknowledgedSwapBuffersCount_) {
     return kCVReturnSuccess;
   }
 
   [self drawView];
 
   acknowledgedSwapBuffersCount_ = currentSwapBuffersCount;
   if (sendAck && renderWidgetHostView_) {
     renderWidgetHostView_->AcknowledgeSwapBuffers(
         rendererId_,
         routeId_,
         gpuHostId_,
         acknowledgedSwapBuffersCount_);
   }
 
   return kCVReturnSuccess;
 }
 
-// This is the renderer output callback function
-static CVReturn DrawOneAcceleratedPluginCallback(
-    CVDisplayLinkRef displayLink,
-    const CVTimeStamp* now,
-    const CVTimeStamp* outputTime,
-    CVOptionFlags flagsIn,
-    CVOptionFlags* flagsOut,
-    void* displayLinkContext) {
-  CVReturn result =
-      [(AcceleratedPluginView*)displayLinkContext getFrameForTime:outputTime];
-  return result;
-}
+///// This is the renderer output callback function
+///static CVReturn DrawOneAcceleratedPluginCallback(
+///    CVDisplayLinkRef displayLink,
+///    const CVTimeStamp* now,
+///    const CVTimeStamp* outputTime,
+///    CVOptionFlags flagsIn,
+///    CVOptionFlags* flagsOut,
+///    void* displayLinkContext) {
+///  CVReturn result =
+///      [(AcceleratedPluginView*)displayLinkContext getFrameForTime:outputTime];
+///  return result;
+///}
 
 - (id)initWithRenderWidgetHostViewMac:(RenderWidgetHostViewMac*)r
                          pluginHandle:(gfx::PluginWindowHandle)pluginHandle {
   if ((self = [super initWithFrame:NSZeroRect])) {
+    TRACE_EVENT0("browser",
+                 "AcceleratedPluginView::initWithRenderWidgetHostViewMac");
     renderWidgetHostView_ = r;
     pluginHandle_ = pluginHandle;
     cachedSize_ = NSZeroSize;
     swapBuffersCount_ = 0;
     acknowledgedSwapBuffersCount_ = 0;
     rendererId_ = 0;
     routeId_ = 0;
     gpuHostId_ = 0;
 
     [self setAutoresizingMask:NSViewMaxXMargin|NSViewMinYMargin];
@@ skipping 15 matching lines @@
     cglPixelFormat_ = (CGLPixelFormatObj)[glPixelFormat_ CGLPixelFormatObj];
 
     // Draw at beam vsync.
     GLint swapInterval;
     if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kDisableGpuVsync))
       swapInterval = 0;
     else
       swapInterval = 1;
     [glContext_ setValues:&swapInterval forParameter:NSOpenGLCPSwapInterval];
 
-    // Set up a display link to do OpenGL rendering on a background thread.
-    CVDisplayLinkCreateWithActiveCGDisplays(&displayLink_);
+/// // Set up a display link to do OpenGL rendering on a background thread.
+/// CVDisplayLinkCreateWithActiveCGDisplays(&displayLink_);
   }
   return self;
 }
 
 - (void)dealloc {
-  CVDisplayLinkRelease(displayLink_);
-  if (renderWidgetHostView_)
+///CVDisplayLinkRelease(displayLink_);
+  if (renderWidgetHostView_) {
+    bool sendAck = (rendererId_ != 0 || routeId_ != 0) &&
+                   (swapBuffersCount_ != acknowledgedSwapBuffersCount_);
+    if (sendAck) {
+      // Prevent deadlock issues if the GPU process is expecting an ack of the
+      // SwapBuffers.
+      renderWidgetHostView_->AcknowledgeSwapBuffers(
+          rendererId_,
+          routeId_,
+          gpuHostId_,
+          swapBuffersCount_);
+    }
     renderWidgetHostView_->DeallocFakePluginWindowHandle(pluginHandle_);
+  }
   [[NSNotificationCenter defaultCenter] removeObserver:self];
   [super dealloc];
 }
 
 - (void)drawView {
   TRACE_EVENT1("browser", "AcceleratedPluginViewMac::drawView",
       "frameNum", swapBuffersCount_);
   // Called on a background thread. Synchronized via the CGL context lock.
   CGLLockContext(cglContext_);
 
   if (renderWidgetHostView_) {
     // TODO(thakis): Pixel or view coordinates for size?
     renderWidgetHostView_->DrawAcceleratedSurfaceInstance(
         cglContext_, pluginHandle_, [self cachedSize]);
   }
 
   CGLFlushDrawable(cglContext_);
   CGLSetCurrentContext(0);
   CGLUnlockContext(cglContext_);
 }
 
 - (void)setCutoutRects:(NSArray*)cutout_rects {
   cutoutRects_.reset([cutout_rects copy]);
 }
 
 - (void)updateSwapBuffersCount:(uint64)count
                   fromRenderer:(int)rendererId
                        routeId:(int32)routeId
                      gpuHostId:(int)gpuHostId {
+  TRACE_EVENT2("browser", "AcceleratedPluginView::updateSwapBuffersCount",
+               "routeId", routeId, "count", count);
   if (rendererId == 0 && routeId == 0) {
     // This notification is coming from a plugin process, for which we
     // don't have flow control implemented right now. Fake up a swap
     // buffers count so that we can at least skip useless renders.
     ++swapBuffersCount_;
   } else {
     rendererId_ = rendererId;
     routeId_ = routeId;
     gpuHostId_ = gpuHostId;
     swapBuffersCount_ = count;
   }
+  [self getFrameForTime:NULL];
 }
 
 - (void)onRenderWidgetHostViewGone {
   if (!renderWidgetHostView_)
     return;
 
   CGLLockContext(cglContext_);
   // Deallocate the plugin handle while we still can.
   renderWidgetHostView_->DeallocFakePluginWindowHandle(pluginHandle_);
   renderWidgetHostView_ = NULL;
@@ skipping 57 matching lines @@
 
   // You would think that -update updates the viewport. You would be wrong.
   CGLSetCurrentContext(cglContext_);
   NSSize size = [self frame].size;
   glViewport(0, 0, size.width, size.height);
 
   CGLSetCurrentContext(0);
   CGLUnlockContext(cglContext_);
   globalFrameDidChangeCGLLockCount_--;
 
-  if (globalFrameDidChangeCGLLockCount_ == 0) {
-    // Make sure the view is synchronized with the correct display.
-    CVDisplayLinkSetCurrentCGDisplayFromOpenGLContext(
-       displayLink_, cglContext_, cglPixelFormat_);
-  }
+///if (globalFrameDidChangeCGLLockCount_ == 0) {
+///  // Make sure the view is synchronized with the correct display.
+///  CVDisplayLinkSetCurrentCGDisplayFromOpenGLContext(
+///     displayLink_, cglContext_, cglPixelFormat_);
+///}
 }
 
 - (void)renewGState {
   // Synchronize with window server to avoid flashes or corrupt drawing.
   [[self window] disableScreenUpdatesUntilFlush];
   [self globalFrameDidChange:nil];
   [super renewGState];
 }
 
 - (void)lockFocus {
   [super lockFocus];
 
   // If we're using OpenGL, make sure it is connected and that the display link
   // is running.
   if ([glContext_ view] != self) {
     [glContext_ setView:self];
 
     [[NSNotificationCenter defaultCenter]
          addObserver:self
             selector:@selector(globalFrameDidChange:)
                 name:NSViewGlobalFrameDidChangeNotification
               object:self];
-    CVDisplayLinkSetOutputCallback(
-        displayLink_, &DrawOneAcceleratedPluginCallback, self);
-    CVDisplayLinkSetCurrentCGDisplayFromOpenGLContext(
-        displayLink_, cglContext_, cglPixelFormat_);
-    CVDisplayLinkStart(displayLink_);
+/// CVDisplayLinkSetOutputCallback(
+///     displayLink_, &DrawOneAcceleratedPluginCallback, self);
+/// CVDisplayLinkSetCurrentCGDisplayFromOpenGLContext(
+///     displayLink_, cglContext_, cglPixelFormat_);
+/// CVDisplayLinkStart(displayLink_);
   }
   [glContext_ makeCurrentContext];
 }
 
 - (void)viewWillMoveToWindow:(NSWindow*)newWindow {
   // Stop the display link thread while the view is not visible.
-  if (newWindow) {
-    if (displayLink_ && !CVDisplayLinkIsRunning(displayLink_))
-      CVDisplayLinkStart(displayLink_);
-  } else {
-    if (displayLink_ && CVDisplayLinkIsRunning(displayLink_))
-      CVDisplayLinkStop(displayLink_);
-  }
+  TRACE_EVENT1("renderer", "viewWillMoveToWindow",
+               "newWindow", newWindow);
+///if (newWindow) {
+///  if (displayLink_ && !CVDisplayLinkIsRunning(displayLink_)) {
+///    TRACE_EVENT0("renderer", "CVDisplayLinkStart");
+///    CVDisplayLinkStart(displayLink_);
+///  }
+///} else {
+///  if (displayLink_ && CVDisplayLinkIsRunning(displayLink_)) {
+///    TRACE_EVENT0("renderer", "CVDisplayLinkStop");
+///    CVDisplayLinkStop(displayLink_);
+///  }
+///}
 
   // Inform the window hosting this accelerated view that it needs to be
   // transparent.
   if (![self isHiddenOrHasHiddenAncestor]) {
     if ([[self window] respondsToSelector:@selector(underlaySurfaceRemoved)])
       [static_cast<id>([self window]) underlaySurfaceRemoved];
     if ([newWindow respondsToSelector:@selector(underlaySurfaceAdded)])
       [static_cast<id>(newWindow) underlaySurfaceAdded];
   }
 }
@@ skipping 38 matching lines @@
   [[self window] makeFirstResponder:[self superview]];
   return YES;
 }
 
 - (void)viewDidMoveToSuperview {
   if (![self superview])
     [self onRenderWidgetHostViewGone];
 }
 @end