Change all test cases to use WebViewBase instead of WebViewImpl.

third_party/WebKit/Source/web/tests/ScrollingCoordinatorTest.cpp

 /*
  * Copyright (C) 2012 Google 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 46 matching lines @@
 
 class ScrollingCoordinatorTest : public ::testing::Test,
                                  public ::testing::WithParamInterface<bool>,
                                  private ScopedRootLayerScrollingForTest {
  public:
   ScrollingCoordinatorTest()
       : ScopedRootLayerScrollingForTest(GetParam()),
         base_url_("http://www.test.com/") {
     helper_.Initialize(true, nullptr, &mock_web_view_client_, nullptr,
                        &ConfigureSettings);
-    GetWebViewImpl()->Resize(IntSize(320, 240));
+    GetWebView()->Resize(IntSize(320, 240));
 
     // macOS attaches main frame scrollbars to the VisualViewport so the
     // VisualViewport layers need to be initialized.
-    GetWebViewImpl()->UpdateAllLifecyclePhases();
+    GetWebView()->UpdateAllLifecyclePhases();
     WebFrameWidgetBase* main_frame_widget =
-        GetWebViewImpl()->MainFrameImpl()->FrameWidget();
-    main_frame_widget->SetRootGraphicsLayer(GetWebViewImpl()
+        GetWebView()->MainFrameImpl()->FrameWidget();
+    main_frame_widget->SetRootGraphicsLayer(GetWebView()
                                                 ->MainFrameImpl()
                                                 ->GetFrame()
                                                 ->View()
                                                 ->GetLayoutViewItem()
                                                 .Compositor()
                                                 ->RootGraphicsLayer());
   }
 
   ~ScrollingCoordinatorTest() override {
     Platform::Current()
         ->GetURLLoaderMockFactory()
         ->UnregisterAllURLsAndClearMemoryCache();
   }
 
   void NavigateTo(const std::string& url) {
-    FrameTestHelpers::LoadFrame(GetWebViewImpl()->MainFrame(), url);
+    FrameTestHelpers::LoadFrame(GetWebView()->MainFrame(), url);
   }
 
   void LoadHTML(const std::string& html) {
-    FrameTestHelpers::LoadHTMLString(GetWebViewImpl()->MainFrame(), html,
+    FrameTestHelpers::LoadHTMLString(GetWebView()->MainFrame(), html,
                                      URLTestHelpers::ToKURL("about:blank"));
   }
 
   void ForceFullCompositingUpdate() {
-    GetWebViewImpl()->UpdateAllLifecyclePhases();
+    GetWebView()->UpdateAllLifecyclePhases();
   }
 
   void RegisterMockedHttpURLLoad(const std::string& file_name) {
     URLTestHelpers::RegisterMockedURLLoadFromBase(
         WebString::FromUTF8(base_url_), testing::WebTestDataPath(),
         WebString::FromUTF8(file_name));
   }
 
   WebLayer* GetRootScrollLayer() {
     GraphicsLayer* layer =
         GetFrame()->View()->LayoutViewportScrollableArea()->LayerForScrolling();
     return layer ? layer->PlatformLayer() : nullptr;
   }
 
-  WebViewImpl* GetWebViewImpl() const { return helper_.WebView(); }
+  WebViewBase* GetWebView() const { return helper_.WebView(); }
   LocalFrame* GetFrame() const {
     return helper_.WebView()->MainFrameImpl()->GetFrame();
   }
 
   WebLayerTreeView* GetWebLayerTreeView() const {
-    return GetWebViewImpl()->LayerTreeView();
+    return GetWebView()->LayerTreeView();
   }
 
  protected:
   std::string base_url_;
   FrameTestHelpers::TestWebViewClient mock_web_view_client_;
 
  private:
   static void ConfigureSettings(WebSettings* settings) {
     settings->SetJavaScriptEnabled(true);
     settings->SetAcceleratedCompositingEnabled(true);
     settings->SetPreferCompositingToLCDTextEnabled(true);
   }
 
   FrameTestHelpers::WebViewHelper helper_;
 };
 
 INSTANTIATE_TEST_CASE_P(All, ScrollingCoordinatorTest, ::testing::Bool());
 
 TEST_P(ScrollingCoordinatorTest, fastScrollingByDefault) {
-  GetWebViewImpl()->Resize(WebSize(800, 600));
+  GetWebView()->Resize(WebSize(800, 600));
   LoadHTML("<div id='spacer' style='height: 1000px'></div>");
   ForceFullCompositingUpdate();
 
   // Make sure the scrolling coordinator is active.
   FrameView* frame_view = GetFrame()->View();
   Page* page = GetFrame()->GetPage();
   ASSERT_TRUE(page->GetScrollingCoordinator());
   ASSERT_TRUE(page->GetScrollingCoordinator()->CoordinatesScrollingForFrameView(
       frame_view));
 
   // Fast scrolling should be enabled by default.
   WebLayer* root_scroll_layer = GetRootScrollLayer();
   ASSERT_TRUE(root_scroll_layer);
   ASSERT_TRUE(root_scroll_layer->Scrollable());
   ASSERT_FALSE(root_scroll_layer->ShouldScrollOnMainThread());
   ASSERT_EQ(WebEventListenerProperties::kNothing,
             GetWebLayerTreeView()->EventListenerProperties(
                 WebEventListenerClass::kTouchStartOrMove));
   ASSERT_EQ(WebEventListenerProperties::kNothing,
             GetWebLayerTreeView()->EventListenerProperties(
                 WebEventListenerClass::kMouseWheel));
 
   WebLayer* inner_viewport_scroll_layer =
       page->GetVisualViewport().ScrollLayer()->PlatformLayer();
   ASSERT_TRUE(inner_viewport_scroll_layer->Scrollable());
   ASSERT_FALSE(inner_viewport_scroll_layer->ShouldScrollOnMainThread());
 }
 
 TEST_P(ScrollingCoordinatorTest, fastScrollingCanBeDisabledWithSetting) {
-  GetWebViewImpl()->Resize(WebSize(800, 600));
+  GetWebView()->Resize(WebSize(800, 600));
   LoadHTML("<div id='spacer' style='height: 1000px'></div>");
-  GetWebViewImpl()->GetSettings()->SetThreadedScrollingEnabled(false);
+  GetWebView()->GetSettings()->SetThreadedScrollingEnabled(false);
   ForceFullCompositingUpdate();
 
   // Make sure the scrolling coordinator is active.
   FrameView* frame_view = GetFrame()->View();
   Page* page = GetFrame()->GetPage();
   ASSERT_TRUE(page->GetScrollingCoordinator());
   ASSERT_TRUE(page->GetScrollingCoordinator()->CoordinatesScrollingForFrameView(
       frame_view));
 
   // Main scrolling should be enabled with the setting override.
@@ skipping 626 matching lines @@
   ASSERT_TRUE(contents_layer);
 
   // After scrollableAreaScrollbarLayerDidChange,
   // if the main frame's scrollbarLayer is opaque,
   // contentsLayer should be opaque too.
   ASSERT_EQ(platform_layer->Opaque(), contents_layer->Opaque());
 }
 
 TEST_P(ScrollingCoordinatorTest,
        FixedPositionLosingBackingShouldTriggerMainThreadScroll) {
-  GetWebViewImpl()->GetSettings()->SetPreferCompositingToLCDTextEnabled(false);
+  GetWebView()->GetSettings()->SetPreferCompositingToLCDTextEnabled(false);
   RegisterMockedHttpURLLoad("fixed-position-losing-backing.html");
   NavigateTo(base_url_ + "fixed-position-losing-backing.html");
   ForceFullCompositingUpdate();
 
   WebLayer* scroll_layer = GetRootScrollLayer();
   ASSERT_TRUE(scroll_layer);
 
   Document* document = GetFrame()->GetDocument();
   Element* fixed_pos = document->getElementById("fixed");
 
   EXPECT_TRUE(static_cast<LayoutBoxModelObject*>(fixed_pos->GetLayoutObject())
                   ->Layer()
                   ->HasCompositedLayerMapping());
   EXPECT_FALSE(scroll_layer->ShouldScrollOnMainThread());
 
   fixed_pos->SetInlineStyleProperty(CSSPropertyTransform, CSSValueNone);
   ForceFullCompositingUpdate();
 
   EXPECT_FALSE(static_cast<LayoutBoxModelObject*>(fixed_pos->GetLayoutObject())
                    ->Layer()
                    ->HasCompositedLayerMapping());
   EXPECT_TRUE(scroll_layer->ShouldScrollOnMainThread());
 }
 
 TEST_P(ScrollingCoordinatorTest, CustomScrollbarShouldTriggerMainThreadScroll) {
-  GetWebViewImpl()->GetSettings()->SetPreferCompositingToLCDTextEnabled(true);
-  GetWebViewImpl()->SetDeviceScaleFactor(2.f);
+  GetWebView()->GetSettings()->SetPreferCompositingToLCDTextEnabled(true);
+  GetWebView()->SetDeviceScaleFactor(2.f);
   RegisterMockedHttpURLLoad("custom_scrollbar.html");
   NavigateTo(base_url_ + "custom_scrollbar.html");
   ForceFullCompositingUpdate();
 
   Document* document = GetFrame()->GetDocument();
   Element* container = document->getElementById("container");
   Element* content = document->getElementById("content");
   DCHECK_EQ(container->getAttribute(HTMLNames::classAttr), "custom_scrollbar");
   DCHECK(container);
   DCHECK(content);
@@ skipping 107 matching lines @@
   web_scroll_layer = scroll_layer->PlatformLayer();
   ASSERT_TRUE(web_scroll_layer->Scrollable());
   ASSERT_TRUE(web_scroll_layer->MainThreadScrollingReasons() &
               MainThreadScrollingReason::kHasBackgroundAttachmentFixedObjects);
 }
 
 // Upon resizing the content size, the main thread scrolling reason
 // kHasNonLayerViewportConstrainedObject should be updated on all frames
 TEST_P(ScrollingCoordinatorTest,
        RecalculateMainThreadScrollingReasonsUponResize) {
-  GetWebViewImpl()->GetSettings()->SetPreferCompositingToLCDTextEnabled(false);
+  GetWebView()->GetSettings()->SetPreferCompositingToLCDTextEnabled(false);
   RegisterMockedHttpURLLoad("has-non-layer-viewport-constrained-objects.html");
   NavigateTo(base_url_ + "has-non-layer-viewport-constrained-objects.html");
   ForceFullCompositingUpdate();
 
   LOG(ERROR) << GetFrame()->View()->GetMainThreadScrollingReasons();
   Element* element = GetFrame()->GetDocument()->getElementById("scrollable");
   ASSERT_TRUE(element);
 
   LayoutObject* layout_object = element->GetLayoutObject();
   ASSERT_TRUE(layout_object);
@@ skipping 70 matching lines @@
       MainThreadScrollingReason::kBackgroundNotOpaqueInRectAndLCDText |
       MainThreadScrollingReason::kIsNotStackingContextAndLCDText;
 
  protected:
   NonCompositedMainThreadScrollingReasonTest() {
     RegisterMockedHttpURLLoad("two_scrollable_area.html");
     NavigateTo(base_url_ + "two_scrollable_area.html");
   }
   void TestNonCompositedReasons(const std::string& target,
                                 const uint32_t reason) {
-    GetWebViewImpl()->GetSettings()->SetPreferCompositingToLCDTextEnabled(
-        false);
+    GetWebView()->GetSettings()->SetPreferCompositingToLCDTextEnabled(false);
     Document* document = GetFrame()->GetDocument();
     Element* container = document->getElementById("scroller1");
     container->setAttribute("class", target.c_str(), ASSERT_NO_EXCEPTION);
     ForceFullCompositingUpdate();
 
     PaintLayerScrollableArea* scrollable_area =
         ToLayoutBoxModelObject(container->GetLayoutObject())
             ->GetScrollableArea();
     ASSERT_TRUE(scrollable_area);
     EXPECT_TRUE(scrollable_area->GetNonCompositedMainThreadScrollingReasons() &
@@ skipping 24 matching lines @@
     // Add target attribute would again lead to scroll on main thread
     container->setAttribute("class", target.c_str(), ASSERT_NO_EXCEPTION);
     ForceFullCompositingUpdate();
 
     EXPECT_TRUE(scrollable_area->GetNonCompositedMainThreadScrollingReasons() &
                 reason);
     EXPECT_FALSE(frame_view->GetMainThreadScrollingReasons() & reason);
 
     if ((reason & kLCDTextRelatedReasons) &&
         !(reason & ~kLCDTextRelatedReasons)) {
-      GetWebViewImpl()->GetSettings()->SetPreferCompositingToLCDTextEnabled(
-          true);
+      GetWebView()->GetSettings()->SetPreferCompositingToLCDTextEnabled(true);
       ForceFullCompositingUpdate();
       EXPECT_FALSE(
           scrollable_area->GetNonCompositedMainThreadScrollingReasons());
       EXPECT_FALSE(frame_view->GetMainThreadScrollingReasons());
     }
   }
 };
 
 INSTANTIATE_TEST_CASE_P(All,
                         NonCompositedMainThreadScrollingReasonTest,
@@ skipping 20 matching lines @@
                            MainThreadScrollingReason::kHasBorderRadius);
 }
 
 TEST_P(NonCompositedMainThreadScrollingReasonTest, ClipTest) {
   TestNonCompositedReasons("clip",
                            MainThreadScrollingReason::kHasClipRelatedProperty);
 }
 
 TEST_P(NonCompositedMainThreadScrollingReasonTest, ClipPathTest) {
   uint32_t clip_reason = MainThreadScrollingReason::kHasClipRelatedProperty;
-  GetWebViewImpl()->GetSettings()->SetPreferCompositingToLCDTextEnabled(false);
+  GetWebView()->GetSettings()->SetPreferCompositingToLCDTextEnabled(false);
   Document* document = GetFrame()->GetDocument();
   // Test ancestor with ClipPath
   Element* element = document->body();
   ASSERT_TRUE(element);
   element->setAttribute(HTMLNames::styleAttr,
                         "clip-path:circle(115px at 20px 20px);");
   Element* container = document->getElementById("scroller1");
   ASSERT_TRUE(container);
   ForceFullCompositingUpdate();
 
@@ skipping 38 matching lines @@
                            MainThreadScrollingReason::kHasOpacityAndLCDText |
                                MainThreadScrollingReason::kHasBorderRadius);
 }
 
 TEST_P(NonCompositedMainThreadScrollingReasonTest, BoxShadowTest) {
   TestNonCompositedReasons(
       "box-shadow", MainThreadScrollingReason::kHasBoxShadowFromNonRootLayer);
 }
 
 TEST_P(NonCompositedMainThreadScrollingReasonTest, StackingContextTest) {
-  GetWebViewImpl()->GetSettings()->SetPreferCompositingToLCDTextEnabled(false);
+  GetWebView()->GetSettings()->SetPreferCompositingToLCDTextEnabled(false);
 
   Document* document = GetFrame()->GetDocument();
   Element* container = document->getElementById("scroller1");
   ASSERT_TRUE(container);
 
   ForceFullCompositingUpdate();
 
   // If a scroller contains all its children, it's not a stacking context.
   PaintLayerScrollableArea* scrollable_area =
       ToLayoutBoxModelObject(container->GetLayoutObject())->GetScrollableArea();
   ASSERT_TRUE(scrollable_area);
   EXPECT_TRUE(scrollable_area->GetNonCompositedMainThreadScrollingReasons() &
               MainThreadScrollingReason::kIsNotStackingContextAndLCDText);
 
-  GetWebViewImpl()->GetSettings()->SetPreferCompositingToLCDTextEnabled(true);
+  GetWebView()->GetSettings()->SetPreferCompositingToLCDTextEnabled(true);
   ForceFullCompositingUpdate();
   EXPECT_FALSE(scrollable_area->GetNonCompositedMainThreadScrollingReasons() &
                MainThreadScrollingReason::kIsNotStackingContextAndLCDText);
-  GetWebViewImpl()->GetSettings()->SetPreferCompositingToLCDTextEnabled(false);
+  GetWebView()->GetSettings()->SetPreferCompositingToLCDTextEnabled(false);
 
   // Adding "contain: paint" to force a stacking context leads to promotion.
   container->setAttribute("style", "contain: paint", ASSERT_NO_EXCEPTION);
   ForceFullCompositingUpdate();
 
   EXPECT_FALSE(scrollable_area->GetNonCompositedMainThreadScrollingReasons());
 }
 
 TEST_P(NonCompositedMainThreadScrollingReasonTest,
        CompositedWithLCDTextRelatedReasonsTest) {
   // With "will-change:transform" we composite elements with
   // LCDTextRelatedReasons only. For elements with other
   // NonCompositedReasons, we don't create scrollingLayer for their
   // CompositedLayerMapping therefore they don't get composited.
-  GetWebViewImpl()->GetSettings()->SetPreferCompositingToLCDTextEnabled(false);
+  GetWebView()->GetSettings()->SetPreferCompositingToLCDTextEnabled(false);
   Document* document = GetFrame()->GetDocument();
   Element* container = document->getElementById("scroller1");
   ASSERT_TRUE(container);
   container->setAttribute("class", "composited transparent",
                           ASSERT_NO_EXCEPTION);
   ForceFullCompositingUpdate();
 
   PaintLayerScrollableArea* scrollable_area =
       ToLayoutBoxModelObject(container->GetLayoutObject())->GetScrollableArea();
   ASSERT_TRUE(scrollable_area);
   EXPECT_FALSE(scrollable_area->GetNonCompositedMainThreadScrollingReasons());
 
   Element* container2 = document->getElementById("scroller2");
   ASSERT_TRUE(container2);
   container2->setAttribute("class", "composited border-radius",
                            ASSERT_NO_EXCEPTION);
   ForceFullCompositingUpdate();
   PaintLayerScrollableArea* scrollable_area2 =
       ToLayoutBoxModelObject(container2->GetLayoutObject())
           ->GetScrollableArea();
   ASSERT_TRUE(scrollable_area2);
   EXPECT_TRUE(scrollable_area2->GetNonCompositedMainThreadScrollingReasons() &
               MainThreadScrollingReason::kHasBorderRadius);
 }
 
 }  // namespace blink