reflow comments in platform/mac

third_party/WebKit/Source/platform/mac/ScrollAnimatorMac.mm

 /*
  * Copyright (C) 2010, 2011 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 27 matching lines @@
 #include "platform/scroll/ScrollbarThemeMac.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebScheduler.h"
 #include "wtf/MathExtras.h"
 #include "wtf/PtrUtil.h"
 #include <memory>
 
 using namespace blink;
 
 static bool supportsUIStateTransitionProgress() {
-  // FIXME: This is temporary until all platforms that support ScrollbarPainter support this part of the API.
+  // FIXME: This is temporary until all platforms that support ScrollbarPainter
+  // support this part of the API.
   static bool globalSupportsUIStateTransitionProgress =
       [NSClassFromString(@"NSScrollerImp")
           instancesRespondToSelector:@selector(mouseEnteredScroller)];
   return globalSupportsUIStateTransitionProgress;
 }
 
 static bool supportsExpansionTransitionProgress() {
   static bool globalSupportsExpansionTransitionProgress =
       [NSClassFromString(@"NSScrollerImp")
           instancesRespondToSelector:@selector(expansionTransitionProgress)];
@@ skipping 155 matching lines @@
              toScrollerImp:(id)scrollerImp {
   if (!_scrollableArea || !scrollerImp)
     return NSZeroPoint;
 
   blink::Scrollbar* scrollbar = nil;
   if ([scrollerImp isHorizontal])
     scrollbar = _scrollableArea->horizontalScrollbar();
   else
     scrollbar = _scrollableArea->verticalScrollbar();
 
-  // It is possible to have a null scrollbar here since it is possible for this delegate
-  // method to be called between the moment when a scrollbar has been set to 0 and the
-  // moment when its destructor has been called. We should probably de-couple some
-  // of the clean-up work in ScrollbarThemeMac::unregisterScrollbar() to avoid this
-  // issue.
+  // It is possible to have a null scrollbar here since it is possible for this
+  // delegate method to be called between the moment when a scrollbar has been
+  // set to 0 and the moment when its destructor has been called. We should
+  // probably de-couple some of the clean-up work in
+  // ScrollbarThemeMac::unregisterScrollbar() to avoid this issue.
   if (!scrollbar)
     return NSZeroPoint;
 
   ASSERT(scrollerImp == scrollbarPainterForScrollbar(*scrollbar));
 
   return scrollbar->convertFromContainingWidget(
       blink::IntPoint(pointInContentArea));
 }
 
 - (void)scrollerImpPair:(id)scrollerImpPair
     setContentAreaNeedsDisplayInRect:(NSRect)rect {
   if (!_scrollableArea)
     return;
 
   if (!_scrollableArea->scrollbarsCanBeActive())
     return;
 
   _scrollableArea->scrollAnimator().contentAreaWillPaint();
 }
 
 - (void)scrollerImpPair:(id)scrollerImpPair
     updateScrollerStyleForNewRecommendedScrollerStyle:
         (NSScrollerStyle)newRecommendedScrollerStyle {
-  // Chrome has a single process mode which is used for testing on Mac. In that mode, WebKit runs on a thread in the
-  // browser process. This notification is called by the OS on the main thread in the browser process, and not on the
+  // Chrome has a single process mode which is used for testing on Mac. In that
+  // mode, WebKit runs on a thread in the browser process. This notification is
+  // called by the OS on the main thread in the browser process, and not on the
   // the WebKit thread. Better to not update the style than crash.
   // http://crbug.com/126514
   if (!isMainThread())
     return;
 
   if (!_scrollableArea)
     return;
 
   [scrollerImpPair setScrollerStyle:newRecommendedScrollerStyle];
 
   static_cast<ScrollAnimatorMac&>(_scrollableArea->scrollAnimator())
       .updateScrollerStyle();
 }
 
 @end
 
 enum FeatureToAnimate {
   ThumbAlpha,
   TrackAlpha,
   UIStateTransition,
   ExpansionTransition
 };
 
 @class BlinkScrollbarPartAnimation;
 
 namespace blink {
 
-// This class is used to drive the animation timer for BlinkScrollbarPartAnimation
-// objects. This is used instead of NSAnimation because CoreAnimation
-// establishes connections to the WindowServer, which should not be done in a
-// sandboxed renderer process.
+// This class is used to drive the animation timer for
+// BlinkScrollbarPartAnimation objects. This is used instead of NSAnimation
+// because CoreAnimation establishes connections to the WindowServer, which
+// should not be done in a sandboxed renderer process.
 class BlinkScrollbarPartAnimationTimer {
  public:
   BlinkScrollbarPartAnimationTimer(BlinkScrollbarPartAnimation* animation,
                                    CFTimeInterval duration)
       : m_timer(this, &BlinkScrollbarPartAnimationTimer::timerFired),
         m_startTime(0.0),
         m_duration(duration),
         m_animation(animation),
         m_timingFunction(CubicBezierTimingFunction::preset(
             CubicBezierTimingFunction::EaseType::EASE_IN_OUT)) {}
@@ skipping 194 matching lines @@
   return _scrollbar->convertFromContainingWidget(
       _scrollbar->getScrollableArea()->lastKnownMousePosition());
 }
 
 - (void)setUpAlphaAnimation:
             (RetainPtr<BlinkScrollbarPartAnimation>&)scrollbarPartAnimation
             scrollerPainter:(ScrollbarPainter)scrollerPainter
                        part:(blink::ScrollbarPart)part
              animateAlphaTo:(CGFloat)newAlpha
                    duration:(NSTimeInterval)duration {
-  // If the user has scrolled the page, then the scrollbars must be animated here.
-  // This overrides the early returns.
+  // If the user has scrolled the page, then the scrollbars must be animated
+  // here.  This overrides the early returns.
   bool mustAnimate = [self scrollAnimator].haveScrolledSincePageLoad();
 
   if ([self scrollAnimator].scrollbarPaintTimerIsActive() && !mustAnimate)
     return;
 
   if (_scrollbar->getScrollableArea()->shouldSuspendScrollAnimations() &&
       !mustAnimate) {
     [self scrollAnimator].startScrollbarPaintTimer();
     return;
   }
@@ skipping 63 matching lines @@
   if (!_scrollbar)
     return;
 
   if (!supportsUIStateTransitionProgress())
     return;
 
   ASSERT(scrollerImp == scrollbarPainterForScrollbar(*_scrollbar));
 
   ScrollbarPainter scrollbarPainter = (ScrollbarPainter)scrollerImp;
 
-  // UIStateTransition always animates to 1. In case an animation is in progress this avoids a hard transition.
+  // UIStateTransition always animates to 1. In case an animation is in progress
+  // this avoids a hard transition.
   [scrollbarPainter
       setUiStateTransitionProgress:1 - [scrollerImp uiStateTransitionProgress]];
 
   if (!_uiStateTransitionAnimation)
     _uiStateTransitionAnimation.adoptNS([[BlinkScrollbarPartAnimation alloc]
         initWithScrollbar:_scrollbar
          featureToAnimate:UIStateTransition
               animateFrom:[scrollbarPainter uiStateTransitionProgress]
                 animateTo:1.0
                  duration:duration]);
   else {
-    // If we don't need to initialize the animation, just reset the values in case they have changed.
+    // If we don't need to initialize the animation, just reset the values in
+    // case they have changed.
     [_uiStateTransitionAnimation.get()
         setStartValue:[scrollbarPainter uiStateTransitionProgress]];
     [_uiStateTransitionAnimation.get() setEndValue:1.0];
     [_uiStateTransitionAnimation.get() setDuration:duration];
   }
   [_uiStateTransitionAnimation.get() startAnimation];
 }
 
 - (void)scrollerImp:(id)scrollerImp
     animateExpansionTransitionWithDuration:(NSTimeInterval)duration {
   if (!_scrollbar)
     return;
 
   if (!supportsExpansionTransitionProgress())
     return;
 
   ASSERT(scrollerImp == scrollbarPainterForScrollbar(*_scrollbar));
 
   ScrollbarPainter scrollbarPainter = (ScrollbarPainter)scrollerImp;
 
-  // ExpansionTransition always animates to 1. In case an animation is in progress this avoids a hard transition.
+  // ExpansionTransition always animates to 1. In case an animation is in
+  // progress this avoids a hard transition.
   [scrollbarPainter
       setExpansionTransitionProgress:1 -
                                      [scrollerImp expansionTransitionProgress]];
 
   if (!_expansionTransitionAnimation) {
     _expansionTransitionAnimation.adoptNS([[BlinkScrollbarPartAnimation alloc]
         initWithScrollbar:_scrollbar
          featureToAnimate:ExpansionTransition
               animateFrom:[scrollbarPainter expansionTransitionProgress]
                 animateTo:1.0
                  duration:duration]);
   } else {
-    // If we don't need to initialize the animation, just reset the values in case they have changed.
+    // If we don't need to initialize the animation, just reset the values in
+    // case they have changed.
     [_expansionTransitionAnimation.get()
         setStartValue:[scrollbarPainter uiStateTransitionProgress]];
     [_expansionTransitionAnimation.get() setEndValue:1.0];
     [_expansionTransitionAnimation.get() setDuration:duration];
   }
   [_expansionTransitionAnimation.get() startAnimation];
 }
 
 - (void)scrollerImp:(id)scrollerImp
     overlayScrollerStateChangedTo:(NSUInteger)newOverlayScrollerState {
-  // The names of these states are based on their observed behavior, and are not based on documentation.
+  // The names of these states are based on their observed behavior, and are not
+  // based on documentation.
   enum {
     NSScrollerStateInvisible = 0,
     NSScrollerStateKnob = 1,
     NSScrollerStateExpanded = 2
   };
-  // We do not receive notifications about the thumb un-expanding when the scrollbar fades away. Ensure
-  // that we re-paint the thumb the next time that we transition away from being invisible, so that
-  // the thumb doesn't stick in an expanded state.
+  // We do not receive notifications about the thumb un-expanding when the
+  // scrollbar fades away. Ensure that we re-paint the thumb the next time that
+  // we transition away from being invisible, so that the thumb doesn't stick
+  // in an expanded state.
   if (newOverlayScrollerState == NSScrollerStateExpanded) {
     _hasExpandedSinceInvisible = YES;
   } else if (newOverlayScrollerState != NSScrollerStateInvisible &&
              _hasExpandedSinceInvisible) {
     _scrollbar->setNeedsPaintInvalidation(ThumbPart);
     _hasExpandedSinceInvisible = NO;
   }
 }
 
 - (void)invalidate {
@@ skipping 84 matching lines @@
     NSPoint targetOrigin = [m_scrollAnimationHelper.get() targetOrigin];
     if (!delta.width())
       newPos.setX(targetOrigin.x);
     if (!delta.height())
       newPos.setY(targetOrigin.y);
   }
 
   NSPoint newPoint = NSMakePoint(newPos.x(), newPos.y());
   [m_scrollAnimationHelper.get() scrollToPoint:newPoint];
 
-  // TODO(bokan): This has different semantics on ScrollResult than ScrollAnimator,
-  // which only returns unused delta if there's no animation and we don't start one.
+  // TODO(bokan): This has different semantics on ScrollResult than
+  // ScrollAnimator, which only returns unused delta if there's no animation
+  // and we don't start one.
   return ScrollResult(consumedDelta.width(), consumedDelta.height(),
                       delta.width() - consumedDelta.width(),
                       delta.height() - consumedDelta.height());
 }
 
 void ScrollAnimatorMac::scrollToOffsetWithoutAnimation(
     const FloatPoint& offset) {
   [m_scrollAnimationHelper.get() _stopRun];
   immediateScrollTo(offset);
 }
@@ skipping 165 matching lines @@
   [painter setDelegate:nil];
   [m_scrollbarPainterController.get() setHorizontalScrollerImp:nil];
 }
 
 bool ScrollAnimatorMac::shouldScrollbarParticipateInHitTesting(
     Scrollbar& scrollbar) {
   // Non-overlay scrollbars should always participate in hit testing.
   if (ScrollbarThemeMac::recommendedScrollerStyle() != NSScrollerStyleOverlay)
     return true;
 
-  // Overlay scrollbars should participate in hit testing whenever they are at all visible.
+  // Overlay scrollbars should participate in hit testing whenever they are at
+  // all visible.
   ScrollbarPainter painter = scrollbarPainterForScrollbar(scrollbar);
   if (!painter)
     return false;
   return [painter knobAlpha] > 0;
 }
 
 void ScrollAnimatorMac::notifyContentAreaScrolled(const FloatSize& delta) {
-  // This function is called when a page is going into the page cache, but the page
-  // isn't really scrolling in that case. We should only pass the message on to the
-  // ScrollbarPainterController when we're really scrolling on an active page.
+  // This function is called when a page is going into the page cache, but the
+  // page isn't really scrolling in that case. We should only pass the message
+  // on to the ScrollbarPainterController when we're really scrolling on an
+  // active page.
   if (getScrollableArea()->scrollbarsCanBeActive())
     sendContentAreaScrolledSoon(delta);
 }
 
 bool ScrollAnimatorMac::setScrollbarsVisibleForTesting(bool show) {
   if (show)
     [m_scrollbarPainterController.get() flashScrollers];
   else
     [m_scrollbarPainterController.get() hideOverlayScrollers];
 
   [m_verticalScrollbarPainterDelegate.get() updateVisibilityImmediately:show];
   [m_verticalScrollbarPainterDelegate.get() updateVisibilityImmediately:show];
   return true;
 }
 
 void ScrollAnimatorMac::cancelAnimation() {
   [m_scrollAnimationHelper.get() _stopRun];
   m_haveScrolledSincePageLoad = false;
 }
 
 void ScrollAnimatorMac::handleWheelEventPhase(PlatformWheelEventPhase phase) {
-  // This may not have been set to true yet if the wheel event was handled by the ScrollingTree,
-  // So set it to true here.
+  // This may not have been set to true yet if the wheel event was handled by
+  // the ScrollingTree, so set it to true here.
   m_haveScrolledSincePageLoad = true;
 
   if (phase == PlatformWheelEventPhaseBegan)
     didBeginScrollGesture();
   else if (phase == PlatformWheelEventPhaseEnded ||
            phase == PlatformWheelEventPhaseCancelled)
     didEndScrollGesture();
   else if (phase == PlatformWheelEventPhaseMayBegin)
     mayBeginScrollGesture();
 }
@@ skipping 19 matching lines @@
         [m_scrollbarPainterController.get() verticalScrollerImp];
     ScrollbarPainter newVerticalPainter = [NSClassFromString(@"NSScrollerImp")
         scrollerImpWithStyle:newStyle
                  controlSize:(NSControlSize)verticalScrollbar->controlSize()
                   horizontal:NO
         replacingScrollerImp:oldVerticalPainter];
     [m_scrollbarPainterController.get()
         setVerticalScrollerImp:newVerticalPainter];
     macTheme->setNewPainterForScrollbar(*verticalScrollbar, newVerticalPainter);
 
-    // The different scrollbar styles have different thicknesses, so we must re-set the
-    // frameRect to the new thickness, and the re-layout below will ensure the position
-    // and length are properly updated.
+    // The different scrollbar styles have different thicknesses, so we must
+    // re-set the frameRect to the new thickness, and the re-layout below will
+    // ensure the position and length are properly updated.
     int thickness =
         macTheme->scrollbarThickness(verticalScrollbar->controlSize());
     verticalScrollbar->setFrameRect(IntRect(0, 0, thickness, thickness));
   }
 
   if (Scrollbar* horizontalScrollbar =
           getScrollableArea()->horizontalScrollbar()) {
     horizontalScrollbar->setNeedsPaintInvalidation(AllParts);
 
     ScrollbarPainter oldHorizontalPainter =
         [m_scrollbarPainterController.get() horizontalScrollerImp];
     ScrollbarPainter newHorizontalPainter = [NSClassFromString(@"NSScrollerImp")
         scrollerImpWithStyle:newStyle
                  controlSize:(NSControlSize)horizontalScrollbar->controlSize()
                   horizontal:YES
         replacingScrollerImp:oldHorizontalPainter];
     [m_scrollbarPainterController.get()
         setHorizontalScrollerImp:newHorizontalPainter];
     macTheme->setNewPainterForScrollbar(*horizontalScrollbar,
                                         newHorizontalPainter);
 
-    // The different scrollbar styles have different thicknesses, so we must re-set the
-    // frameRect to the new thickness, and the re-layout below will ensure the position
-    // and length are properly updated.
+    // The different scrollbar styles have different thicknesses, so we must
+    // re-set the frameRect to the new thickness, and the re-layout below will
+    // ensure the position and length are properly updated.
     int thickness =
         macTheme->scrollbarThickness(horizontalScrollbar->controlSize());
     horizontalScrollbar->setFrameRect(IntRect(0, 0, thickness, thickness));
   }
 
-  // If m_needsScrollerStyleUpdate is true, then the page is restoring from the page cache, and
-  // a relayout will happen on its own. Otherwise, we must initiate a re-layout ourselves.
+  // If m_needsScrollerStyleUpdate is true, then the page is restoring from the
+  // page cache, and a relayout will happen on its own. Otherwise, we must
+  // initiate a re-layout ourselves.
   if (!m_needsScrollerStyleUpdate)
     getScrollableArea()->scrollbarStyleChanged();
 
   m_needsScrollerStyleUpdate = false;
 }
 
 void ScrollAnimatorMac::startScrollbarPaintTimer() {
   m_taskRunner->postDelayedTask(
       BLINK_FROM_HERE, m_initialScrollbarPaintTaskFactory->cancelAndCreate(),
       0.1);
 }
 
 bool ScrollAnimatorMac::scrollbarPaintTimerIsActive() const {
   return m_initialScrollbarPaintTaskFactory->isPending();
 }
 
 void ScrollAnimatorMac::stopScrollbarPaintTimer() {
   m_initialScrollbarPaintTaskFactory->cancel();
 }
 
 void ScrollAnimatorMac::initialScrollbarPaintTask() {
-  // To force the scrollbars to flash, we have to call hide first. Otherwise, the ScrollbarPainterController
-  // might think that the scrollbars are already showing and bail early.
+  // To force the scrollbars to flash, we have to call hide first. Otherwise,
+  // the ScrollbarPainterController might think that the scrollbars are already
+  // showing and bail early.
   [m_scrollbarPainterController.get() hideOverlayScrollers];
   [m_scrollbarPainterController.get() flashScrollers];
 }
 
 void ScrollAnimatorMac::sendContentAreaScrolledSoon(const FloatSize& delta) {
   m_contentAreaScrolledTimerScrollDelta = delta;
 
   if (!m_sendContentAreaScrolledTaskFactory->isPending())
     m_taskRunner->postTask(
         BLINK_FROM_HERE,
@@ skipping 20 matching lines @@
     rectInViewCoordinates =
         verticalScrollbar->convertToContainingWidget(scrollerThumb);
 
   if (rectInViewCoordinates == m_visibleScrollerThumbRect)
     return;
 
   m_visibleScrollerThumbRect = rectInViewCoordinates;
 }
 
 }  // namespace blink