Use refs for non-null GraphicsContext, Scrollbar, etc. in scrollbar related code

third_party/WebKit/Source/platform/scroll/ScrollableArea.cpp

 /*
  * Copyright (c) 2010, Google Inc. All rights reserved.
  * Copyright (C) 2008, 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 55 matching lines @@
     return kPixelsPerLineStep;
 }
 
 float ScrollableArea::minFractionToStepWhenPaging()
 {
     return kMinFractionToStepWhenPaging;
 }
 
 int ScrollableArea::maxOverlapBetweenPages()
 {
-    static int maxOverlapBetweenPages = ScrollbarTheme::theme()->maxOverlapBetweenPages();
+    static int maxOverlapBetweenPages = ScrollbarTheme::theme().maxOverlapBetweenPages();
     return maxOverlapBetweenPages;
 }
 
 ScrollableArea::ScrollableArea()
     : m_inLiveResize(false)
     , m_scrollbarOverlayStyle(ScrollbarOverlayStyleDefault)
     , m_scrollOriginChanged(false)
     , m_horizontalScrollbarNeedsPaintInvalidation(false)
     , m_verticalScrollbarNeedsPaintInvalidation(false)
     , m_scrollCornerNeedsPaintInvalidation(false)
 {
 }
 
 ScrollableArea::~ScrollableArea()
 {
 }
 
 void ScrollableArea::clearScrollAnimators()
 {
 #if OS(MACOSX) && ENABLE(OILPAN)
     if (m_scrollAnimator)
         m_scrollAnimator->dispose();
 #endif
     m_scrollAnimator.clear();
     m_programmaticScrollAnimator.clear();
 }
 
-ScrollAnimatorBase* ScrollableArea::scrollAnimator() const
+ScrollAnimatorBase& ScrollableArea::scrollAnimator() const
 {
     if (!m_scrollAnimator)
         m_scrollAnimator = ScrollAnimatorBase::create(const_cast<ScrollableArea*>(this));
 
-    return m_scrollAnimator.get();
+    return *m_scrollAnimator;
 }
 
-ProgrammaticScrollAnimator* ScrollableArea::programmaticScrollAnimator() const
+ProgrammaticScrollAnimator& ScrollableArea::programmaticScrollAnimator() const
 {
     if (!m_programmaticScrollAnimator)
         m_programmaticScrollAnimator = ProgrammaticScrollAnimator::create(const_cast<ScrollableArea*>(this));
 
-    return m_programmaticScrollAnimator.get();
+    return *m_programmaticScrollAnimator;
 }
 
 void ScrollableArea::setScrollOrigin(const IntPoint& origin)
 {
     if (m_scrollOrigin != origin) {
         m_scrollOrigin = origin;
         m_scrollOriginChanged = true;
     }
 }
 
@@ skipping 28 matching lines @@
         break;
     case ScrollByPixel:
     case ScrollByPrecisePixel:
         step = pixelStep(orientation);
         break;
     }
 
     if (direction == ScrollUp || direction == ScrollLeft)
         delta = -delta;
 
-    return scrollAnimator()->userScroll(orientation, granularity, step, delta);
+    return scrollAnimator().userScroll(orientation, granularity, step, delta);
 }
 
 void ScrollableArea::setScrollPosition(const DoublePoint& position, ScrollType scrollType, ScrollBehavior behavior)
 {
     if (behavior == ScrollBehaviorAuto)
         behavior = scrollBehaviorStyle();
 
     if (scrollType == CompositorScroll)
         scrollPositionChanged(clampScrollPosition(position), CompositorScroll);
     else if (scrollType == ProgrammaticScroll)
         programmaticScrollHelper(position, behavior);
     else if (scrollType == UserScroll)
         userScrollHelper(position, behavior);
     else
         ASSERT_NOT_REACHED();
 }
 
 void ScrollableArea::scrollBy(const DoubleSize& delta, ScrollType type, ScrollBehavior behavior)
 {
     setScrollPosition(scrollPositionDouble() + delta, type, behavior);
 }
 
 void ScrollableArea::setScrollPositionSingleAxis(ScrollbarOrientation orientation, double position, ScrollType scrollType, ScrollBehavior behavior)
 {
     DoublePoint newPosition;
     if (orientation == HorizontalScrollbar)
-        newPosition = DoublePoint(position, scrollAnimator()->currentPosition().y());
+        newPosition = DoublePoint(position, scrollAnimator().currentPosition().y());
     else
-        newPosition = DoublePoint(scrollAnimator()->currentPosition().x(), position);
+        newPosition = DoublePoint(scrollAnimator().currentPosition().x(), position);
 
     // TODO(bokan): Note, this doesn't use the derived class versions since this method is currently used
     // exclusively by code that adjusts the position by the scroll origin and the derived class versions
     // differ on whether they take that into account or not.
     ScrollableArea::setScrollPosition(newPosition, scrollType, behavior);
 }
 
 void ScrollableArea::programmaticScrollHelper(const DoublePoint& position, ScrollBehavior scrollBehavior)
 {
     cancelScrollAnimation();
 
     if (scrollBehavior == ScrollBehaviorSmooth)
-        programmaticScrollAnimator()->animateToOffset(toFloatPoint(position));
+        programmaticScrollAnimator().animateToOffset(toFloatPoint(position));
     else
-        programmaticScrollAnimator()->scrollToOffsetWithoutAnimation(toFloatPoint(position));
+        programmaticScrollAnimator().scrollToOffsetWithoutAnimation(toFloatPoint(position));
 }
 
 void ScrollableArea::userScrollHelper(const DoublePoint& position, ScrollBehavior scrollBehavior)
 {
     cancelProgrammaticScrollAnimation();
 
-    double x = userInputScrollable(HorizontalScrollbar) ? position.x() : scrollAnimator()->currentPosition().x();
-    double y = userInputScrollable(VerticalScrollbar) ? position.y() : scrollAnimator()->currentPosition().y();
+    double x = userInputScrollable(HorizontalScrollbar) ? position.x() : scrollAnimator().currentPosition().x();
+    double y = userInputScrollable(VerticalScrollbar) ? position.y() : scrollAnimator().currentPosition().y();
 
     // Smooth user scrolls (keyboard, wheel clicks) are handled via the userScroll method.
     // TODO(bokan): The userScroll method should probably be modified to call this method
     //              and ScrollAnimatorBase to have a simpler animateToOffset method like the
     //              ProgrammaticScrollAnimator.
     ASSERT(scrollBehavior == ScrollBehaviorInstant);
-    scrollAnimator()->scrollToOffsetWithoutAnimation(FloatPoint(x, y));
+    scrollAnimator().scrollToOffsetWithoutAnimation(FloatPoint(x, y));
 }
 
 LayoutRect ScrollableArea::scrollIntoView(const LayoutRect& rectInContent, const ScrollAlignment& alignX, const ScrollAlignment& alignY, ScrollType)
 {
     // TODO(bokan): This should really be implemented here but ScrollAlignment is in Core which is a dependency violation.
     ASSERT_NOT_REACHED();
     return LayoutRect();
 }
 
 void ScrollableArea::scrollPositionChanged(const DoublePoint& position, ScrollType scrollType)
 {
     TRACE_EVENT0("blink", "ScrollableArea::scrollPositionChanged");
 
     DoublePoint oldPosition = scrollPositionDouble();
     DoublePoint truncatedPosition = shouldUseIntegerScrollOffset() ? flooredIntPoint(position) : position;
 
     // Tell the derived class to scroll its contents.
     setScrollOffset(truncatedPosition, scrollType);
 
     Scrollbar* verticalScrollbar = this->verticalScrollbar();
 
     // Tell the scrollbars to update their thumb postions.
     if (Scrollbar* horizontalScrollbar = this->horizontalScrollbar()) {
         horizontalScrollbar->offsetDidChange();
         if (horizontalScrollbar->isOverlayScrollbar() && !hasLayerForHorizontalScrollbar())
-            setScrollbarNeedsPaintInvalidation(horizontalScrollbar);
+            setScrollbarNeedsPaintInvalidation(HorizontalScrollbar);
     }
     if (verticalScrollbar) {
         verticalScrollbar->offsetDidChange();
         if (verticalScrollbar->isOverlayScrollbar() && !hasLayerForVerticalScrollbar())
-            setScrollbarNeedsPaintInvalidation(verticalScrollbar);
+            setScrollbarNeedsPaintInvalidation(VerticalScrollbar);
     }
 
     if (scrollPositionDouble() != oldPosition) {
         // FIXME: Pass in DoubleSize. crbug.com/414283.
-        scrollAnimator()->notifyContentAreaScrolled(toFloatSize(scrollPositionDouble() - oldPosition));
+        scrollAnimator().notifyContentAreaScrolled(toFloatSize(scrollPositionDouble() - oldPosition));
     }
 
-    scrollAnimator()->setCurrentPosition(toFloatPoint(position));
+    scrollAnimator().setCurrentPosition(toFloatPoint(position));
 }
 
 bool ScrollableArea::scrollBehaviorFromString(const String& behaviorString, ScrollBehavior& behavior)
 {
     if (behaviorString == "auto")
         behavior = ScrollBehaviorAuto;
     else if (behaviorString == "instant")
         behavior = ScrollBehaviorInstant;
     else if (behaviorString == "smooth")
         behavior = ScrollBehaviorSmooth;
@@ skipping 44 matching lines @@
     if (ScrollAnimatorBase* scrollAnimator = existingScrollAnimator())
         scrollAnimator->mouseEnteredContentArea();
 }
 
 void ScrollableArea::mouseMovedInContentArea() const
 {
     if (ScrollAnimatorBase* scrollAnimator = existingScrollAnimator())
         scrollAnimator->mouseMovedInContentArea();
 }
 
-void ScrollableArea::mouseEnteredScrollbar(Scrollbar* scrollbar) const
+void ScrollableArea::mouseEnteredScrollbar(Scrollbar& scrollbar) const
 {
-    scrollAnimator()->mouseEnteredScrollbar(scrollbar);
+    scrollAnimator().mouseEnteredScrollbar(scrollbar);
 }
 
-void ScrollableArea::mouseExitedScrollbar(Scrollbar* scrollbar) const
+void ScrollableArea::mouseExitedScrollbar(Scrollbar& scrollbar) const
 {
-    scrollAnimator()->mouseExitedScrollbar(scrollbar);
+    scrollAnimator().mouseExitedScrollbar(scrollbar);
 }
 
 void ScrollableArea::contentAreaDidShow() const
 {
     if (ScrollAnimatorBase* scrollAnimator = existingScrollAnimator())
         scrollAnimator->contentAreaDidShow();
 }
 
 void ScrollableArea::contentAreaDidHide() const
 {
     if (ScrollAnimatorBase* scrollAnimator = existingScrollAnimator())
         scrollAnimator->contentAreaDidHide();
 }
 
 void ScrollableArea::finishCurrentScrollAnimations() const
 {
     if (ScrollAnimatorBase* scrollAnimator = existingScrollAnimator())
         scrollAnimator->finishCurrentScrollAnimations();
 }
 
-void ScrollableArea::didAddScrollbar(Scrollbar* scrollbar, ScrollbarOrientation orientation)
+void ScrollableArea::didAddScrollbar(Scrollbar& scrollbar, ScrollbarOrientation orientation)
 {
     if (orientation == VerticalScrollbar)
-        scrollAnimator()->didAddVerticalScrollbar(scrollbar);
+        scrollAnimator().didAddVerticalScrollbar(scrollbar);
     else
-        scrollAnimator()->didAddHorizontalScrollbar(scrollbar);
+        scrollAnimator().didAddHorizontalScrollbar(scrollbar);
 
     // <rdar://problem/9797253> AppKit resets the scrollbar's style when you attach a scrollbar
     setScrollbarOverlayStyle(scrollbarOverlayStyle());
 }
 
-void ScrollableArea::willRemoveScrollbar(Scrollbar* scrollbar, ScrollbarOrientation orientation)
+void ScrollableArea::willRemoveScrollbar(Scrollbar& scrollbar, ScrollbarOrientation orientation)
 {
     if (orientation == VerticalScrollbar)
-        scrollAnimator()->willRemoveVerticalScrollbar(scrollbar);
+        scrollAnimator().willRemoveVerticalScrollbar(scrollbar);
     else
-        scrollAnimator()->willRemoveHorizontalScrollbar(scrollbar);
+        scrollAnimator().willRemoveHorizontalScrollbar(scrollbar);
 }
 
 void ScrollableArea::contentsResized()
 {
     if (ScrollAnimatorBase* scrollAnimator = existingScrollAnimator())
         scrollAnimator->contentsResized();
 }
 
 bool ScrollableArea::hasOverlayScrollbars() const
 {
     Scrollbar* vScrollbar = verticalScrollbar();
     if (vScrollbar && vScrollbar->isOverlayScrollbar())
         return true;
     Scrollbar* hScrollbar = horizontalScrollbar();
     return hScrollbar && hScrollbar->isOverlayScrollbar();
 }
 
 void ScrollableArea::setScrollbarOverlayStyle(ScrollbarOverlayStyle overlayStyle)
 {
     m_scrollbarOverlayStyle = overlayStyle;
 
     if (Scrollbar* scrollbar = horizontalScrollbar()) {
-        ScrollbarTheme::theme()->updateScrollbarOverlayStyle(scrollbar);
-        setScrollbarNeedsPaintInvalidation(scrollbar);
+        ScrollbarTheme::theme().updateScrollbarOverlayStyle(*scrollbar);
+        setScrollbarNeedsPaintInvalidation(HorizontalScrollbar);
     }
 
     if (Scrollbar* scrollbar = verticalScrollbar()) {
-        ScrollbarTheme::theme()->updateScrollbarOverlayStyle(scrollbar);
-        setScrollbarNeedsPaintInvalidation(scrollbar);
+        ScrollbarTheme::theme().updateScrollbarOverlayStyle(*scrollbar);
+        setScrollbarNeedsPaintInvalidation(VerticalScrollbar);
     }
 }
 
-void ScrollableArea::setScrollbarNeedsPaintInvalidation(Scrollbar* scrollbar)
+void ScrollableArea::setScrollbarNeedsPaintInvalidation(ScrollbarOrientation orientation)
 {
-    if (scrollbar == horizontalScrollbar()) {
+    if (orientation == HorizontalScrollbar)
         m_horizontalScrollbarNeedsPaintInvalidation = true;
-        scrollControlWasSetNeedsPaintInvalidation();
-        return;
-    }
-    if (scrollbar == verticalScrollbar()) {
+    else
         m_verticalScrollbarNeedsPaintInvalidation = true;
-        scrollControlWasSetNeedsPaintInvalidation();
-        return;
-    }
-    // Otherwise the scrollbar is just created and has not been set as either
-    // horizontalScrollbar() or verticalScrollbar().
+
+    scrollControlWasSetNeedsPaintInvalidation();
 }
 
 void ScrollableArea::setScrollCornerNeedsPaintInvalidation()
 {
     if (GraphicsLayer* graphicsLayer = layerForScrollCorner()) {
         graphicsLayer->setNeedsDisplay();
         return;
     }
     m_scrollCornerNeedsPaintInvalidation = true;
     scrollControlWasSetNeedsPaintInvalidation();
@@ skipping 143 matching lines @@
 
 }
 
 DEFINE_TRACE(ScrollableArea)
 {
     visitor->trace(m_scrollAnimator);
     visitor->trace(m_programmaticScrollAnimator);
 }
 
 } // namespace blink