Several background pattern fixes on the Mac....

chrome/browser/cocoa/tab_view.mm

 // Copyright (c) 2009 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/cocoa/tab_view.h"
 
 #include "base/logging.h"
 #include "base/nsimage_cache_mac.h"
 #import "chrome/browser/cocoa/tab_controller.h"
 #import "chrome/browser/cocoa/tab_window_controller.h"
@@ skipping 41 matching lines @@
   // Cancel any delayed requests that may still be pending (drags or hover).
   [NSObject cancelPreviousPerformRequestsWithTarget:self];
   // [self gtm_unregisterForThemeNotifications];
   [closeButton_ removeTrackingArea:closeTrackingArea_.get()];
   [super dealloc];
 }
 
 // Overridden so that mouse clicks come to this view (the parent of the
 // hierarchy) first. We want to handle clicks and drags in this class and
 // leave the background button for display purposes only.
-- (BOOL)acceptsFirstMouse:(NSEvent *)theEvent {
+- (BOOL)acceptsFirstMouse:(NSEvent*)theEvent {
   return YES;
 }
 
 - (void)adjustHoverValue {
   NSTimeInterval thisUpdate = [NSDate timeIntervalSinceReferenceDate];
 
   NSTimeInterval elapsed = thisUpdate - lastHoverUpdate_;
 
   CGFloat opacity = [self hoverAlpha];
   if (isMouseInside_) {
     opacity += elapsed / kAnimationShowDuration;
   } else {
     opacity -= elapsed / kAnimationHideDuration;
   }
 
   if (!isMouseInside_ && opacity < 0) {
     opacity = 0;
   } else if (isMouseInside_ && opacity > 1) {
     opacity = 1;
   } else {
     [self performSelector:_cmd withObject:nil afterDelay:0.02];
   }
   lastHoverUpdate_ = thisUpdate;
   [self setHoverAlpha:opacity];
 
   [self setNeedsDisplay:YES];
 }
 
-- (void)mouseEntered:(NSEvent *)theEvent {
+- (void)mouseEntered:(NSEvent*)theEvent {
   if ([theEvent trackingArea] == closeTrackingArea_) {
     [closeButton_ setImage:nsimage_cache::ImageNamed(@"close_bar_h.pdf")];
   } else {
     lastHoverUpdate_ = [NSDate timeIntervalSinceReferenceDate];
     isMouseInside_ = YES;
     [self adjustHoverValue];
     [self setNeedsDisplay:YES];
   }
 }
 
-- (void)mouseMoved:(NSEvent *)theEvent {
+- (void)mouseMoved:(NSEvent*)theEvent {
   hoverPoint_ = [self convertPoint:[theEvent locationInWindow]
                           fromView:nil];
   [self setNeedsDisplay:YES];
 }
 
-- (void)mouseExited:(NSEvent *)theEvent {
+- (void)mouseExited:(NSEvent*)theEvent {
   if ([theEvent trackingArea] == closeTrackingArea_) {
     [closeButton_ setImage:nsimage_cache::ImageNamed(@"close_bar.pdf")];
   } else {
     lastHoverUpdate_ = [NSDate timeIntervalSinceReferenceDate];
     isMouseInside_ = NO;
     [self adjustHoverValue];
     [self setNeedsDisplay:YES];
   }
 }
 
 // Determines which view a click in our frame actually hit. It's either this
 // view or our child close button.
-- (NSView *)hitTest:(NSPoint)aPoint {
+- (NSView*)hitTest:(NSPoint)aPoint {
   NSPoint viewPoint = [self convertPoint:aPoint fromView:[self superview]];
   NSRect frame = [self frame];
 
   // Reduce the width of the hit rect slightly to remove the overlap
   // between adjacent tabs.  The drawing code in TabCell has the top
   // corners of the tab inset by height*2/3, so we inset by half of
   // that here.  This doesn't completely eliminate the overlap, but it
   // works well enough.
   NSRect hitRect = NSInsetRect(frame, frame.size.height / 3.0f, 0);
   if (![closeButton_ isHidden])
     if (NSPointInRect(viewPoint, [closeButton_ frame])) return closeButton_;
   if (NSPointInRect(aPoint, hitRect)) return self;
   return nil;
 }
 
 // Returns |YES| if this tab can be torn away into a new window.
 - (BOOL)canBeDragged {
-  NSWindowController *controller = [sourceWindow_ windowController];
+  NSWindowController* controller = [sourceWindow_ windowController];
   if ([controller isKindOfClass:[TabWindowController class]]) {
     TabWindowController* realController =
         static_cast<TabWindowController*>(controller);
     return [realController isTabDraggable:self];
   }
   return YES;
 }
 
 // Find all the windows that could be a target. It has to be of the
 // appropriate class, and visible (obviously). Note that the window cannot be
 // a target for itself.
 - (NSArray*)dropTargetsForController:(TabWindowController*)dragController {
   NSMutableArray* targets = [NSMutableArray array];
   NSWindow* dragWindow = [dragController window];
   for (NSWindow* window in [NSApp windows]) {
     if (window == dragWindow) continue;
     if (![window isVisible]) continue;
-    NSWindowController *controller = [window windowController];
+    NSWindowController* controller = [window windowController];
     if ([controller isKindOfClass:[TabWindowController class]]) {
       TabWindowController* realController =
           static_cast<TabWindowController*>(controller);
       if ([realController canReceiveFrom:dragController]) {
         [targets addObject:controller];
       }
     }
   }
   return targets;
 }
@@ skipping 14 matching lines @@
 // ideas of dragging cocoa views between windows and how the Browser and
 // TabStrip models want to manage tabs.
 
 static const CGFloat kTearDistance = 36.0;
 static const NSTimeInterval kTearDuration = 0.333;
 
 // This is used to judge whether the mouse has moved during rapid closure; if it
 // has moved less than the threshold, we want to close the tab.
 static const CGFloat kRapidCloseDist = 2.5;
 
-- (void)mouseDown:(NSEvent *)theEvent {
+- (void)mouseDown:(NSEvent*)theEvent {
   NSPoint downLocation = [theEvent locationInWindow];
 
   // During the tab closure animation (in particular, during rapid tab closure),
   // we may get incorrectly hit with a mouse down. If it should have gone to the
   // close button, we send it there -- it should then track the mouse, so we
   // don't have to worry about mouse ups.
   if ([controller_ inRapidClosureMode]) {
     NSPoint hitLocation = [[self superview] convertPoint:downLocation
                                                 fromView:nil];
     if ([self hitTest:hitLocation] == closeButton_) {
@@ skipping 74 matching lines @@
     } else {
       // TODO(viettrungluu): [crbug.com/23830] We can receive right-mouse-ups
       // (and maybe even others?) for reasons I don't understand. So we
       // explicitly check for both events we're expecting, and log others. We
       // should figure out what's going on.
       LOG(WARNING) << "Spurious event received of type " << type << ".";
     }
   }
 }
 
-- (void)mouseDragged:(NSEvent *)theEvent {
+- (void)mouseDragged:(NSEvent*)theEvent {
   // Special-case this to keep the logic below simpler.
   if (moveWindowOnDrag_) {
     NSPoint thisPoint = [NSEvent mouseLocation];
     NSPoint origin = sourceWindowFrame_.origin;
     origin.x += (thisPoint.x - dragOrigin_.x);
     origin.y += (thisPoint.y - dragOrigin_.y);
     [sourceWindow_ setFrameOrigin:NSMakePoint(origin.x, origin.y)];
     return;
   }
 
@@ skipping 147 matching lines @@
   if (targetController_) {
     if (![[targetController_ window] isKeyWindow]) {
       // && ([targetDwellDate timeIntervalSinceNow] < -REQUIRED_DWELL)) {
       [[targetController_ window] orderFront:nil];
       targetDwellDate = nil;
     }
 
     // Compute where placeholder should go and insert it into the
     // destination tab strip.
     NSRect dropTabFrame = [[targetController_ tabStripView] frame];
-    TabView *draggedTabView = (TabView *)[draggedController_ selectedTabView];
+    TabView* draggedTabView = (TabView*)[draggedController_ selectedTabView];
     NSRect tabFrame = [draggedTabView frame];
     tabFrame.origin = [dragWindow_ convertBaseToScreen:tabFrame.origin];
     tabFrame.origin = [[targetController_ window]
                         convertScreenToBase:tabFrame.origin];
     tabFrame = [[targetController_ tabStripView]
                 convertRectFromBase:tabFrame];
     NSPoint point =
       [sourceWindow_ convertBaseToScreen:
        [draggedTabView convertPointToBase:NSZeroPoint]];
     [targetController_ insertPlaceholderForTab:self
@@ skipping 17 matching lines @@
       [dragWindow_ setAlphaValue:0.0];
       [[draggedController_ overlayWindow] setHasShadow:YES];
     } else {
       [dragWindow_ setAlphaValue:0.5];
       [[draggedController_ overlayWindow] setHasShadow:NO];
     }
     chromeIsVisible_ = chromeShouldBeVisible;
   }
 }
 
-- (void)mouseUp:(NSEvent *)theEvent {
+- (void)mouseUp:(NSEvent*)theEvent {
   // The drag/click is done. If the user dragged the mouse, finalize the drag
   // and clean up.
 
   // Special-case this to keep the logic below simpler.
   if (moveWindowOnDrag_)
     return;
 
   // Cancel any delayed -mouseDragged: requests that may still be pending.
   [NSObject cancelPreviousPerformRequestsWithTarget:self];
 
@@ skipping 38 matching lines @@
   [self resetDragControllers];
 }
 
 - (void)otherMouseUp:(NSEvent*)theEvent {
   // Support middle-click-to-close.
   if ([theEvent buttonNumber] == 2) {
     [controller_ closeTab:self];
   }
 }
 
-- (NSPoint)patternPhase {
-  NSPoint phase = NSZeroPoint;
-  phase.x -= [self convertRect:[self bounds] toView:nil].origin.x;
-  // offset to start pattern in upper left corner
-  phase.y += NSHeight([self bounds]) - 1;
-  return phase;
-}
-
 - (void)drawRect:(NSRect)rect {
-  [[NSGraphicsContext currentContext] saveGraphicsState];
+  NSGraphicsContext* context = [NSGraphicsContext currentContext];
+  [context saveGraphicsState];
   rect = [self bounds];
   BOOL active = [[self window] isKeyWindow] || [[self window] isMainWindow];
-  BOOL selected = [(NSButton *)self state];
+  BOOL selected = [(NSButton*)self state];
 
   // Inset by 0.5 in order to draw on pixels rather than on borders (which would
   // cause blurry pixels). Decrease height by 1 in order to move away from the
   // edge for the dark shadow.
   rect = NSInsetRect(rect, -0.5, -0.5);
   rect.origin.y -= 1;
 
   NSPoint bottomLeft = NSMakePoint(NSMinX(rect), NSMinY(rect) + 2);
   NSPoint bottomRight = NSMakePoint(NSMaxX(rect), NSMinY(rect) + 2);
   NSPoint topRight =
       NSMakePoint(NSMaxX(rect) - kInsetMultiplier * NSHeight(rect),
                   NSMaxY(rect));
   NSPoint topLeft =
       NSMakePoint(NSMinX(rect)  + kInsetMultiplier * NSHeight(rect),
                   NSMaxY(rect));
 
   float baseControlPointOutset = NSHeight(rect) * kControlPoint1Multiplier;
   float bottomControlPointInset = NSHeight(rect) * kControlPoint2Multiplier;
 
   // Outset many of these values by 1 to cause the fill to bleed outside the
   // clip area.
-  NSBezierPath *path = [NSBezierPath bezierPath];
+  NSBezierPath* path = [NSBezierPath bezierPath];
   [path moveToPoint:NSMakePoint(bottomLeft.x - 1, bottomLeft.y - 2)];
   [path lineToPoint:NSMakePoint(bottomLeft.x - 1, bottomLeft.y)];
   [path lineToPoint:bottomLeft];
   [path curveToPoint:topLeft
        controlPoint1:NSMakePoint(bottomLeft.x + baseControlPointOutset,
                                  bottomLeft.y)
        controlPoint2:NSMakePoint(topLeft.x - bottomControlPointInset,
                                  topLeft.y)];
   [path lineToPoint:topRight];
   [path curveToPoint:bottomRight
        controlPoint1:NSMakePoint(topRight.x + bottomControlPointInset,
                                  topRight.y)
        controlPoint2:NSMakePoint(bottomRight.x - baseControlPointOutset,
                                  bottomRight.y)];
   [path lineToPoint:NSMakePoint(bottomRight.x + 1, bottomRight.y)];
   [path lineToPoint:NSMakePoint(bottomRight.x + 1, bottomRight.y - 2)];
 
-  GTMTheme *theme = [self gtm_theme];
+  GTMTheme* theme = [self gtm_theme];
+
+  // Setting the pattern phase
+  NSPoint phase = [self gtm_themePatternPhase];
+  [context setPatternPhase:phase];
 
   if (!selected) {
-    NSColor *windowColor =
+    NSColor* windowColor =
         [theme backgroundPatternColorForStyle:GTMThemeStyleWindow
                                         state:GTMThemeStateActiveWindow];
     if (windowColor) {
       [windowColor set];
-
-      [[NSGraphicsContext currentContext] setPatternPhase:[self patternPhase]];
     } else {
-      NSPoint phase = [self patternPhase];
-      phase.y += 1;
-      [[NSGraphicsContext currentContext] setPatternPhase:phase];
       [[NSColor windowBackgroundColor] set];
     }
 
     [path fill];
 
-    NSColor *tabColor =
+    NSColor* tabColor =
         [theme backgroundPatternColorForStyle:GTMThemeStyleTabBarDeselected
                                         state:GTMThemeStateActiveWindow];
     if (tabColor) {
       [tabColor set];
-      [[NSGraphicsContext currentContext] setPatternPhase:[self patternPhase]];
     } else {
       [[NSColor colorWithCalibratedWhite:1.0 alpha:0.3] set];
     }
     [path fill];
-
   }
 
-  [[NSGraphicsContext currentContext] saveGraphicsState];
+  [context saveGraphicsState];
   [path addClip];
 
   if (selected || hoverAlpha_ > 0) {
     // Draw the background.
     CGFloat backgroundAlpha = hoverAlpha_ * 0.5;
-    [[NSGraphicsContext currentContext] saveGraphicsState];
-    CGContextRef context =
-        (CGContextRef)([[NSGraphicsContext currentContext] graphicsPort]);
-    CGContextBeginTransparencyLayer(context, 0);
+    [context saveGraphicsState];
+    CGContextRef cgContext =
+        (CGContextRef)([context graphicsPort]);
+    CGContextBeginTransparencyLayer(cgContext, 0);
     if (!selected)
-      CGContextSetAlpha(context, backgroundAlpha);
+      CGContextSetAlpha(cgContext, backgroundAlpha);
     [path addClip];
-    [super drawRect:rect];
+    [context saveGraphicsState];
+    [super drawBackground];
+    [context restoreGraphicsState];
 
     // Draw a mouse hover gradient for the default themes
     if (!selected) {
       if (![theme backgroundImageForStyle:GTMThemeStyleTabBarDeselected
                                     state:GTMThemeStateActiveWindow]) {
         scoped_nsobject<NSGradient> glow([NSGradient alloc]);
         [glow initWithStartingColor:[NSColor colorWithCalibratedWhite:1.0
                                                                 alpha:1.0 *
                                                                     hoverAlpha_]
                         endingColor:[NSColor colorWithCalibratedWhite:1.0
                                                                 alpha:0.0]];
 
         NSPoint point = hoverPoint_;
         point.y = NSHeight(rect);
         [glow drawFromCenter:point
                       radius:0
                     toCenter:point
                       radius:NSWidth(rect)/3
                      options:NSGradientDrawsBeforeStartingLocation];
 
         [glow drawInBezierPath:path relativeCenterPosition:hoverPoint_];
       }
     }
 
-    CGContextEndTransparencyLayer(context);
-    [[NSGraphicsContext currentContext] restoreGraphicsState];
+    CGContextEndTransparencyLayer(cgContext);
+    [context restoreGraphicsState];
   }
 
   // Draw the top inner highlight.
   NSAffineTransform* highlightTransform = [NSAffineTransform transform];
   [highlightTransform translateXBy:1 yBy:-1];
   scoped_nsobject<NSBezierPath> highlightPath([path copy]);
   [highlightPath transformUsingAffineTransform:highlightTransform];
   [[NSColor colorWithCalibratedWhite:1.0 alpha:0.2 + 0.3 * hoverAlpha_]
       setStroke];
   [highlightPath stroke];
 
-  [[NSGraphicsContext currentContext] restoreGraphicsState];
+  [context restoreGraphicsState];
 
   // Draw the top stroke.
-  [[NSGraphicsContext currentContext] saveGraphicsState];
+  [context saveGraphicsState];
   if (selected) {
     [[NSColor colorWithDeviceWhite:0.0 alpha:active ? 0.3 : 0.15] set];
   } else {
     [[NSColor colorWithDeviceWhite:0.0 alpha:active ? 0.2 : 0.15] set];
     [[NSBezierPath bezierPathWithRect:NSOffsetRect(rect, 0, 2.5)] addClip];
   }
   [path setLineWidth:1.0];
   [path stroke];
-  [[NSGraphicsContext currentContext] restoreGraphicsState];
+  [context restoreGraphicsState];
 
   // Draw the bottom border.
   if (!selected) {
     [path addClip];
     NSRect borderRect, contentRect;
     NSDivideRect(rect, &borderRect, &contentRect, 2.5, NSMinYEdge);
     [[NSColor colorWithDeviceWhite:0.0 alpha:active ? 0.3 : 0.15] set];
     NSRectFillUsingOperation(borderRect, NSCompositeSourceOver);
   }
-  [[NSGraphicsContext currentContext] restoreGraphicsState];
+  [context restoreGraphicsState];
 }
 
 // Called when the user hits the right mouse button (or control-clicks) to
 // show a context menu.
 - (void)rightMouseDown:(NSEvent*)theEvent {
   [NSMenu popUpContextMenu:[self menu] withEvent:theEvent forView:self];
 }
 
+- (void)viewDidMoveToWindow {
+  [super viewDidMoveToWindow];
+  if ([self window]) {
+    [controller_ updateTitleColor];
+  }
+}
+
 @end