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_;
 
+- (void)drawView {
+  TRACE_EVENT1("browser", "AcceleratedPluginViewMac::drawView",
+      "frameNum", swapBuffersCount_);
+
+  if (renderWidgetHostView_) {
+    // TODO(thakis): Pixel or view coordinates for size?
+    renderWidgetHostView_->DrawAcceleratedSurfaceInstance(
+        cglContext_, pluginHandle_, [self cachedSize]);
+  }
+
+  CGLFlushDrawable(cglContext_);
+  CGLSetCurrentContext(0);
+}
+
+// Note: cglContext_ lock must be held during this call.

[Ken Russell (switch to Gerrit), 2011/06/13 21:45:12]

This comment applies to drawView too.

+- (void)ackSwapBuffers:(uint64)swapBuffersCount {
+  if (swapBuffersCount > acknowledgedSwapBuffersCount_) {
+    acknowledgedSwapBuffersCount_ = swapBuffersCount;
+    bool sendAck = (rendererId_ != 0 || routeId_ != 0);
+    if (sendAck && renderWidgetHostView_) {
+      renderWidgetHostView_->AcknowledgeSwapBuffers(
+          rendererId_,
+          routeId_,
+          gpuHostId_,
+          acknowledgedSwapBuffersCount_);
+    }
+  }
+}
+
 - (CVReturn)getFrameForTime:(const CVTimeStamp*)outputTime {
+  TRACE_EVENT0("browser", "AcceleratedPluginView::getFrameForTime");
   // 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;
   }
 
+  // Called on a background thread. Synchronized via the CGL context lock.
+  CGLLockContext(cglContext_);
+
   [self drawView];
+  [self ackSwapBuffers:currentSwapBuffersCount];
 
-  acknowledgedSwapBuffersCount_ = currentSwapBuffersCount;
-  if (sendAck && renderWidgetHostView_) {
-    renderWidgetHostView_->AcknowledgeSwapBuffers(
-        rendererId_,
-        routeId_,
-        gpuHostId_,
-        acknowledgedSwapBuffersCount_);
-  }
+  CGLUnlockContext(cglContext_);
 
   return kCVReturnSuccess;
 }
 
 // This is the renderer output callback function
 static CVReturn DrawOneAcceleratedPluginCallback(
     CVDisplayLinkRef displayLink,
     const CVTimeStamp* now,
     const CVTimeStamp* outputTime,
     CVOptionFlags flagsIn,
@@ skipping 37 matching lines @@
     // 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_);
+    CVDisplayLinkSetOutputCallback(
+        displayLink_, &DrawOneAcceleratedPluginCallback, self);
+    CVDisplayLinkSetCurrentCGDisplayFromOpenGLContext(
+        displayLink_, cglContext_, cglPixelFormat_);
+
+    [[NSNotificationCenter defaultCenter]
+         addObserver:self
+            selector:@selector(globalFrameDidChange:)
+                name:NSViewGlobalFrameDidChangeNotification
+              object:self];
   }
   return self;
 }
 
 - (void)dealloc {
   CVDisplayLinkRelease(displayLink_);
+
+  // Ack pending swaps (if any):
+  CGLLockContext(cglContext_);
+  [self ackSwapBuffers:swapBuffersCount_];
+  CGLUnlockContext(cglContext_);
+
   if (renderWidgetHostView_)
     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 {
   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;
   }
+  // If this view is not visible, we have to ack now. Otherwise,
+  // the ack will not be sent until the tab is made visible, which means it will
+  // look like the tab is loading (busy cursor) until it is clicked.
+  if (![self window]) {
+    // Ack pending swaps (if any):
+    CGLLockContext(cglContext_);
+    [self ackSwapBuffers:swapBuffersCount_];
+    CGLUnlockContext(cglContext_);
+  }
 }
 
 - (void)onRenderWidgetHostViewGone {
   if (!renderWidgetHostView_)
     return;
 
   CGLLockContext(cglContext_);
+  // Ack pending swaps (if any):
+  [self ackSwapBuffers:swapBuffersCount_];
   // Deallocate the plugin handle while we still can.
   renderWidgetHostView_->DeallocFakePluginWindowHandle(pluginHandle_);
   renderWidgetHostView_ = NULL;
   CGLUnlockContext(cglContext_);
 }
 
 - (void)drawRect:(NSRect)rect {
+  TRACE_EVENT0("browser", "AcceleratedPluginView::drawRect");
   const NSRect* dirtyRects;
   int dirtyRectCount;
   [self getRectsBeingDrawn:&dirtyRects count:&dirtyRectCount];
 
   {
     gfx::ScopedNSGraphicsContextSaveGState scopedGState;
 
     // Mask out any cutout rects--somewhat counterintuitively cutout rects are
     // places where clearColor is *not* drawn. The trick is that drawing nothing
     // lets the parent view (i.e., the web page) show through, whereas drawing
@@ skipping 15 matching lines @@
       }
 
       [path addClip];
     }
 
     // Punch a hole so that the OpenGL view shows through.
     [[NSColor clearColor] set];
     NSRectFillList(dirtyRects, dirtyRectCount);
   }
 
+  CGLLockContext(cglContext_);
   [self drawView];
+  CGLUnlockContext(cglContext_);
 }
 
 - (void)rightMouseDown:(NSEvent*)event {
   // The NSResponder documentation: "Note: The NSView implementation of this
   // method does not pass the message up the responder chain, it handles it
   // directly."
   // That's bad, we want the next responder (RWHVMac) to handle this event to
   // dispatch it to the renderer.
   [[self nextResponder] rightMouseDown:event];
 }
@@ skipping 14 matching lines @@
   CGLUnlockContext(cglContext_);
   globalFrameDidChangeCGLLockCount_--;
 
   if (globalFrameDidChangeCGLLockCount_ == 0) {
     // Make sure the view is synchronized with the correct display.
     CVDisplayLinkSetCurrentCGDisplayFromOpenGLContext(
        displayLink_, cglContext_, cglPixelFormat_);
   }
 }
 
+- (void)prepareForGLRendering {
+  TRACE_EVENT0("browser", "AcceleratedPluginView::prepareForGLRendering");
+
+  // If we're using OpenGL, make sure it is connected.
+  if ([glContext_ view] != self) {
+    [glContext_ setView:self];
+  }
+}
+
 - (void)renewGState {
+  TRACE_EVENT0("browser", "AcceleratedPluginView::renewGState");
   // Synchronize with window server to avoid flashes or corrupt drawing.
   [[self window] disableScreenUpdatesUntilFlush];
   [self globalFrameDidChange:nil];
   [super renewGState];
 }
 
+- (void)setUpGState {
+  TRACE_EVENT0("browser", "AcceleratedPluginView::setUpGState");
+  [self prepareForGLRendering];
+}
+
+// TODO(jbates): is lockFocus needed anymore? it seems redundant with
+//               setUpGState in traces.
 - (void)lockFocus {
+  TRACE_EVENT0("browser", "AcceleratedPluginView::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_);
-  }
+  [self prepareForGLRendering];
   [glContext_ makeCurrentContext];
 }
 
 - (void)viewWillMoveToWindow:(NSWindow*)newWindow {
+  TRACE_EVENT1("browser", "AcceleratedPluginView::viewWillMoveToWindow",
+               "newWindow", newWindow);
   // Stop the display link thread while the view is not visible.
   if (newWindow) {
-    if (displayLink_ && !CVDisplayLinkIsRunning(displayLink_))
+    if (!CVDisplayLinkIsRunning(displayLink_))
       CVDisplayLinkStart(displayLink_);
   } else {
-    if (displayLink_ && CVDisplayLinkIsRunning(displayLink_))
+    if (CVDisplayLinkIsRunning(displayLink_))
       CVDisplayLinkStop(displayLink_);
+
+    // Ack pending swaps (if any):
+    CGLLockContext(cglContext_);
+    [self ackSwapBuffers:swapBuffersCount_];
+    CGLUnlockContext(cglContext_);
   }
 
   // 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];
   }
 }
 
 - (void)viewDidHide {
+  TRACE_EVENT0("browser", "AcceleratedPluginView::viewDidHide");
   [super viewDidHide];
 
   if ([[self window] respondsToSelector:@selector(underlaySurfaceRemoved)]) {
     [static_cast<id>([self window]) underlaySurfaceRemoved];
   }
 }
 
 - (void)viewDidUnhide {
+  TRACE_EVENT0("browser", "AcceleratedPluginView::viewDidUnhide");
   [super viewDidUnhide];
 
   if ([[self window] respondsToSelector:@selector(underlaySurfaceRemoved)]) {
     [static_cast<id>([self window]) underlaySurfaceAdded];
   }
 }
 
 - (void)setFrame:(NSRect)frameRect {
   TRACE_EVENT0("browser", "AcceleratedPluginViewMac::setFrame");
   [self setCachedSize:frameRect.size];
   [super setFrame:frameRect];
 }
 
 - (void)setFrameSize:(NSSize)newSize {
+  TRACE_EVENT0("browser", "AcceleratedPluginView::newSize");
   [self setCachedSize:newSize];
   [super setFrameSize:newSize];
 }
 
 - (BOOL)acceptsFirstResponder {
   // Accept first responder if the first responder isn't the RWHVMac, and if the
   // RWHVMac accepts first responder.  If the RWHVMac does not accept first
   // responder, do not accept on its behalf.
   return ([[self window] firstResponder] != [self superview] &&
           [[self superview] acceptsFirstResponder]);
 }
 
 - (BOOL)becomeFirstResponder {
   // Delegate first responder to the RWHVMac.
   [[self window] makeFirstResponder:[self superview]];
   return YES;
 }
 
 - (void)viewDidMoveToSuperview {
+  TRACE_EVENT0("browser", "AcceleratedPluginView::viewDidMoveToSuperview");
   if (![self superview])
     [self onRenderWidgetHostViewGone];
 }
 @end