Update Source/platform/ to assume Oilpan only.

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

 // Copyright 2015 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 "platform/scroll/ScrollableArea.h"
 
 #include "platform/graphics/Color.h"
 #include "platform/graphics/GraphicsLayer.h"
 #include "platform/scroll/ScrollbarTheme.h"
 #include "platform/scroll/ScrollbarThemeMock.h"
 #include "platform/testing/FakeGraphicsLayer.h"
 #include "platform/testing/TestingPlatformSupport.h"
 #include "public/platform/Platform.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace blink {
 
 namespace {
 
 using testing::_;
 using testing::Return;
 
 class MockScrollableArea : public GarbageCollectedFinalized<MockScrollableArea>, public ScrollableArea {
     USING_GARBAGE_COLLECTED_MIXIN(MockScrollableArea);
 public:
-    static RawPtr<MockScrollableArea> create(const IntPoint& maximumScrollPosition)
+    static MockScrollableArea* create(const IntPoint& maximumScrollPosition)
     {
         return new MockScrollableArea(maximumScrollPosition);
     }
 
     MOCK_CONST_METHOD0(visualRectForScrollbarParts, LayoutRect());
     MOCK_CONST_METHOD0(isActive, bool());
     MOCK_CONST_METHOD1(scrollSize, int(ScrollbarOrientation));
     MOCK_CONST_METHOD0(isScrollCornerVisible, bool());
     MOCK_CONST_METHOD0(scrollCornerRect, IntRect());
     MOCK_CONST_METHOD0(horizontalScrollbar, Scrollbar*());
@@ skipping 52 matching lines @@
     {
         m_fakePlatform = nullptr;
     }
 
 private:
     OwnPtr<TestingPlatformSupportWithMockScheduler> m_fakePlatform;
 };
 
 TEST_F(ScrollableAreaTest, ScrollAnimatorCurrentPositionShouldBeSync)
 {
-    RawPtr<MockScrollableArea> scrollableArea = MockScrollableArea::create(IntPoint(0, 100));
+    MockScrollableArea* scrollableArea = MockScrollableArea::create(IntPoint(0, 100));
     scrollableArea->setScrollPosition(IntPoint(0, 10000), CompositorScroll);
     EXPECT_EQ(100.0, scrollableArea->scrollAnimator().currentPosition().y());
 }
 
 namespace {
 
 class ScrollbarThemeWithMockInvalidation : public ScrollbarThemeMock {
 public:
     MOCK_CONST_METHOD0(shouldRepaintAllPartsOnInvalidation, bool());
     MOCK_CONST_METHOD3(invalidateOnThumbPositionChange, ScrollbarPart(const ScrollbarThemeClient&, float, float));
 };
 
 } // namespace
 
 TEST_F(ScrollableAreaTest, ScrollbarTrackAndThumbRepaint)
 {
     ScrollbarThemeWithMockInvalidation theme;
-    RawPtr<MockScrollableArea> scrollableArea = MockScrollableArea::create(IntPoint(0, 100));
-    RawPtr<Scrollbar> scrollbar = Scrollbar::createForTesting(scrollableArea.get(), HorizontalScrollbar, RegularScrollbar, &theme);
+    MockScrollableArea* scrollableArea = MockScrollableArea::create(IntPoint(0, 100));
+    Scrollbar* scrollbar = Scrollbar::createForTesting(scrollableArea, HorizontalScrollbar, RegularScrollbar, &theme);
 
     EXPECT_CALL(theme, shouldRepaintAllPartsOnInvalidation()).WillRepeatedly(Return(true));
     EXPECT_TRUE(scrollbar->trackNeedsRepaint());
     EXPECT_TRUE(scrollbar->thumbNeedsRepaint());
     scrollbar->setNeedsPaintInvalidation(NoPart);
     EXPECT_TRUE(scrollbar->trackNeedsRepaint());
     EXPECT_TRUE(scrollbar->thumbNeedsRepaint());
 
     scrollbar->clearTrackNeedsRepaint();
     scrollbar->clearThumbNeedsRepaint();
@@ skipping 23 matching lines @@
     bool needsRepaint(const GraphicsLayer&) const { return true; }
     IntRect computeInterestRect(const GraphicsLayer*, const IntRect&) const { return IntRect(); }
     void paintContents(const GraphicsLayer*, GraphicsContext&, GraphicsLayerPaintingPhase, const IntRect&) const override { }
     String debugName(const GraphicsLayer*) const override { return String(); }
     bool isTrackingPaintInvalidations() const override { return true; }
 };
 
 TEST_F(ScrollableAreaTest, ScrollbarGraphicsLayerInvalidation)
 {
     ScrollbarTheme::setMockScrollbarsEnabled(true);
-    RawPtr<MockScrollableArea> scrollableArea = MockScrollableArea::create(IntPoint(0, 100));
+    MockScrollableArea* scrollableArea = MockScrollableArea::create(IntPoint(0, 100));
     MockGraphicsLayerClient graphicsLayerClient;
     FakeGraphicsLayer graphicsLayer(&graphicsLayerClient);
     graphicsLayer.setDrawsContent(true);
     graphicsLayer.setSize(FloatSize(111, 222));
 
     EXPECT_CALL(*scrollableArea, layerForHorizontalScrollbar()).WillRepeatedly(Return(&graphicsLayer));
 
-    RawPtr<Scrollbar> scrollbar = Scrollbar::create(scrollableArea.get(), HorizontalScrollbar, RegularScrollbar, nullptr);
+    Scrollbar* scrollbar = Scrollbar::create(scrollableArea, HorizontalScrollbar, RegularScrollbar, nullptr);
     graphicsLayer.resetTrackedPaintInvalidations();
     scrollbar->setNeedsPaintInvalidation(NoPart);
     EXPECT_TRUE(graphicsLayer.hasTrackedPaintInvalidations());
 
     // Forced GC in order to finalize objects depending on the mock object.
     Heap::collectAllGarbage();
 }
 
 TEST_F(ScrollableAreaTest, InvalidatesNonCompositedScrollbarsWhenThumbMoves)
 {
     ScrollbarThemeWithMockInvalidation theme;
-    RawPtr<MockScrollableArea> scrollableArea = MockScrollableArea::create(IntPoint(100, 100));
-    RawPtr<Scrollbar> horizontalScrollbar = Scrollbar::createForTesting(scrollableArea.get(), HorizontalScrollbar, RegularScrollbar, &theme);
-    RawPtr<Scrollbar> verticalScrollbar = Scrollbar::createForTesting(scrollableArea.get(), VerticalScrollbar, RegularScrollbar, &theme);
-    EXPECT_CALL(*scrollableArea, horizontalScrollbar()).WillRepeatedly(Return(horizontalScrollbar.get()));
-    EXPECT_CALL(*scrollableArea, verticalScrollbar()).WillRepeatedly(Return(verticalScrollbar.get()));
+    MockScrollableArea* scrollableArea = MockScrollableArea::create(IntPoint(100, 100));
+    Scrollbar* horizontalScrollbar = Scrollbar::createForTesting(scrollableArea, HorizontalScrollbar, RegularScrollbar, &theme);
+    Scrollbar* verticalScrollbar = Scrollbar::createForTesting(scrollableArea, VerticalScrollbar, RegularScrollbar, &theme);
+    EXPECT_CALL(*scrollableArea, horizontalScrollbar()).WillRepeatedly(Return(horizontalScrollbar));
+    EXPECT_CALL(*scrollableArea, verticalScrollbar()).WillRepeatedly(Return(verticalScrollbar));
 
     // Regardless of whether the theme invalidates any parts, non-composited
     // scrollbars have to be repainted if the thumb moves.
     EXPECT_CALL(*scrollableArea, layerForHorizontalScrollbar()).WillRepeatedly(Return(nullptr));
     EXPECT_CALL(*scrollableArea, layerForVerticalScrollbar()).WillRepeatedly(Return(nullptr));
     ASSERT_FALSE(scrollableArea->hasLayerForVerticalScrollbar());
     ASSERT_FALSE(scrollableArea->hasLayerForHorizontalScrollbar());
     EXPECT_CALL(theme, shouldRepaintAllPartsOnInvalidation()).WillRepeatedly(Return(false));
     EXPECT_CALL(theme, invalidateOnThumbPositionChange(_, _, _)).WillRepeatedly(Return(NoPart));
 
     // A scroll in each direction should only invalidate one scrollbar.
     scrollableArea->setScrollPosition(DoublePoint(0, 50), ProgrammaticScroll);
     EXPECT_FALSE(scrollableArea->horizontalScrollbarNeedsPaintInvalidation());
     EXPECT_TRUE(scrollableArea->verticalScrollbarNeedsPaintInvalidation());
     scrollableArea->clearNeedsPaintInvalidationForScrollControls();
     scrollableArea->setScrollPosition(DoublePoint(50, 50), ProgrammaticScroll);
     EXPECT_TRUE(scrollableArea->horizontalScrollbarNeedsPaintInvalidation());
     EXPECT_FALSE(scrollableArea->verticalScrollbarNeedsPaintInvalidation());
     scrollableArea->clearNeedsPaintInvalidationForScrollControls();
 
     // Forced GC in order to finalize objects depending on the mock object.
     Heap::collectAllGarbage();
 }
 
 TEST_F(ScrollableAreaTest, InvalidatesCompositedScrollbarsIfPartsNeedRepaint)
 {
     ScrollbarThemeWithMockInvalidation theme;
-    RawPtr<MockScrollableArea> scrollableArea = MockScrollableArea::create(IntPoint(100, 100));
-    RawPtr<Scrollbar> horizontalScrollbar = Scrollbar::createForTesting(scrollableArea.get(), HorizontalScrollbar, RegularScrollbar, &theme);
+    MockScrollableArea* scrollableArea = MockScrollableArea::create(IntPoint(100, 100));
+    Scrollbar* horizontalScrollbar = Scrollbar::createForTesting(scrollableArea, HorizontalScrollbar, RegularScrollbar, &theme);
     horizontalScrollbar->clearTrackNeedsRepaint();
     horizontalScrollbar->clearThumbNeedsRepaint();
-    RawPtr<Scrollbar> verticalScrollbar = Scrollbar::createForTesting(scrollableArea.get(), VerticalScrollbar, RegularScrollbar, &theme);
+    Scrollbar* verticalScrollbar = Scrollbar::createForTesting(scrollableArea, VerticalScrollbar, RegularScrollbar, &theme);
     verticalScrollbar->clearTrackNeedsRepaint();
     verticalScrollbar->clearThumbNeedsRepaint();
-    EXPECT_CALL(*scrollableArea, horizontalScrollbar()).WillRepeatedly(Return(horizontalScrollbar.get()));
-    EXPECT_CALL(*scrollableArea, verticalScrollbar()).WillRepeatedly(Return(verticalScrollbar.get()));
+    EXPECT_CALL(*scrollableArea, horizontalScrollbar()).WillRepeatedly(Return(horizontalScrollbar));
+    EXPECT_CALL(*scrollableArea, verticalScrollbar()).WillRepeatedly(Return(verticalScrollbar));
 
     // Composited scrollbars only need repainting when parts become invalid
     // (e.g. if the track changes appearance when the thumb reaches the end).
     MockGraphicsLayerClient graphicsLayerClient;
     FakeGraphicsLayer layerForHorizontalScrollbar(&graphicsLayerClient);
     layerForHorizontalScrollbar.setDrawsContent(true);
     layerForHorizontalScrollbar.setSize(FloatSize(10, 10));
     FakeGraphicsLayer layerForVerticalScrollbar(&graphicsLayerClient);
     layerForVerticalScrollbar.setDrawsContent(true);
     layerForVerticalScrollbar.setSize(FloatSize(10, 10));
@@ skipping 36 matching lines @@
     EXPECT_FALSE(horizontalScrollbar->thumbNeedsRepaint());
     EXPECT_FALSE(verticalScrollbar->trackNeedsRepaint());
     EXPECT_FALSE(verticalScrollbar->thumbNeedsRepaint());
 
     // Forced GC in order to finalize objects depending on the mock object.
     Heap::collectAllGarbage();
 }
 
 TEST_F(ScrollableAreaTest, RecalculatesScrollbarOverlayIfBackgroundChanges)
 {
-    RawPtr<MockScrollableArea> scrollableArea = MockScrollableArea::create(IntPoint(0, 100));
+    MockScrollableArea* scrollableArea = MockScrollableArea::create(IntPoint(0, 100));
 
     EXPECT_EQ(ScrollbarOverlayStyleDefault, scrollableArea->getScrollbarOverlayStyle());
     scrollableArea->recalculateScrollbarOverlayStyle(Color(34, 85, 51));
     EXPECT_EQ(ScrollbarOverlayStyleLight, scrollableArea->getScrollbarOverlayStyle());
     scrollableArea->recalculateScrollbarOverlayStyle(Color(236, 143, 185));
     EXPECT_EQ(ScrollbarOverlayStyleDefault, scrollableArea->getScrollbarOverlayStyle());
 }
 
 } // namespace blink