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_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;
   }
 
+  CGLLockContext(cglContext_);
+
   [self drawView];
 
   acknowledgedSwapBuffersCount_ = currentSwapBuffersCount;
+  // Locked here because renderWidgetHostView_ is set to NULL on another thread.

[Ken Russell (switch to Gerrit), 2011/06/10 01:30:12]

Maybe move this comment next to the call to CGLLockContext.

[jbates, 2011/06/11 02:00:44]

Done.

   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,
     CVOptionFlags* flagsOut,
@@ skipping 98 matching lines @@
     return;
 
   CGLLockContext(cglContext_);
   // 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_);

[Ken Russell (switch to Gerrit), 2011/06/10 01:30:12]

This is unnecessary. The first thing drawView does is lock the context.

[jbates, 2011/06/11 02:00:44]

I meant to remove the drawView mutex locking, since I had to move it outside for
the other case. Although it is recursive, seems best to avoid that when
possible.

   [self drawView];
+  CGLUnlockContext(cglContext_);

[Ken Russell (switch to Gerrit), 2011/06/10 01:30:12]

Unnecessary.

 }
 
 - (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 21 matching lines @@
   }
 }
 
 - (void)renewGState {
   // Synchronize with window server to avoid flashes or corrupt drawing.
   [[self window] disableScreenUpdatesUntilFlush];
   [self globalFrameDidChange:nil];
   [super renewGState];
 }
 
-- (void)lockFocus {
-  [super lockFocus];
+- (void)setViewForGL {
+  TRACE_EVENT0("browser", "AcceleratedPluginView::setViewForGL");
 
   // 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_);
   }
+}
+
+- (void)lockFocus {
+  TRACE_EVENT0("browser", "AcceleratedPluginView::lockFocus");
+  [super lockFocus];
+  [self setViewForGL];
   [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_))
       CVDisplayLinkStart(displayLink_);
   } else {
     if (displayLink_ && CVDisplayLinkIsRunning(displayLink_))
       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];
   }
 }
 
 - (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