Fix window shadows.

ui/base/cocoa/underlay_opengl_hosting_window.mm

 // Copyright (c) 2012 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 "ui/base/cocoa/underlay_opengl_hosting_window.h"
 
+#import <objc/runtime.h>
+
 #include "base/logging.h"
+#include "base/mac/mac_util.h"
+#include "base/mac/scoped_nsautorelease_pool.h"
+#include "base/memory/scoped_nsobject.h"
+
+@interface NSWindow (UndocumentedAPI)
+// Normally, punching a hole in a window by painting a subview with a
+// transparent color causes the shadow for that area to also not be present.
+// That feature is "content has shadow", which means that shadows are effective
+// even in the content area of the window. If, however, "content has shadow" is
+// turned off, then the transparent area of the content casts a shadow. The one
+// tricky part is that even if "content has shadow" is turned off, "the content"
+// is defined as being the scanline from the leftmost opaque part to the
+// rightmost opaque part.  Therefore, to force the entire window to have a
+// shadow, make sure that for the entire content region, there is an opaque area
+// on the right and left edge of the window.
+- (void)_setContentHasShadow:(BOOL)shadow;
+@end
+
+@interface OpaqueView : NSView
+@end
+
+@implementation OpaqueView
+- (void)drawRect:(NSRect)r {
+  [[NSColor blackColor] set];
+  NSRectFill(r);
+}
+@end
+
+namespace {
+
+NSComparisonResult OpaqueViewsOnTop(id view1, id view2, void* context) {

[jbates, 2012/04/10 17:54:00]

If view1 and view2 are both OpaqueView, then:
  OpaqueViewsOnTop(view1, view2) == NSOrderedDescending
  OpaqueViewsOnTop(view2, view1) == NSOrderedDescending
Could check for equality first?

[Avi (use Gerrit), 2012/04/10 18:34:46]

Probably a good idea.

+  if ([view1 isKindOfClass:[OpaqueView class]])
+    return NSOrderedDescending;
+  if ([view2 isKindOfClass:[OpaqueView class]])
+    return NSOrderedAscending;
+  return NSOrderedSame;
+}
+
+void RootDidAddSubview(id self, SEL _cmd, NSView* subview) {
+  // Make sure the opaques are on top.
+  [self sortSubviewsUsingFunction:OpaqueViewsOnTop context:NULL];
+}
+
+}  // namespace
 
 @implementation UnderlayOpenGLHostingWindow
 
-- (void)underlaySurfaceAdded {
-  DCHECK_GE(underlaySurfaceCount_, 0);
-  ++underlaySurfaceCount_;
++ (void)load {
+  base::mac::ScopedNSAutoreleasePool pool;
 
-  // We're having the OpenGL surface render under the window, so the window
-  // needs to be not opaque.
-  if (underlaySurfaceCount_ == 1)
-    [self setOpaque:NO];
+  // On 10.8+ the background for textured windows are no longer drawn by
+  // NSGrayFrame, and NSThemeFrame is used instead <http://crbug.com/114745>.
+  Class borderViewClass = NSClassFromString(
+      base::mac::IsOSMountainLionOrLater() ? @"NSThemeFrame" : @"NSGrayFrame");
+  DCHECK(borderViewClass);
+  if (!borderViewClass) return;
+
+  // Install callback for added views.
+  Method m = class_getInstanceMethod([NSView class], @selector(didAddSubview:));
+  DCHECK(m);
+  if (m) {
+    BOOL didAdd = class_addMethod(borderViewClass,
+                                  @selector(didAddSubview:),
+                                  reinterpret_cast<IMP>(&RootDidAddSubview),
+                                  method_getTypeEncoding(m));
+    DCHECK(didAdd);
+  }
 }
 
-- (void)underlaySurfaceRemoved {
-  --underlaySurfaceCount_;
-  DCHECK_GE(underlaySurfaceCount_, 0);
+- (id)initWithContentRect:(NSRect)contentRect
+                styleMask:(NSUInteger)windowStyle
+                  backing:(NSBackingStoreType)bufferingType
+                    defer:(BOOL)deferCreation {
+  if ((self = [super initWithContentRect:contentRect
+                               styleMask:windowStyle
+                                 backing:bufferingType
+                                   defer:deferCreation])) {
+    // The invisible opaque area technique only works > 10.5. Fortunately, hole
+    // punching is used only when IOSurfaces are used to transport, and that's
+    // also only on > 10.5.
+    if (base::mac::IsOSSnowLeopardOrLater()) {
+      [self setOpaque:NO];
+      [self _setContentHasShadow:NO];
 
-  if (underlaySurfaceCount_ == 0)
-    [self setOpaque:YES];
+      NSView* rootView = [[self contentView] superview];
+      NSRect rootBounds = [rootView bounds];
+
+      const CGFloat kEdgeInset = 16;
+
+      scoped_nsobject<NSView> leftOpaque(
+          [[OpaqueView alloc] initWithFrame:
+              NSMakeRect(NSMinX(rootBounds), NSMinY(rootBounds) + kEdgeInset,
+                         1, NSHeight(rootBounds) - 2 * kEdgeInset)]);
+      [rootView addSubview:leftOpaque];
+      [leftOpaque setAutoresizingMask:NSViewMaxXMargin|NSViewHeightSizable];
+      [leftOpaque setAlphaValue:0.002f];

[jbates, 2012/04/10 17:54:00]

Is this chosen on purpose to round to zero when converted to uint8? Assuming OSX
is drawing windows via 8-bit-per-color shaders, 0.002 => (uint8)(255*(0.002)) =>
0

Would be interesting to verify that with a screenshot using the old code and the
new (but a thicker line so it overlaps with the tab contents a bit) on an
accelerated tab with a white background (and compare the white pixel values).

[Avi (use Gerrit), 2012/04/10 18:34:46]

You ascribe to me far more cleverness than is deserved. I selected 0.002 because
that was the smallest value (with three digits) that still had the effect of
preserving the window background.

+
+      scoped_nsobject<NSView> rightOpaque([[OpaqueView alloc] initWithFrame:
+          NSMakeRect(NSMaxX(rootBounds) - 1, NSMinY(rootBounds) + kEdgeInset,
+                     1, NSHeight(rootBounds) - 2 * kEdgeInset)]);
+      [rootView addSubview:rightOpaque];
+      [rightOpaque setAutoresizingMask:NSViewMinXMargin|NSViewHeightSizable];
+      [rightOpaque setAlphaValue:0.002f];
+    }
+  }
+
+  return self;
 }
 
 @end