[Mac] Rubber-banding on Lion.

chrome/browser/renderer_host/render_widget_host_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.
 
 #include <QuartzCore/QuartzCore.h>
 
 #include "chrome/browser/renderer_host/render_widget_host_view_mac.h"
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
+#include "base/mac/mac_util.h"
 #include "base/mac/scoped_cftyperef.h"
 #import "base/mac/scoped_nsautorelease_pool.h"
 #include "base/metrics/histogram.h"
 #import "base/memory/scoped_nsobject.h"
 #include "base/string_util.h"
 #include "base/sys_info.h"
 #include "base/sys_string_conversions.h"
 #include "chrome/browser/browser_trial.h"
 #import "chrome/browser/renderer_host/accelerated_plugin_view_mac.h"
 #import "chrome/browser/renderer_host/text_input_client_mac.h"
@@ skipping 16 matching lines @@
 #include "content/common/gpu/gpu_messages.h"
 #include "content/common/native_web_keyboard_event.h"
 #include "content/common/plugin_messages.h"
 #include "content/common/view_messages.h"
 #include "skia/ext/platform_canvas.h"
 #import "third_party/mozilla/ComplexTextInputPanel.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/mac/WebInputEventFactory.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebInputEvent.h"
 #include "ui/gfx/point.h"
+#include "ui/gfx/scoped_ns_graphics_context_save_gstate_mac.h"
 #include "ui/gfx/surface/io_surface_support_mac.h"
 #include "webkit/glue/webaccessibility.h"
 #include "webkit/plugins/npapi/webplugin.h"
 
 using WebKit::WebInputEvent;
 using WebKit::WebInputEventFactory;
 using WebKit::WebMouseEvent;
 using WebKit::WebMouseWheelEvent;
+using WebKit::WebGestureEvent;
 
 static inline int ToWebKitModifiers(NSUInteger flags) {
   int modifiers = 0;
   if (flags & NSControlKeyMask) modifiers |= WebInputEvent::ControlKey;
   if (flags & NSShiftKeyMask) modifiers |= WebInputEvent::ShiftKey;
   if (flags & NSAlternateKeyMask) modifiers |= WebInputEvent::AltKey;
   if (flags & NSCommandKeyMask) modifiers |= WebInputEvent::MetaKey;
   return modifiers;
 }
 
 // Private methods:
 @interface RenderWidgetHostViewCocoa ()
 @property(nonatomic, assign) NSRange selectedRange;
 @property(nonatomic, assign) NSRange markedRange;
 
 + (BOOL)shouldAutohideCursorForEvent:(NSEvent*)event;
 - (id)initWithRenderWidgetHostViewMac:(RenderWidgetHostViewMac*)r;
 - (void)keyEvent:(NSEvent*)theEvent wasKeyEquivalent:(BOOL)equiv;
 - (void)cancelChildPopups;
 - (void)checkForPluginImeCancellation;
 @end
 
 // This API was published since 10.6. Provide the declaration so it can be
-// // called below when building with the 10.5 SDK.
+// called below when building with the 10.5 SDK.
 #if MAC_OS_X_VERSION_MAX_ALLOWED <= MAC_OS_X_VERSION_10_5
 @class NSTextInputContext;
 @interface NSResponder (AppKitDetails)
 - (NSTextInputContext *)inputContext;
+- (void)beginGestureWithEvent:(NSEvent*)event;
+- (void)endGestureWithEvent:(NSEvent*)event;
 @end
 #endif
 
+// Undocumented Lion method to get the pattern for the over-scroll area.
+@interface NSColor (LionSekretAPI)
++ (NSImage*)_linenPatternImage;
+@end
+
+// NSEvent subtype for scroll gestures events.
+static const short kIOHIDEventTypeScroll = 6;
+
 namespace {
 
 // Maximum number of characters we allow in a tooltip.
 const size_t kMaxTooltipLength = 1024;
 
 // TODO(suzhe): Upstream this function.
 WebKit::WebColor WebColorFromNSColor(NSColor *color) {
   CGFloat r, g, b, a;
   [color getRed:&r green:&g blue:&b alpha:&a];
 
@@ skipping 1108 matching lines @@
     [self confirmComposition];
   }
 
   const WebMouseEvent& event =
       WebInputEventFactory::mouseEvent(theEvent, self);
 
   if (renderWidgetHostView_->render_widget_host_)
     renderWidgetHostView_->render_widget_host_->ForwardMouseEvent(event);
 }
 
+- (void)beginGestureWithEvent:(NSEvent*)event {
+  if (base::mac::IsOSLionOrLater() &&
+      [event subtype] == kIOHIDEventTypeScroll &&
+      renderWidgetHostView_->render_widget_host_) {
+    WebGestureEvent webEvent = WebInputEventFactory::gestureEvent(event, self);
+    renderWidgetHostView_->render_widget_host_->ForwardGestureEvent(webEvent);
+  }
+
+  // Forward the gesture event to the next responder so that the browser window
+  // controller has a chance to act on back/forward gestures.
+  [[self nextResponder] beginGestureWithEvent:event];
+}
+
+- (void)endGestureWithEvent:(NSEvent*)event {
+  if (base::mac::IsOSLionOrLater() &&
+      [event subtype] == kIOHIDEventTypeScroll &&
+      renderWidgetHostView_->render_widget_host_) {
+    WebGestureEvent webEvent = WebInputEventFactory::gestureEvent(event, self);
+    renderWidgetHostView_->render_widget_host_->ForwardGestureEvent(webEvent);
+  }
+
+  // Forward the gesture event to the next responder so that the browser window
+  // controller has a chance to act on back/forward gestures.
+  [[self nextResponder] endGestureWithEvent:event];
+}
+
 - (BOOL)performKeyEquivalent:(NSEvent*)theEvent {
   // |performKeyEquivalent:| is sent to all views of a window, not only down the
   // responder chain (cf. "Handling Key Equivalents" in
   // http://developer.apple.com/mac/library/documentation/Cocoa/Conceptual/EventOverview/HandlingKeyEvents/HandlingKeyEvents.html
   // ). We only want to handle key equivalents if we're first responder.
   if ([[self window] firstResponder] != self)
     return NO;
 
   // If we return |NO| from this function, cocoa will send the key event to
   // the menu and only if the menu does not process the event to |keyDown:|. We
@@ skipping 16 matching lines @@
   return YES;
 }
 
 - (BOOL)_wantsKeyDownForEvent:(NSEvent*)event {
   // This is a SPI that AppKit apparently calls after |performKeyEquivalent:|
   // returned NO. If this function returns |YES|, Cocoa sends the event to
   // |keyDown:| instead of doing other things with it. Ctrl-tab will be sent
   // to us instead of doing key view loop control, ctrl-left/right get handled
   // correctly, etc.
   // (However, there are still some keys that Cocoa swallows, e.g. the key
-  // equivalent that Cocoa uses for toggling the input langauge. In this case,
+  // equivalent that Cocoa uses for toggling the input language. In this case,
   // that's actually a good thing, though -- see http://crbug.com/26115 .)
   return YES;
 }
 
 - (void)keyEvent:(NSEvent*)theEvent {
   [self keyEvent:theEvent wasKeyEquivalent:NO];
 }
 
 - (void)keyEvent:(NSEvent*)theEvent wasKeyEquivalent:(BOOL)equiv {
   DCHECK([theEvent type] != NSKeyDown ||
@@ skipping 298 matching lines @@
       y += height;
       height = -height;
     }
 
     NSRect r = [self flipRectToNSRect:gfx::Rect(x, y, width, height)];
     [[NSColor whiteColor] set];
     NSRectFill(r);
   }
 }
 
+- (void)fillRect:(NSRect)rect withPattern:(NSImage*)patternImage {
+  if (NSIsEmptyRect(rect))
+    return;
+
+  NSColor* patternColor = [NSColor colorWithPatternImage:patternImage];
+  [patternColor set];
+  NSRectFill(rect);
+}
+
+- (void)drawShadow:(NSShadow*)shadow
+          withRect:(NSRect)rect
+              clip:(NSRect)clipRect {
+  gfx::ScopedNSGraphicsContextSaveGState scopedGState;
+  NSBezierPath* drawingPath = [NSBezierPath bezierPathWithRect:rect];
+  [shadow set];
+  [[NSColor blackColor] set];
+  [[NSBezierPath bezierPathWithRect:clipRect] addClip];
+  [drawingPath fill];
+}
+
+- (NSRect)computeVisibleContentRect {
+  const RenderWidgetHost* rwh = renderWidgetHostView_->render_widget_host_;
+  gfx::Point offset = rwh->last_scroll_offset();
+  gfx::Size size = rwh->contents_size();
+  NSRect contentRect =
+      NSMakeRect(-offset.x(), -offset.y(), size.width(), size.height());
+  NSRect frameRect = [self frame];
+  frameRect.origin = NSMakePoint(0, 0);
+  return NSIntersectionRect(frameRect, contentRect);
+}
+
+- (void)fillOverScrollAreas:(NSRect)dirtyRect {
+  if (![NSColor respondsToSelector:@selector(_linenPatternImage)])
+    return;
+
+  NSRect visibleContentRect = [self computeVisibleContentRect];
+  NSSize frameSize = [self frame].size;
+  bool hasHorizontalOverflow = (NSWidth(visibleContentRect) < frameSize.width);
+  bool hasVerticalOverflow = (NSHeight(visibleContentRect) < frameSize.height);
+
+  if (!hasHorizontalOverflow && !hasVerticalOverflow)
+    return;
+
+  NSRect xRect = NSMakeRect(0,
+                            0,
+                            frameSize.width - NSWidth(visibleContentRect),
+                            frameSize.height);
+  NSRect yRect = NSMakeRect(0,
+                            0,
+                            frameSize.width,
+                            frameSize.height - NSHeight(visibleContentRect));
+  NSImage* background = [NSColor _linenPatternImage];
+  scoped_nsobject<NSShadow> shadow([[NSShadow alloc] init]);
+  [shadow.get() setShadowColor:[NSColor blackColor]];
+  [shadow setShadowBlurRadius:5];
+
+  if (hasHorizontalOverflow) {
+    NSRect shadowRect;
+    if (visibleContentRect.origin.x > 0) {
+      shadowRect = xRect;
+      shadowRect.origin.x += NSWidth(shadowRect);
+    } else {
+      xRect.origin.x = NSWidth(visibleContentRect);
+      shadowRect = xRect;
+      shadowRect.origin.x -= 1;
+    }
+    shadowRect.size.width = 1;
+    NSRect intersectRect = NSIntersectionRect(dirtyRect, xRect);
+    [self fillRect:intersectRect withPattern:background];
+    [self drawShadow:shadow.get() withRect:shadowRect clip:intersectRect];
+  }
+
+  if (hasVerticalOverflow) {
+    NSRect shadowRect = visibleContentRect;
+    if (visibleContentRect.origin.y > 0) {
+      yRect.origin.y = NSHeight(visibleContentRect);
+      shadowRect.origin.y = yRect.origin.y - 1;
+    } else {
+      shadowRect.origin.y = yRect.origin.y + NSHeight(yRect);
+    }
+    shadowRect.size.height = 1;
+    NSRect intersectRect = NSIntersectionRect(dirtyRect, yRect);
+    [self fillRect:intersectRect withPattern:background];
+    [self drawShadow:shadow.get() withRect:shadowRect clip:intersectRect];
+  }
+}
+
 - (void)drawRect:(NSRect)dirtyRect {
   if (!renderWidgetHostView_->render_widget_host_) {
     // TODO(shess): Consider using something more noticable?
     [[NSColor whiteColor] set];
     NSRectFill(dirtyRect);
     return;
   }
 
   const gfx::Rect damagedRect([self flipNSRectToRect:dirtyRect]);
 
@@ skipping 55 matching lines @@
             CGBitmapContextCreateImage(backingStore->cg_bitmap()));
         CGRect imageRect = bitmapRect.ToCGRect();
         imageRect.origin.y = yOffset;
         CGContextDrawImage(context, imageRect, image);
       }
     }
 
     // Fill the remaining portion of the damagedRect with white
     [self fillBottomRightRemainderOfRect:bitmapRect dirtyRect:damagedRect];
 
+    // Fill the over-scroll areas, if any, with the appropriate pattern.
+    [self fillOverScrollAreas:dirtyRect];
+
     if (!renderWidgetHostView_->whiteout_start_time_.is_null()) {
       base::TimeDelta whiteout_duration = base::TimeTicks::Now() -
           renderWidgetHostView_->whiteout_start_time_;
       UMA_HISTOGRAM_TIMES("MPArch.RWHH_WhiteoutDuration", whiteout_duration);
 
       // Reset the start time to 0 so that we start recording again the next
       // time the backing store is NULL...
       renderWidgetHostView_->whiteout_start_time_ = base::TimeTicks();
     }
     if (!renderWidgetHostView_->tab_switch_paint_time_.is_null()) {
@@ skipping 227 matching lines @@
     RenderWidgetHost* rwh = renderWidgetHostView_->render_widget_host_;
     rwh->Send(new ViewMsg_SetAccessibilityFocus(
         rwh->routing_id(), accessibilityObjectId));
   }
 }
 
 - (void)performShowMenuAction:(BrowserAccessibilityCocoa*)accessibility {
   // Performs a right click copying WebKit's
   // accessibilityPerformShowMenuAction.
   NSPoint location = [self accessibilityPointInScreen:accessibility];
-NSSize size = [[accessibility size] sizeValue];
+  NSSize size = [[accessibility size] sizeValue];
   location = [[self window] convertScreenToBase:location];
   location.x += size.width/2;
   location.y += size.height/2;
 
   NSEvent* fakeRightClick = [NSEvent
                            mouseEventWithType:NSRightMouseDown
                                      location:location
                                 modifierFlags:nil
                                     timestamp:0
                                  windowNumber:[[self window] windowNumber]
@@ skipping 725 matching lines @@
   if (!string) return NO;
 
   // If the user is currently using an IME, confirm the IME input,
   // and then insert the text from the service, the same as TextEdit and Safari.
   [self confirmComposition];
   [self insertText:string];
   return YES;
 }
 
 @end