Change all test cases to use WebViewBase instead of WebViewImpl.

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

 /*
  * Copyright (C) 2010 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 61 matching lines @@
 #include "core/input/EventHandler.h"
 #include "core/layout/HitTestResult.h"
 #include "core/layout/LayoutFullScreen.h"
 #include "core/layout/api/LayoutViewItem.h"
 #include "core/layout/compositing/PaintLayerCompositor.h"
 #include "core/loader/DocumentLoader.h"
 #include "core/loader/DocumentThreadableLoader.h"
 #include "core/loader/DocumentThreadableLoaderClient.h"
 #include "core/loader/FrameLoadRequest.h"
 #include "core/loader/ThreadableLoader.h"
+#include "core/page/ChromeClient.h"
 #include "core/page/Page.h"
 #include "core/page/ScopedPageSuspender.h"
 #include "core/paint/PaintLayer.h"
 #include "core/testing/NullExecutionContext.h"
 #include "modules/mediastream/MediaStream.h"
 #include "modules/mediastream/MediaStreamRegistry.h"
 #include "platform/Cursor.h"
 #include "platform/DragImage.h"
 #include "platform/KeyboardCodes.h"
 #include "platform/PlatformResourceLoader.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/UserGestureIndicator.h"
 #include "platform/geometry/FloatRect.h"
+#include "platform/graphics/GraphicsLayer.h"
 #include "platform/loader/fetch/FetchParameters.h"
 #include "platform/loader/fetch/MemoryCache.h"
 #include "platform/loader/fetch/ResourceError.h"
 #include "platform/loader/fetch/ResourceFetcher.h"
 #include "platform/scroll/Scrollbar.h"
 #include "platform/scroll/ScrollbarTestSuite.h"
 #include "platform/scroll/ScrollbarTheme.h"
 #include "platform/scroll/ScrollbarThemeMock.h"
 #include "platform/scroll/ScrollbarThemeOverlayMock.h"
 #include "platform/testing/RuntimeEnabledFeaturesTestHelpers.h"
 #include "platform/testing/URLTestHelpers.h"
 #include "platform/testing/UnitTestHelpers.h"
 #include "platform/weborigin/KURLHash.h"
 #include "platform/weborigin/SchemeRegistry.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "platform/wtf/Forward.h"
 #include "platform/wtf/PtrUtil.h"
 #include "platform/wtf/dtoa/utils.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebCache.h"
 #include "public/platform/WebCachePolicy.h"
 #include "public/platform/WebClipboard.h"
+#include "public/platform/WebCoalescedInputEvent.h"
 #include "public/platform/WebFloatRect.h"
 #include "public/platform/WebKeyboardEvent.h"
 #include "public/platform/WebMockClipboard.h"
 #include "public/platform/WebSecurityOrigin.h"
 #include "public/platform/WebThread.h"
 #include "public/platform/WebURL.h"
 #include "public/platform/WebURLLoaderClient.h"
 #include "public/platform/WebURLLoaderMockFactory.h"
 #include "public/platform/WebURLResponse.h"
 #include "public/web/WebConsoleMessage.h"
@@ skipping 3107 matching lines @@
   EXPECT_TRUE(
       view->GetLayoutViewItem().Compositor()->LayerForVerticalScrollbar());
 
   web_view_helper.Resize(WebSize(view_width * 10, view_height * 10));
   EXPECT_FALSE(
       view->GetLayoutViewItem().Compositor()->LayerForHorizontalScrollbar());
   EXPECT_FALSE(
       view->GetLayoutViewItem().Compositor()->LayerForVerticalScrollbar());
 }
 
-void SetScaleAndScrollAndLayout(WebViewImpl* web_view,
+void SetScaleAndScrollAndLayout(WebViewBase* web_view,
                                 WebPoint scroll,
                                 float scale) {
   web_view->SetPageScaleFactor(scale);
   web_view->MainFrame()->SetScrollOffset(WebSize(scroll.x, scroll.y));
   web_view->UpdateAllLifecyclePhases();
 }
 
-void SimulatePageScale(WebViewImpl* web_view_impl, float& scale) {
+void SimulatePageScale(WebViewBase* web_view_impl, float& scale) {
   ScrollOffset scroll_delta =
       ToScrollOffset(
           web_view_impl->FakePageScaleAnimationTargetPositionForTesting()) -
       web_view_impl->MainFrameImpl()->GetFrameView()->GetScrollOffset();
   float scale_delta =
       web_view_impl->FakePageScaleAnimationPageScaleForTesting() /
       web_view_impl->PageScaleFactor();
   web_view_impl->ApplyViewportDeltas(WebFloatSize(), FloatSize(scroll_delta),
                                      WebFloatSize(), scale_delta, 0);
   scale = web_view_impl->PageScaleFactor();
 }
 
-void SimulateMultiTargetZoom(WebViewImpl* web_view_impl,
+void SimulateMultiTargetZoom(WebViewBase* web_view_impl,
                              const WebRect& rect,
                              float& scale) {
   if (web_view_impl->ZoomToMultipleTargetsRect(rect))
     SimulatePageScale(web_view_impl, scale);
 }
 
-void SimulateDoubleTap(WebViewImpl* web_view_impl,
+void SimulateDoubleTap(WebViewBase* web_view_impl,
                        WebPoint& point,
                        float& scale) {
   web_view_impl->AnimateDoubleTapZoom(point);
   EXPECT_TRUE(web_view_impl->FakeDoubleTapAnimationPendingForTesting());
   SimulatePageScale(web_view_impl, scale);
 }
 
 TEST_P(ParameterizedWebFrameTest, DivAutoZoomParamsTest) {
   RegisterMockedHttpURLLoad("get_scale_for_auto_zoom_into_div_test.html");
 
@@ skipping 1093 matching lines @@
   void Reset() { call_count_ = 0; }
 
  private:
   int call_count_;
 };
 
 TEST_P(ParameterizedWebFrameTest, TabKeyCursorMoveTriggersOneSelectionChange) {
   ChangedSelectionCounter counter;
   FrameTestHelpers::WebViewHelper web_view_helper;
   RegisterMockedHttpURLLoad("editable_elements.html");
-  WebViewImpl* web_view = web_view_helper.InitializeAndLoad(
+  WebViewBase* web_view = web_view_helper.InitializeAndLoad(
       base_url_ + "editable_elements.html", true, &counter);
 
   WebKeyboardEvent tab_down(WebInputEvent::kKeyDown,
                             WebInputEvent::kNoModifiers,
                             WebInputEvent::kTimeStampForTesting);
   WebKeyboardEvent tab_up(WebInputEvent::kKeyUp, WebInputEvent::kNoModifiers,
                           WebInputEvent::kTimeStampForTesting);
   tab_down.dom_key = Platform::Current()->DomKeyEnumFromString("\t");
   tab_up.dom_key = Platform::Current()->DomKeyEnumFromString("\t");
   tab_down.windows_key_code = VKEY_TAB;
@@ skipping 1857 matching lines @@
 TEST_F(WebFrameTest, DisambiguationPopupVisualViewport) {
   const std::string html_file = "disambiguation_popup_200_by_800.html";
   RegisterMockedHttpURLLoad(html_file);
 
   DisambiguationPopupTestWebViewClient client;
 
   FrameTestHelpers::WebViewHelper web_view_helper;
   web_view_helper.InitializeAndLoad(base_url_ + html_file, true, nullptr,
                                     &client, nullptr, ConfigureAndroid);
 
-  WebViewImpl* web_view_impl = web_view_helper.WebView();
+  WebViewBase* web_view_impl = web_view_helper.WebView();
   ASSERT_TRUE(web_view_impl);
   LocalFrame* frame = web_view_impl->MainFrameImpl()->GetFrame();
   ASSERT_TRUE(frame);
 
   web_view_helper.Resize(WebSize(100, 200));
 
   // Scroll main frame to the bottom of the document
   web_view_impl->MainFrame()->SetScrollOffset(WebSize(0, 400));
   EXPECT_SIZE_EQ(ScrollOffset(0, 400), frame->View()->GetScrollOffset());
 
@@ skipping 1319 matching lines @@
   WebHistoryCommitType LastCommitType() const { return last_commit_type_; }
 
  private:
   WebHistoryCommitType last_commit_type_;
 };
 
 TEST_P(ParameterizedWebFrameTest, SameDocumentHistoryNavigationCommitType) {
   RegisterMockedHttpURLLoad("push_state.html");
   TestDidNavigateCommitTypeWebFrameClient client;
   FrameTestHelpers::WebViewHelper web_view_helper;
-  WebViewImpl* web_view_impl = web_view_helper.InitializeAndLoad(
+  WebViewBase* web_view_impl = web_view_helper.InitializeAndLoad(
       base_url_ + "push_state.html", true, &client);
   Persistent<HistoryItem> item =
       ToLocalFrame(web_view_impl->GetPage()->MainFrame())
           ->Loader()
           .GetDocumentLoader()
           ->GetHistoryItem();
   RunPendingTasks();
 
   ToLocalFrame(web_view_impl->GetPage()->MainFrame())
       ->Loader()
@@ skipping 169 matching lines @@
   EXPECT_EQ(1, client.CallCount());
 }
 
 TEST_P(ParameterizedWebFrameTest, fixedPositionInFixedViewport) {
   RegisterMockedHttpURLLoad("fixed-position-in-fixed-viewport.html");
   FrameTestHelpers::WebViewHelper web_view_helper;
   web_view_helper.InitializeAndLoad(
       base_url_ + "fixed-position-in-fixed-viewport.html", true, nullptr,
       nullptr, nullptr, EnableViewportSettings);
 
-  WebViewImpl* web_view = web_view_helper.WebView();
+  WebViewBase* web_view = web_view_helper.WebView();
   web_view_helper.Resize(WebSize(100, 100));
 
   Document* document = web_view->MainFrameImpl()->GetFrame()->GetDocument();
   Element* bottom_fixed = document->getElementById("bottom-fixed");
   Element* top_bottom_fixed = document->getElementById("top-bottom-fixed");
   Element* right_fixed = document->getElementById("right-fixed");
   Element* left_right_fixed = document->getElementById("left-right-fixed");
 
   // The layout viewport will hit the min-scale limit of 0.25, so it'll be
   // 400x800.
@@ skipping 22 matching lines @@
 }
 
 TEST_F(WebFrameTest, FrameViewScrollAccountsForBrowserControls) {
   FakeCompositingWebViewClient client;
   RegisterMockedHttpURLLoad("long_scroll.html");
   FrameTestHelpers::WebViewHelper web_view_helper;
   web_view_helper.InitializeAndLoad(base_url_ + "long_scroll.html", true,
                                     nullptr, &client, nullptr,
                                     ConfigureAndroid);
 
-  WebViewImpl* web_view = web_view_helper.WebView();
+  WebViewBase* web_view = web_view_helper.WebView();
   FrameView* frame_view =
       web_view_helper.WebView()->MainFrameImpl()->GetFrameView();
 
   float browser_controls_height = 40;
   web_view->ResizeWithBrowserControls(WebSize(100, 100),
                                       browser_controls_height, false);
   web_view->SetPageScaleFactor(2.0f);
   web_view->UpdateAllLifecyclePhases();
 
   web_view->MainFrame()->SetScrollOffset(WebSize(0, 2000));
@@ skipping 77 matching lines @@
 }
 
 TEST_P(ParameterizedWebFrameTest, FullscreenLayerSize) {
   FakeCompositingWebViewClient client;
   RegisterMockedHttpURLLoad("fullscreen_div.html");
   FrameTestHelpers::WebViewHelper web_view_helper;
   int viewport_width = 640;
   int viewport_height = 480;
   client.screen_info_.rect.width = viewport_width;
   client.screen_info_.rect.height = viewport_height;
-  WebViewImpl* web_view_impl = web_view_helper.InitializeAndLoad(
+  WebViewBase* web_view_impl = web_view_helper.InitializeAndLoad(
       base_url_ + "fullscreen_div.html", true, nullptr, &client, nullptr,
       ConfigureAndroid);
   web_view_helper.Resize(WebSize(viewport_width, viewport_height));
   web_view_impl->UpdateAllLifecyclePhases();
 
   Document* document =
       web_view_impl->MainFrameImpl()->GetFrame()->GetDocument();
   UserGestureIndicator gesture(DocumentUserGestureToken::Create(document));
   Element* div_fullscreen = document->getElementById("div1");
   Fullscreen::RequestFullscreen(*div_fullscreen);
@@ skipping 22 matching lines @@
   EXPECT_EQ(viewport_height, fullscreen_layout_object->LogicalWidth().ToInt());
   EXPECT_EQ(viewport_width, fullscreen_layout_object->LogicalHeight().ToInt());
 }
 
 TEST_F(WebFrameTest, FullscreenLayerNonScrollable) {
   FakeCompositingWebViewClient client;
   RegisterMockedHttpURLLoad("fullscreen_div.html");
   FrameTestHelpers::WebViewHelper web_view_helper;
   int viewport_width = 640;
   int viewport_height = 480;
-  WebViewImpl* web_view_impl = web_view_helper.InitializeAndLoad(
+  WebViewBase* web_view_impl = web_view_helper.InitializeAndLoad(
       base_url_ + "fullscreen_div.html", true, nullptr, &client, nullptr,
       ConfigureAndroid);
   web_view_helper.Resize(WebSize(viewport_width, viewport_height));
   web_view_impl->UpdateAllLifecyclePhases();
 
   Document* document =
       web_view_impl->MainFrameImpl()->GetFrame()->GetDocument();
   UserGestureIndicator gesture(DocumentUserGestureToken::Create(document));
   Element* div_fullscreen = document->getElementById("div1");
   Fullscreen::RequestFullscreen(*div_fullscreen);
@@ skipping 35 matching lines @@
   ASSERT_TRUE(visual_viewport_scroll_layer->UserScrollableHorizontal());
   ASSERT_TRUE(visual_viewport_scroll_layer->UserScrollableVertical());
 }
 
 TEST_P(ParameterizedWebFrameTest, FullscreenMainFrame) {
   FakeCompositingWebViewClient client;
   RegisterMockedHttpURLLoad("fullscreen_div.html");
   FrameTestHelpers::WebViewHelper web_view_helper;
   int viewport_width = 640;
   int viewport_height = 480;
-  WebViewImpl* web_view_impl = web_view_helper.InitializeAndLoad(
+  WebViewBase* web_view_impl = web_view_helper.InitializeAndLoad(
       base_url_ + "fullscreen_div.html", true, nullptr, &client, nullptr,
       ConfigureAndroid);
   web_view_helper.Resize(WebSize(viewport_width, viewport_height));
   web_view_impl->UpdateAllLifecyclePhases();
 
   WebLayer* web_scroll_layer = web_view_impl->MainFrameImpl()
                                    ->GetFrame()
                                    ->View()
                                    ->LayoutViewportScrollableArea()
                                    ->LayerForScrolling()
@@ skipping 37 matching lines @@
   ASSERT_TRUE(web_scroll_layer->Scrollable());
   ASSERT_TRUE(web_scroll_layer->UserScrollableHorizontal());
   ASSERT_TRUE(web_scroll_layer->UserScrollableVertical());
 }
 
 TEST_P(ParameterizedWebFrameTest, FullscreenSubframe) {
   FakeCompositingWebViewClient client;
   RegisterMockedHttpURLLoad("fullscreen_iframe.html");
   RegisterMockedHttpURLLoad("fullscreen_div.html");
   FrameTestHelpers::WebViewHelper web_view_helper;
-  WebViewImpl* web_view_impl = web_view_helper.InitializeAndLoad(
+  WebViewBase* web_view_impl = web_view_helper.InitializeAndLoad(
       base_url_ + "fullscreen_iframe.html", true, nullptr, &client, nullptr,
       ConfigureAndroid);
   int viewport_width = 640;
   int viewport_height = 480;
   client.screen_info_.rect.width = viewport_width;
   client.screen_info_.rect.height = viewport_height;
   web_view_helper.Resize(WebSize(viewport_width, viewport_height));
   web_view_impl->UpdateAllLifecyclePhases();
 
   Document* document =
@@ skipping 20 matching lines @@
   EXPECT_EQ(viewport_height, fullscreen_layout_object->LogicalWidth().ToInt());
   EXPECT_EQ(viewport_width, fullscreen_layout_object->LogicalHeight().ToInt());
 }
 
 // Tests entering nested fullscreen and then exiting via the same code path
 // that's used when the browser process exits fullscreen.
 TEST_P(ParameterizedWebFrameTest, FullscreenNestedExit) {
   RegisterMockedHttpURLLoad("fullscreen_iframe.html");
   RegisterMockedHttpURLLoad("fullscreen_div.html");
   FrameTestHelpers::WebViewHelper web_view_helper;
-  WebViewImpl* web_view_impl = web_view_helper.InitializeAndLoad(
+  WebViewBase* web_view_impl = web_view_helper.InitializeAndLoad(
       base_url_ + "fullscreen_iframe.html", true);
 
   web_view_impl->UpdateAllLifecyclePhases();
 
   Document* top_doc = web_view_impl->MainFrameImpl()->GetFrame()->GetDocument();
   Element* top_body = top_doc->body();
 
   HTMLIFrameElement* iframe =
       toHTMLIFrameElement(top_doc->QuerySelector("iframe"));
   Document* iframe_doc = iframe->contentDocument();
@@ skipping 27 matching lines @@
   EXPECT_EQ(nullptr, Fullscreen::CurrentFullScreenElementFrom(*top_doc));
   EXPECT_EQ(nullptr, Fullscreen::FullscreenElementFrom(*top_doc));
   EXPECT_EQ(nullptr, Fullscreen::CurrentFullScreenElementFrom(*iframe_doc));
   EXPECT_EQ(nullptr, Fullscreen::FullscreenElementFrom(*iframe_doc));
 }
 
 TEST_P(ParameterizedWebFrameTest, FullscreenWithTinyViewport) {
   FakeCompositingWebViewClient client;
   RegisterMockedHttpURLLoad("viewport-tiny.html");
   FrameTestHelpers::WebViewHelper web_view_helper;
-  WebViewImpl* web_view_impl = web_view_helper.InitializeAndLoad(
+  WebViewBase* web_view_impl = web_view_helper.InitializeAndLoad(
       base_url_ + "viewport-tiny.html", true, nullptr, &client, nullptr,
       ConfigureAndroid);
   int viewport_width = 384;
   int viewport_height = 640;
   client.screen_info_.rect.width = viewport_width;
   client.screen_info_.rect.height = viewport_height;
   web_view_helper.Resize(WebSize(viewport_width, viewport_height));
   web_view_impl->UpdateAllLifecyclePhases();
 
   LayoutViewItem layout_view_item = web_view_helper.WebView()
@@ skipping 24 matching lines @@
   EXPECT_EQ(533, layout_view_item.LogicalHeight().Floor());
   EXPECT_FLOAT_EQ(1.2, web_view_impl->PageScaleFactor());
   EXPECT_FLOAT_EQ(1.2, web_view_impl->MinimumPageScaleFactor());
   EXPECT_FLOAT_EQ(5.0, web_view_impl->MaximumPageScaleFactor());
 }
 
 TEST_P(ParameterizedWebFrameTest, FullscreenResizeWithTinyViewport) {
   FakeCompositingWebViewClient client;
   RegisterMockedHttpURLLoad("viewport-tiny.html");
   FrameTestHelpers::WebViewHelper web_view_helper;
-  WebViewImpl* web_view_impl = web_view_helper.InitializeAndLoad(
+  WebViewBase* web_view_impl = web_view_helper.InitializeAndLoad(
       base_url_ + "viewport-tiny.html", true, nullptr, &client, nullptr,
       ConfigureAndroid);
   int viewport_width = 384;
   int viewport_height = 640;
   client.screen_info_.rect.width = viewport_width;
   client.screen_info_.rect.height = viewport_height;
   web_view_helper.Resize(WebSize(viewport_width, viewport_height));
   web_view_impl->UpdateAllLifecyclePhases();
 
   LayoutViewItem layout_view_item = web_view_helper.WebView()
@@ skipping 38 matching lines @@
   // resize and switching fullscreen state operations on WebView, with the
   // interference from Android status bars like a real device does.
   // This verifies we handle the transition and restore states correctly.
   WebSize screen_size_minus_status_bars_minus_url_bar(598, 303);
   WebSize screen_size_minus_status_bars(598, 359);
   WebSize screen_size(640, 384);
 
   FakeCompositingWebViewClient client;
   RegisterMockedHttpURLLoad("fullscreen_restore_scale_factor.html");
   FrameTestHelpers::WebViewHelper web_view_helper;
-  WebViewImpl* web_view_impl = web_view_helper.InitializeAndLoad(
+  WebViewBase* web_view_impl = web_view_helper.InitializeAndLoad(
       base_url_ + "fullscreen_restore_scale_factor.html", true, nullptr,
       &client, nullptr, &ConfigureAndroid);
   client.screen_info_.rect.width =
       screen_size_minus_status_bars_minus_url_bar.width;
   client.screen_info_.rect.height =
       screen_size_minus_status_bars_minus_url_bar.height;
   web_view_helper.Resize(screen_size_minus_status_bars_minus_url_bar);
   LayoutViewItem layout_view_item = web_view_helper.WebView()
                                         ->MainFrameImpl()
                                         ->GetFrameView()
@@ skipping 47 matching lines @@
 }
 
 // Tests that leaving fullscreen by navigating to a new page resets the
 // fullscreen page scale constraints.
 TEST_P(ParameterizedWebFrameTest, ClearFullscreenConstraintsOnNavigation) {
   RegisterMockedHttpURLLoad("viewport-tiny.html");
   FrameTestHelpers::WebViewHelper web_view_helper;
   int viewport_width = 100;
   int viewport_height = 200;
 
-  WebViewImpl* web_view_impl = web_view_helper.InitializeAndLoad(
+  WebViewBase* web_view_impl = web_view_helper.InitializeAndLoad(
       base_url_ + "viewport-tiny.html", true, nullptr, nullptr, nullptr,
       ConfigureAndroid);
 
   web_view_helper.Resize(WebSize(viewport_width, viewport_height));
   web_view_impl->UpdateAllLifecyclePhases();
 
   // viewport-tiny.html specifies a 320px layout width.
   LayoutViewItem layout_view_item =
       web_view_impl->MainFrameImpl()->GetFrameView()->GetLayoutViewItem();
   EXPECT_EQ(320, layout_view_item.LogicalWidth().Floor());
@@ skipping 55 matching lines @@
   TestFullscreenWebLayerTreeView test_fullscreen_layer_tree_view;
 };
 
 }  // anonymous namespace
 
 TEST_P(ParameterizedWebFrameTest, OverlayFullscreenVideo) {
   RuntimeEnabledFeatures::setForceOverlayFullscreenVideoEnabled(true);
   RegisterMockedHttpURLLoad("fullscreen_video.html");
   TestFullscreenWebViewClient web_view_client;
   FrameTestHelpers::WebViewHelper web_view_helper;
-  WebViewImpl* web_view_impl = web_view_helper.InitializeAndLoad(
+  WebViewBase* web_view_impl = web_view_helper.InitializeAndLoad(
       base_url_ + "fullscreen_video.html", true, nullptr, &web_view_client);
 
   const TestFullscreenWebLayerTreeView& layer_tree_view =
       web_view_client.test_fullscreen_layer_tree_view;
 
   Document* document =
       web_view_impl->MainFrameImpl()->GetFrame()->GetDocument();
   UserGestureIndicator gesture(DocumentUserGestureToken::Create(document));
   HTMLVideoElement* video =
       toHTMLVideoElement(document->getElementById("video"));
@@ skipping 12 matching lines @@
   EXPECT_FALSE(video->IsFullscreen());
   EXPECT_FALSE(layer_tree_view.has_transparent_background);
 }
 
 TEST_P(ParameterizedWebFrameTest, LayoutBlockPercentHeightDescendants) {
   RegisterMockedHttpURLLoad("percent-height-descendants.html");
   FrameTestHelpers::WebViewHelper web_view_helper;
   web_view_helper.InitializeAndLoad(base_url_ +
                                     "percent-height-descendants.html");
 
-  WebViewImpl* web_view = web_view_helper.WebView();
+  WebViewBase* web_view = web_view_helper.WebView();
   web_view_helper.Resize(WebSize(800, 800));
   web_view->UpdateAllLifecyclePhases();
 
   Document* document = web_view->MainFrameImpl()->GetFrame()->GetDocument();
   LayoutBlock* container =
       ToLayoutBlock(document->getElementById("container")->GetLayoutObject());
   LayoutBox* percent_height_in_anonymous =
       ToLayoutBox(document->getElementById("percent-height-in-anonymous")
                       ->GetLayoutObject());
   LayoutBox* percent_height_direct_child =
@@ skipping 14 matching lines @@
       percent_height_direct_child));
 
   LayoutBlock* anonymous_block = percent_height_in_anonymous->ContainingBlock();
   EXPECT_TRUE(anonymous_block->IsAnonymous());
   EXPECT_FALSE(anonymous_block->HasPercentHeightDescendants());
 }
 
 TEST_P(ParameterizedWebFrameTest, HasVisibleContentOnVisibleFrames) {
   RegisterMockedHttpURLLoad("visible_frames.html");
   FrameTestHelpers::WebViewHelper web_view_helper;
-  WebViewImpl* web_view_impl =
+  WebViewBase* web_view_impl =
       web_view_helper.InitializeAndLoad(base_url_ + "visible_frames.html");
   for (WebFrame* frame = web_view_impl->MainFrameImpl()->TraverseNext(); frame;
        frame = frame->TraverseNext()) {
     EXPECT_TRUE(frame->HasVisibleContent());
   }
 }
 
 TEST_P(ParameterizedWebFrameTest, HasVisibleContentOnHiddenFrames) {
   RegisterMockedHttpURLLoad("hidden_frames.html");
   FrameTestHelpers::WebViewHelper web_view_helper;
-  WebViewImpl* web_view_impl =
+  WebViewBase* web_view_impl =
       web_view_helper.InitializeAndLoad(base_url_ + "hidden_frames.html");
   for (WebFrame* frame = web_view_impl->MainFrameImpl()->TraverseNext(); frame;
        frame = frame->TraverseNext()) {
     EXPECT_FALSE(frame->HasVisibleContent());
   }
 }
 
 class ManifestChangeWebFrameClient
     : public FrameTestHelpers::TestWebFrameClient {
  public:
@@ skipping 257 matching lines @@
     RegisterMockedHttpURLLoad("subframe-c.html");
     RegisterMockedHttpURLLoad("subframe-hello.html");
 
     web_view_helper_.InitializeAndLoad(base_url_ + "frame-a-b-c.html", true);
   }
 
   void Reset() { web_view_helper_.Reset(); }
   WebFrame* MainFrame() const {
     return web_view_helper_.WebView()->MainFrame();
   }
-  WebViewImpl* WebView() const { return web_view_helper_.WebView(); }
+  WebViewBase* WebView() const { return web_view_helper_.WebView(); }
 
  private:
   FrameTestHelpers::WebViewHelper web_view_helper_;
 };
 
 TEST_F(WebFrameSwapTest, SwapMainFrame) {
   WebRemoteFrame* remote_frame =
       WebRemoteFrame::Create(WebTreeScopeType::kDocument, nullptr);
   MainFrame()->Swap(remote_frame);
 
@@ skipping 27 matching lines @@
 
   remote_frame->View()->Resize(size);
 
   FrameTestHelpers::TestWebFrameClient client;
   WebLocalFrame* local_frame = WebLocalFrame::CreateProvisional(
       &client, nullptr, nullptr, remote_frame, WebSandboxFlags::kNone);
   remote_frame->Swap(local_frame);
 
   // Verify that the size that was set with a remote main frame is correct
   // after swapping to a local frame.
-  Page* page =
-      ToWebViewImpl(local_frame->View())->GetPage()->MainFrame()->GetPage();
+  Page* page = static_cast<WebViewBase*>(local_frame->View())
+                   ->GetPage()
+                   ->MainFrame()
+                   ->GetPage();
   EXPECT_EQ(size.width, page->GetVisualViewport().Size().Width());
   EXPECT_EQ(size.height, page->GetVisualViewport().Size().Height());
 
   // Manually reset to break WebViewHelper's dependency on the stack allocated
   // TestWebFrameClient.
   Reset();
   remote_frame->Close();
 }
 
 namespace {
@@ skipping 1379 matching lines @@
   ScrollUpdate(&web_view_helper, 0, -150);
   Mock::VerifyAndClearExpectations(&client);
 
   ScrollEnd(&web_view_helper);
 }
 
 TEST_P(WebFrameOverscrollTest, ScaledPageRootLayerOverscrolled) {
   OverscrollWebViewClient client;
   RegisterMockedHttpURLLoad("overscroll/overscroll.html");
   FrameTestHelpers::WebViewHelper web_view_helper;
-  WebViewImpl* web_view_impl = web_view_helper.InitializeAndLoad(
+  WebViewBase* web_view_impl = web_view_helper.InitializeAndLoad(
       base_url_ + "overscroll/overscroll.html", true, nullptr, &client, nullptr,
       ConfigureAndroid);
   web_view_helper.Resize(WebSize(200, 200));
   web_view_impl->SetPageScaleFactor(3.0);
 
   // Calculation of accumulatedRootOverscroll and unusedDelta on scaled page.
   // The point is (99, 99) because we clamp in the division by 3 to 33 so when
   // we go back to viewport coordinates it becomes (99, 99).
   ScrollBegin(&web_view_helper);
   EXPECT_CALL(client, DidOverscroll(WebFloatSize(0, -30), WebFloatSize(0, -30),
@@ skipping 80 matching lines @@
 
   EXPECT_CALL(client, DidOverscroll(_, _, _, _)).Times(0);
   ScrollEnd(&web_view_helper);
   Mock::VerifyAndClearExpectations(&client);
 }
 
 TEST_F(WebFrameTest, OrientationFrameDetach) {
   RuntimeEnabledFeatures::setOrientationEventEnabled(true);
   RegisterMockedHttpURLLoad("orientation-frame-detach.html");
   FrameTestHelpers::WebViewHelper web_view_helper;
-  WebViewImpl* web_view_impl = web_view_helper.InitializeAndLoad(
+  WebViewBase* web_view_impl = web_view_helper.InitializeAndLoad(
       base_url_ + "orientation-frame-detach.html", true);
   web_view_impl->MainFrameImpl()->SendOrientationChangeEvent();
 }
 
 TEST_F(WebFrameTest, MaxFramesDetach) {
   RegisterMockedHttpURLLoad("max-frames-detach.html");
   FrameTestHelpers::WebViewHelper web_view_helper;
-  WebViewImpl* web_view_impl = web_view_helper.InitializeAndLoad(
+  WebViewBase* web_view_impl = web_view_helper.InitializeAndLoad(
       base_url_ + "max-frames-detach.html", true);
   web_view_impl->MainFrameImpl()->CollectGarbage();
 }
 
 TEST_F(WebFrameTest, ImageDocumentLoadFinishTime) {
   // Loading an image resource directly generates an ImageDocument with
   // the document loader feeding image data into the resource of a generated
   // img tag. We expect the load finish time to be the same for the document
   // and the image resource.
 
   RegisterMockedHttpURLLoadWithMimeType("white-1x1.png", "image/png");
   FrameTestHelpers::WebViewHelper web_view_helper;
   web_view_helper.InitializeAndLoad(base_url_ + "white-1x1.png");
-  WebViewImpl* web_view = web_view_helper.WebView();
+  WebViewBase* web_view = web_view_helper.WebView();
   Document* document = web_view->MainFrameImpl()->GetFrame()->GetDocument();
 
   EXPECT_TRUE(document);
   EXPECT_TRUE(document->IsImageDocument());
 
   ImageDocument* img_document = ToImageDocument(document);
   ImageResource* resource = img_document->CachedImageResourceDeprecated();
 
   EXPECT_TRUE(resource);
   EXPECT_NE(0, resource->LoadFinishTime());
@@ skipping 207 matching lines @@
 };
 
 TEST_F(WebFrameTest, SaveImageAt) {
   std::string url = base_url_ + "image-with-data-url.html";
   RegisterMockedURLLoadFromBase(base_url_, "image-with-data-url.html");
   URLTestHelpers::RegisterMockedURLLoad(
       ToKURL("http://test"), testing::WebTestDataPath("white-1x1.png"));
 
   FrameTestHelpers::WebViewHelper helper;
   SaveImageFromDataURLWebFrameClient client;
-  WebViewImpl* web_view = helper.InitializeAndLoad(url, true, &client);
+  WebViewBase* web_view = helper.InitializeAndLoad(url, true, &client);
   web_view->Resize(WebSize(400, 400));
   web_view->UpdateAllLifecyclePhases();
 
   WebLocalFrame* local_frame = web_view->MainFrameImpl();
 
   client.Reset();
   local_frame->SaveImageAt(WebPoint(1, 1));
   EXPECT_EQ(
       WebString::FromUTF8("data:image/gif;base64"
                           ",R0lGODlhAQABAIAAAAUEBAAAACwAAAAAAQABAAACAkQBADs="),
@@ skipping 16 matching lines @@
   // Explicitly reset to break dependency on locally scoped client.
   helper.Reset();
 }
 
 TEST_F(WebFrameTest, SaveImageWithImageMap) {
   std::string url = base_url_ + "image-map.html";
   RegisterMockedURLLoadFromBase(base_url_, "image-map.html");
 
   FrameTestHelpers::WebViewHelper helper;
   SaveImageFromDataURLWebFrameClient client;
-  WebViewImpl* web_view = helper.InitializeAndLoad(url, true, &client);
+  WebViewBase* web_view = helper.InitializeAndLoad(url, true, &client);
   web_view->Resize(WebSize(400, 400));
 
   WebLocalFrame* local_frame = web_view->MainFrameImpl();
 
   client.Reset();
   local_frame->SaveImageAt(WebPoint(25, 25));
   EXPECT_EQ(
       WebString::FromUTF8("data:image/gif;base64"
                           ",R0lGODlhAQABAIAAAAUEBAAAACwAAAAAAQABAAACAkQBADs="),
       client.Result());
@@ skipping 11 matching lines @@
 
   // Explicitly reset to break dependency on locally scoped client.
   helper.Reset();
 }
 
 TEST_F(WebFrameTest, CopyImageAt) {
   std::string url = base_url_ + "canvas-copy-image.html";
   RegisterMockedURLLoadFromBase(base_url_, "canvas-copy-image.html");
 
   FrameTestHelpers::WebViewHelper helper;
-  WebViewImpl* web_view = helper.InitializeAndLoad(url, true, 0);
+  WebViewBase* web_view = helper.InitializeAndLoad(url, true, 0);
   web_view->Resize(WebSize(400, 400));
 
   uint64_t sequence = Platform::Current()->Clipboard()->SequenceNumber(
       WebClipboard::kBufferStandard);
 
   WebLocalFrame* local_frame = web_view->MainFrameImpl();
   local_frame->CopyImageAt(WebPoint(50, 50));
 
   EXPECT_NE(sequence, Platform::Current()->Clipboard()->SequenceNumber(
                           WebClipboard::kBufferStandard));
 
   WebImage image =
       static_cast<WebMockClipboard*>(Platform::Current()->Clipboard())
           ->ReadRawImage(WebClipboard::Buffer());
 
   EXPECT_EQ(SkColorSetARGB(255, 255, 0, 0), image.GetSkBitmap().getColor(0, 0));
 };
 
 TEST_F(WebFrameTest, CopyImageAtWithPinchZoom) {
   std::string url = base_url_ + "canvas-copy-image.html";
   RegisterMockedURLLoadFromBase(base_url_, "canvas-copy-image.html");
 
   FrameTestHelpers::WebViewHelper helper;
-  WebViewImpl* web_view = helper.InitializeAndLoad(url, true, 0);
+  WebViewBase* web_view = helper.InitializeAndLoad(url, true, 0);
   web_view->Resize(WebSize(400, 400));
   web_view->UpdateAllLifecyclePhases();
   web_view->SetPageScaleFactor(2);
   web_view->SetVisualViewportOffset(WebFloatPoint(200, 200));
 
   uint64_t sequence = Platform::Current()->Clipboard()->SequenceNumber(
       WebClipboard::kBufferStandard);
 
   WebLocalFrame* local_frame = web_view->MainFrameImpl();
   local_frame->CopyImageAt(WebPoint(0, 0));
 
   EXPECT_NE(sequence, Platform::Current()->Clipboard()->SequenceNumber(
                           WebClipboard::kBufferStandard));
 
   WebImage image =
       static_cast<WebMockClipboard*>(Platform::Current()->Clipboard())
           ->ReadRawImage(WebClipboard::Buffer());
 
   EXPECT_EQ(SkColorSetARGB(255, 255, 0, 0), image.GetSkBitmap().getColor(0, 0));
 };
 
 TEST_F(WebFrameTest, CopyImageWithImageMap) {
   SaveImageFromDataURLWebFrameClient client;
 
   std::string url = base_url_ + "image-map.html";
   RegisterMockedURLLoadFromBase(base_url_, "image-map.html");
 
   FrameTestHelpers::WebViewHelper helper;
-  WebViewImpl* web_view = helper.InitializeAndLoad(url, true, &client);
+  WebViewBase* web_view = helper.InitializeAndLoad(url, true, &client);
   web_view->Resize(WebSize(400, 400));
 
   client.Reset();
   WebLocalFrame* local_frame = web_view->MainFrameImpl();
   local_frame->SaveImageAt(WebPoint(25, 25));
   EXPECT_EQ(
       WebString::FromUTF8("data:image/gif;base64"
                           ",R0lGODlhAQABAIAAAAUEBAAAACwAAAAAAQABAAACAkQBADs="),
       client.Result());
 
@@ skipping 169 matching lines @@
 // content size -- maintains a minimum height matching the viewport in cases
 // where the content is smaller.
 TEST_F(WebFrameTest, RootLayerMinimumHeight) {
   constexpr int kViewportWidth = 320;
   constexpr int kViewportHeight = 640;
   constexpr int kBrowserControlsHeight = 100;
 
   FrameTestHelpers::WebViewHelper web_view_helper;
   web_view_helper.Initialize(true, nullptr, nullptr, nullptr,
                              EnableViewportSettings);
-  WebViewImpl* web_view = web_view_helper.WebView();
+  WebViewBase* web_view = web_view_helper.WebView();
   web_view->ResizeWithBrowserControls(
       WebSize(kViewportWidth, kViewportHeight - kBrowserControlsHeight),
       kBrowserControlsHeight, true);
 
   InitializeWithHTML(*web_view->MainFrameImpl()->GetFrame(),
                      "<!DOCTYPE html>"
                      "<style>"
                      "  html, body {width:100%;height:540px;margin:0px}"
                      "  #elem {"
                      "    overflow: scroll;"
@@ skipping 45 matching lines @@
 
   document->View()->SetTracksPaintInvalidations(false);
 }
 
 // Load a page with display:none set and try to scroll it. It shouldn't crash
 // due to lack of layoutObject. crbug.com/653327.
 TEST_F(WebFrameTest, ScrollBeforeLayoutDoesntCrash) {
   RegisterMockedHttpURLLoad("display-none.html");
   FrameTestHelpers::WebViewHelper web_view_helper;
   web_view_helper.InitializeAndLoad(base_url_ + "display-none.html");
-  WebViewImpl* web_view = web_view_helper.WebView();
+  WebViewBase* web_view = web_view_helper.WebView();
   web_view_helper.Resize(WebSize(640, 480));
 
   Document* document = web_view->MainFrameImpl()->GetFrame()->GetDocument();
   document->documentElement()->SetLayoutObject(nullptr);
 
   WebGestureEvent begin_event(WebInputEvent::kGestureScrollBegin,
                               WebInputEvent::kNoModifiers,
                               WebInputEvent::kTimeStampForTesting);
   begin_event.source_device = kWebGestureDeviceTouchpad;
   WebGestureEvent update_event(WebInputEvent::kGestureScrollUpdate,
@@ skipping 18 matching lines @@
   web_view_helper.WebView()->HandleInputEvent(
       WebCoalescedInputEvent(update_event));
   web_view_helper.WebView()->HandleInputEvent(
       WebCoalescedInputEvent(end_event));
 }
 
 TEST_F(WebFrameTest, HidingScrollbarsOnScrollableAreaDisablesScrollbars) {
   FrameTestHelpers::WebViewHelper web_view_helper;
   web_view_helper.Initialize(true);
   web_view_helper.Resize(WebSize(800, 600));
-  WebViewImpl* web_view = web_view_helper.WebView();
+  WebViewBase* web_view = web_view_helper.WebView();
 
   InitializeWithHTML(
       *web_view->MainFrameImpl()->GetFrame(),
       "<!DOCTYPE html>"
       "<style>"
       "  #scroller { overflow: scroll; width: 1000px; height: 1000px }"
       "  #spacer { width: 2000px; height: 2000px }"
       "</style>"
       "<div id='scroller'>"
       "  <div id='spacer'></div>"
@@ skipping 41 matching lines @@
       scroller_area->HorizontalScrollbar()->ShouldParticipateInHitTesting());
   EXPECT_TRUE(
       scroller_area->VerticalScrollbar()->ShouldParticipateInHitTesting());
 }
 
 TEST_F(WebFrameTest, MouseOverDifferntNodeClearsTooltip) {
   FrameTestHelpers::WebViewHelper web_view_helper;
   web_view_helper.Initialize(true, nullptr, nullptr, nullptr,
                              [](WebSettings* settings) {});
   web_view_helper.Resize(WebSize(200, 200));
-  WebViewImpl* web_view = web_view_helper.WebView();
+  WebViewBase* web_view = web_view_helper.WebView();
 
   InitializeWithHTML(
       *web_view->MainFrameImpl()->GetFrame(),
       "<head>"
       "  <style type='text/css'>"
       "   div"
       "    {"
       "      width: 200px;"
       "      height: 100px;"
       "      background-color: #eeeeff;"
@@ skipping 59 matching lines @@
 }
 
 // Makes sure that mouse hover over an overlay scrollbar doesn't activate
 // elements below(except the Element that owns the scrollbar) unless the
 // scrollbar is faded out.
 TEST_F(WebFrameTest, MouseOverLinkAndOverlayScrollbar) {
   FrameTestHelpers::WebViewHelper web_view_helper;
   web_view_helper.Initialize(true, nullptr, nullptr, nullptr,
                              [](WebSettings* settings) {});
   web_view_helper.Resize(WebSize(20, 20));
-  WebViewImpl* web_view = web_view_helper.WebView();
+  WebViewBase* web_view = web_view_helper.WebView();
 
   InitializeWithHTML(*web_view->MainFrameImpl()->GetFrame(),
                      "<!DOCTYPE html>"
                      "<a id='a' href='javascript:void(0);'>"
                      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
                      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
                      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
                      "</a>"
                      "<div style='position: absolute; top: 1000px'>end</div>");
 
@@ skipping 92 matching lines @@
 
   document->GetFrame()->GetEventHandler().HandleMouseReleaseEvent(
       mouse_release_event);
 }
 
 // Makes sure that mouse hover over an custom scrollbar doesn't change the
 // activate elements.
 TEST_F(WebFrameTest, MouseOverCustomScrollbar) {
   RegisterMockedHttpURLLoad("custom-scrollbar-hover.html");
   FrameTestHelpers::WebViewHelper web_view_helper;
-  WebViewImpl* web_view = web_view_helper.InitializeAndLoad(
+  WebViewBase* web_view = web_view_helper.InitializeAndLoad(
       base_url_ + "custom-scrollbar-hover.html");
 
   web_view_helper.Resize(WebSize(200, 200));
 
   web_view->UpdateAllLifecyclePhases();
 
   Document* document =
       ToLocalFrame(web_view->GetPage()->MainFrame())->GetDocument();
 
   Element* scrollbar_div = document->getElementById("scrollbar");
@@ skipping 37 matching lines @@
   EXPECT_EQ(document->HoverElement(), scrollbar_div);
   EXPECT_EQ(hit_test_result.GetScrollbar()->HoveredPart(),
             ScrollbarPart::kThumbPart);
 }
 
 // Makes sure that mouse hover over an overlay scrollbar doesn't hover iframe
 // below.
 TEST_F(WebFrameTest, MouseOverScrollbarAndIFrame) {
   RegisterMockedHttpURLLoad("scrollbar-and-iframe-hover.html");
   FrameTestHelpers::WebViewHelper web_view_helper;
-  WebViewImpl* web_view = web_view_helper.InitializeAndLoad(
+  WebViewBase* web_view = web_view_helper.InitializeAndLoad(
       base_url_ + "scrollbar-and-iframe-hover.html");
 
   web_view_helper.Resize(WebSize(200, 200));
 
   web_view->UpdateAllLifecyclePhases();
 
   Document* document =
       ToLocalFrame(web_view->GetPage()->MainFrame())->GetDocument();
   Element* iframe = document->getElementById("iframe");
   DCHECK(iframe);
@@ skipping 55 matching lines @@
   // IFRAME hover.
   EXPECT_EQ(document->HoverElement(), iframe);
 }
 
 // Makes sure that mouse hover over a scrollbar also hover the element owns the
 // scrollbar.
 TEST_F(WebFrameTest, MouseOverScrollbarAndParentElement) {
   RegisterMockedHttpURLLoad("scrollbar-and-element-hover.html");
   FrameTestHelpers::WebViewHelper web_view_helper;
   RuntimeEnabledFeatures::setOverlayScrollbarsEnabled(false);
-  WebViewImpl* web_view = web_view_helper.InitializeAndLoad(
+  WebViewBase* web_view = web_view_helper.InitializeAndLoad(
       base_url_ + "scrollbar-and-element-hover.html");
 
   web_view_helper.Resize(WebSize(200, 200));
 
   web_view->UpdateAllLifecyclePhases();
 
   Document* document =
       ToLocalFrame(web_view->GetPage()->MainFrame())->GetDocument();
 
   Element* parent_div = document->getElementById("parent");
@@ skipping 62 matching lines @@
   document->GetFrame()->GetEventHandler().HandleMouseMoveEvent(
       mouse_move_over_div_and_scrollbar, Vector<WebMouseEvent>());
 
   // Not change the DIV :hover.
   EXPECT_EQ(document->HoverElement(), parent_div);
 }
 
 TEST_F(WebFrameTest, MouseReleaseUpdatesScrollbarHoveredPart) {
   RegisterMockedHttpURLLoad("custom-scrollbar-hover.html");
   FrameTestHelpers::WebViewHelper web_view_helper;
-  WebViewImpl* web_view = web_view_helper.InitializeAndLoad(
+  WebViewBase* web_view = web_view_helper.InitializeAndLoad(
       base_url_ + "custom-scrollbar-hover.html");
 
   web_view_helper.Resize(WebSize(200, 200));
 
   web_view->UpdateAllLifecyclePhases();
 
   Document* document =
       ToLocalFrame(web_view->GetPage()->MainFrame())->GetDocument();
 
   Element* scrollbar_div = document->getElementById("scrollbar");
@@ skipping 52 matching lines @@
       mouse_release_event);
   EXPECT_EQ(scrollbar->PressedPart(), ScrollbarPart::kNoPart);
   EXPECT_EQ(scrollbar->HoveredPart(), ScrollbarPart::kNoPart);
 }
 
 TEST_F(WebFrameTest,
        CustomScrollbarInOverlayScrollbarThemeWillNotCauseDCHECKFails) {
   RegisterMockedHttpURLLoad(
       "custom-scrollbar-dcheck-failed-when-paint-scroll-corner.html");
   FrameTestHelpers::WebViewHelper web_view_helper;
-  WebViewImpl* web_view = web_view_helper.InitializeAndLoad(
+  WebViewBase* web_view = web_view_helper.InitializeAndLoad(
       base_url_ +
       "custom-scrollbar-dcheck-failed-when-paint-scroll-corner.html");
 
   web_view_helper.Resize(WebSize(200, 200));
 
   // No DCHECK Fails. Issue 676678.
   web_view->UpdateAllLifecyclePhases();
 }
 
 static void DisableCompositing(WebSettings* settings) {
   settings->SetAcceleratedCompositingEnabled(false);
   settings->SetPreferCompositingToLCDTextEnabled(false);
 }
 
 // Make sure overlay scrollbars on non-composited scrollers fade out and set
 // the hidden bit as needed.
 TEST_F(WebFrameTest, TestNonCompositedOverlayScrollbarsFade) {
   FrameTestHelpers::WebViewHelper web_view_helper;
-  WebViewImpl* web_view_impl = web_view_helper.Initialize(
+  WebViewBase* web_view_impl = web_view_helper.Initialize(
       true, nullptr, nullptr, nullptr, &DisableCompositing);
 
   constexpr double kMockOverlayFadeOutDelayMs = 5.0;
 
   ScrollbarTheme& theme = ScrollbarTheme::GetTheme();
   // This test relies on mock overlay scrollbars.
   ASSERT_TRUE(theme.IsMockTheme());
   ASSERT_TRUE(theme.UsesOverlayScrollbars());
   ScrollbarThemeOverlayMock& mock_overlay_theme =
       (ScrollbarThemeOverlayMock&)theme;
@@ skipping 267 matching lines @@
   }
 
   bool DidShowVirtualKeyboard() const { return did_show_virtual_keyboard_; }
 
  private:
   bool did_show_virtual_keyboard_;
 };
 
 TEST_F(WebFrameTest, ShowVirtualKeyboardOnElementFocus) {
   FrameTestHelpers::WebViewHelper web_view_helper;
-  WebViewImpl* web_view = web_view_helper.Initialize(true);
+  WebViewBase* web_view = web_view_helper.Initialize(true);
   WebRemoteFrameImpl* remote_frame = static_cast<WebRemoteFrameImpl*>(
       WebRemoteFrame::Create(WebTreeScopeType::kDocument, nullptr));
   web_view->SetMainFrame(remote_frame);
   RefPtr<SecurityOrigin> unique_origin = SecurityOrigin::CreateUnique();
   remote_frame->GetFrame()->GetSecurityContext()->SetSecurityOrigin(
       unique_origin);
 
   ShowVirtualKeyboardObserverWidgetClient web_widget_client;
   WebLocalFrameImpl* local_frame = FrameTestHelpers::CreateLocalChild(
       remote_frame, "child", nullptr, &web_widget_client);
@@ skipping 27 matching lines @@
   WebContextMenuData GetMenuData() { return menu_data_; }
 
  private:
   WebContextMenuData menu_data_;
   DISALLOW_COPY_AND_ASSIGN(ContextMenuWebFrameClient);
 };
 
 bool TestSelectAll(const std::string& html) {
   ContextMenuWebFrameClient frame;
   FrameTestHelpers::WebViewHelper web_view_helper;
-  WebViewImpl* web_view = web_view_helper.Initialize(true, &frame);
+  WebViewBase* web_view = web_view_helper.Initialize(true, &frame);
   FrameTestHelpers::LoadHTMLString(web_view->MainFrame(), html,
                                    ToKURL("about:blank"));
   web_view->Resize(WebSize(500, 300));
   web_view->UpdateAllLifecyclePhases();
   RunPendingTasks();
   web_view->SetInitialFocus(false);
   RunPendingTasks();
 
   WebMouseEvent mouse_event(WebInputEvent::kMouseDown,
                             WebInputEvent::kNoModifiers,
@@ skipping 14 matching lines @@
   EXPECT_FALSE(TestSelectAll("<input>"));
   EXPECT_TRUE(TestSelectAll("<input value='nonempty'>"));
   EXPECT_FALSE(TestSelectAll("<div contenteditable></div>"));
   EXPECT_TRUE(TestSelectAll("<div contenteditable>nonempty</div>"));
   EXPECT_TRUE(TestSelectAll("<div contenteditable>\n</div>"));
 }
 
 TEST_F(WebFrameTest, ContextMenuDataSelectedText) {
   ContextMenuWebFrameClient frame;
   FrameTestHelpers::WebViewHelper web_view_helper;
-  WebViewImpl* web_view = web_view_helper.Initialize(true, &frame);
+  WebViewBase* web_view = web_view_helper.Initialize(true, &frame);
   const std::string& html = "<input value=' '>";
   FrameTestHelpers::LoadHTMLString(web_view->MainFrame(), html,
                                    ToKURL("about:blank"));
   web_view->Resize(WebSize(500, 300));
   web_view->UpdateAllLifecyclePhases();
   RunPendingTasks();
   web_view->SetInitialFocus(false);
   RunPendingTasks();
 
   web_view->MainFrameImpl()->ExecuteCommand(WebString::FromUTF8("SelectAll"));
@@ skipping 88 matching lines @@
 
   // Failing the original child frame navigation and trying to render fallback
   // content shouldn't crash. It should return NoLoadInProgress. This is so the
   // caller won't attempt to replace the correctly empty frame with an error
   // page.
   EXPECT_EQ(WebLocalFrame::NoLoadInProgress,
             child->MaybeRenderFallbackContent(WebURLError()));
 }
 
 }  // namespace blink