Mac: Well-behaved accelerated plugins, actual fix

chrome/browser/renderer_host/render_widget_host_view_mac.mm

 // Copyright (c) 2010 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 "app/surface/io_surface_support_mac.h"
 #import "base/chrome_application_mac.h"
@@ skipping 117 matching lines @@
   TSMRemoveDocumentProperty(0, kTSMDocumentEnabledInputSourcesPropertyTag);
 }
 
 }  // namespace
 
 // AcceleratedPluginView ------------------------------------------------------
 
 // This subclass of NSView hosts the output of accelerated plugins on
 // the page.
 
+// Informat protocol implemented by windows that need to be informed explicitly
+// about underlay surfaces.
+@protocol UnderlayableSurface

[pink (ping after 24hrs), 2010/08/24 17:18:55]

If it's a @protocol, then it's formal. s/Informal//

[Nico, 2010/08/24 17:27:55]

Not really, since nothing implements this protocol. It's just here to get rid of
the "unknow method -underlaySurfaceAdded, assuming int return type and ...
parameters" warning.

+- (void)underlaySurfaceAdded;
+- (void)underlaySurfaceRemoved;
+@end
+
 @interface AcceleratedPluginView : NSView {
   scoped_nsobject<NSOpenGLPixelFormat> glPixelFormat_;
   CGLPixelFormatObj cglPixelFormat_;  // weak, backed by |glPixelFormat_|.
   scoped_nsobject<NSOpenGLContext> glContext_;
   CGLContextObj cglContext_;  // weak, backed by |glContext_|.
 
   CVDisplayLinkRef displayLink_;  // Owned by us.
 
   RenderWidgetHostViewMac* renderWidgetHostView_;  // weak
   gfx::PluginWindowHandle pluginHandle_;  // weak
 
   // True if the backing IO surface was updated since we last painted.
   BOOL surfaceWasSwapped_;
+
+  // True if the surface might contain transparent pixels that need to be
+  // blended.
+  BOOL canDrawTransparent_;
 }
 
 - (id)initWithRenderWidgetHostViewMac:(RenderWidgetHostViewMac*)r
-                         pluginHandle:(gfx::PluginWindowHandle)pluginHandle;
+                         pluginHandle:(gfx::PluginWindowHandle)pluginHandle
+                   canDrawTransparent:(BOOL)canDrawTransparent;
 - (void)drawView;
 
 // This _must_ be atomic, since it's accessed from several threads.
 @property BOOL surfaceWasSwapped;
 @end
 
 @implementation AcceleratedPluginView : NSView
 @synthesize surfaceWasSwapped = surfaceWasSwapped_;
 
 - (CVReturn)getFrameForTime:(const CVTimeStamp*)outputTime {
@@ skipping 15 matching lines @@
     const CVTimeStamp* now,
     const CVTimeStamp* outputTime,
     CVOptionFlags flagsIn,
     CVOptionFlags* flagsOut,
     void* displayLinkContext) {
   CVReturn result =
       [(AcceleratedPluginView*)displayLinkContext getFrameForTime:outputTime];
   return result;
 }
 
+- (BOOL)drawAsUnderlaySurface {
+  // Transparent plugins really need to be handled by the GPU process. Until
+  // then, we have the coice of two evils:

[pink (ping after 24hrs), 2010/08/24 17:18:55]

choice

[Nico, 2010/08/24 17:27:55]

will fix when i touch this file again (probably soon)

+  // 1.) They are drawn as underlay surface, blending with whatever is behind
+  //     the browser window (instead of blending with the webpage as intended)
+  // 2.) They are blended with the web page but drawn on top of sibling windows
+  //     such as the find bar and the fullscreen window overlay.
+  // Option 2 seems less bad, so don't show transparent plugins as underlays.
+  //
+  // Note that this never happens in practice at the moment, because
+  // |canDrawTransparent| will only be true for flash with wmode=transparent and
+  // sliverlight with a transparent background, and these don't use
+  // CoreAnimation when they're transparent.
+  return !canDrawTransparent_ && !CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kDisableHolePunching);
+}
+
 - (id)initWithRenderWidgetHostViewMac:(RenderWidgetHostViewMac*)r
-                         pluginHandle:(gfx::PluginWindowHandle)pluginHandle {
+                         pluginHandle:(gfx::PluginWindowHandle)pluginHandle
+                   canDrawTransparent:(BOOL)canDrawTransparent {
   if ((self = [super initWithFrame:NSZeroRect])) {
     renderWidgetHostView_ = r;
     pluginHandle_ = pluginHandle;
+    canDrawTransparent_ = canDrawTransparent;
 
     [self setAutoresizingMask:NSViewMaxXMargin|NSViewMinYMargin];
 
     NSOpenGLPixelFormatAttribute attributes[] =
         { NSOpenGLPFAAccelerated, NSOpenGLPFADoubleBuffer, 0};
 
     glPixelFormat_.reset([[NSOpenGLPixelFormat alloc]
         initWithAttributes:attributes]);
     glContext_.reset([[NSOpenGLContext alloc] initWithFormat:glPixelFormat_
                                                 shareContext:nil]);
 
+    if ([self drawAsUnderlaySurface]) {
+      // We "punch a hole" in the window, and have the WindowServer render the
+      // OpenGL surface underneath so we can draw over it.
+      GLint belowWindow = -1;
+      [glContext_ setValues:&belowWindow forParameter:NSOpenGLCPSurfaceOrder];
+    }
+
     cglContext_ = (CGLContextObj)[glContext_ CGLContextObj];
     cglPixelFormat_ = (CGLPixelFormatObj)[glPixelFormat_ CGLPixelFormatObj];
 
     // Draw at beam vsync.
     GLint 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_);
     CVDisplayLinkStart(displayLink_);
   }
   return self;
 }
 
 - (void)drawView {
   // Called on a background thread. Synchronized via the CGL context lock.
   CGLLockContext(cglContext_);
 
   renderWidgetHostView_->DrawAcceleratedSurfaceInstance(
       cglContext_, pluginHandle_);
 
   CGLFlushDrawable(cglContext_);
   CGLUnlockContext(cglContext_);
 }
 
 - (void)drawRect:(NSRect)rect {
+  if ([self drawAsUnderlaySurface]) {
+    const NSRect* dirtyRects;
+    int dirtyRectCount;
+
+    [self getRectsBeingDrawn:&dirtyRects count:&dirtyRectCount];
+    // Punch a hole so that the OpenGL view shows through.
+    [[NSColor clearColor] set];
+    NSRectFillList(dirtyRects, dirtyRectCount);
+  }
+
   [self drawView];
 }
 
 - (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 33 matching lines @@
               object:self];
   }
   [glContext_ makeCurrentContext];
 }
 
 - (void)dealloc {
   CVDisplayLinkRelease(displayLink_);
   [[NSNotificationCenter defaultCenter] removeObserver:self];
   [super dealloc];
 }
+
+- (void)viewWillMoveToWindow:(NSWindow*)newWindow {
+  if (![self drawAsUnderlaySurface]) {
+    return;
+  }
+
+  if ([self window] &&

[pink (ping after 24hrs), 2010/08/24 17:18:55]

do you need the extra window null checks? [nil respondsToSelector:] is always
NO, right?

[Nico, 2010/08/24 17:27:55]

i don't need them, but i thought it's clearer.

since both stuart and you complained, i guess i'll remove them when i touch this
file the next time :-P

+      [[self window] respondsToSelector:@selector(underlaySurfaceRemoved)]) {
+    [static_cast<id>([self window]) underlaySurfaceRemoved];
+  }
+
+  if (newWindow &&
+      [newWindow respondsToSelector:@selector(underlaySurfaceAdded)]) {
+    [static_cast<id>(newWindow) underlaySurfaceAdded];
+  }
+}
 @end
 
 // RenderWidgetHostView --------------------------------------------------------
 
 // static
 RenderWidgetHostView* RenderWidgetHostView::CreateViewForWidget(
     RenderWidgetHost* widget) {
   return new RenderWidgetHostViewMac(widget);
 }
 
@@ skipping 456 matching lines @@
 
 void RenderWidgetHostViewMac::KillSelf() {
   if (shutdown_factory_.empty()) {
     [cocoa_view_ setHidden:YES];
     MessageLoop::current()->PostTask(FROM_HERE,
         shutdown_factory_.NewRunnableMethod(
             &RenderWidgetHostViewMac::ShutdownHost));
   }
 }
 
-gfx::PluginWindowHandle
-RenderWidgetHostViewMac::AllocateFakePluginWindowHandle(bool opaque,
-                                                        bool root) {
+gfx::PluginWindowHandle RenderWidgetHostViewMac::AllocateFakePluginWindowHandle(
+    bool opaque, bool can_draw_transparent, bool root) {
   // Create an NSView to host the plugin's/compositor's pixels.
   gfx::PluginWindowHandle handle =
       plugin_container_manager_.AllocateFakePluginWindowHandle(opaque, root);
 
-  scoped_nsobject<NSView> plugin_view(
-      [[AcceleratedPluginView alloc] initWithRenderWidgetHostViewMac:this
-                                                        pluginHandle:handle]);
+  scoped_nsobject<NSView> plugin_view([[AcceleratedPluginView alloc]
+      initWithRenderWidgetHostViewMac:this
+                         pluginHandle:handle
+                   canDrawTransparent:can_draw_transparent]);
   [plugin_view setHidden:YES];
 
   [cocoa_view_ addSubview:plugin_view];
   plugin_views_[handle] = plugin_view;
 
   return handle;
 }
 
 void RenderWidgetHostViewMac::DestroyFakePluginWindowHandle(
     gfx::PluginWindowHandle window) {
@@ skipping 1514 matching lines @@
   NSArray* toDeclare = [NSArray arrayWithObject:NSStringPboardType];
   [pboard declareTypes:toDeclare owner:nil];
   return [pboard setString:text forType:NSStringPboardType];
 }
 
 - (BOOL)readSelectionFromPasteboard:(NSPasteboard*)pboard {
   return NO;
 }
 
 @end