Update WebLocalFrameImpl with WebLocalFrameBase to break dependencies.

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

 /*
  * Copyright (C) 2011, 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:
  *
  *     * 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 29 matching lines @@
 #include "core/dom/NodeComputedStyle.h"
 #include "core/editing/FrameSelection.h"
 #include "core/editing/InputMethodController.h"
 #include "core/editing/markers/DocumentMarkerController.h"
 #include "core/exported/WebViewBase.h"
 #include "core/frame/EventHandlerRegistry.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/frame/VisualViewport.h"
+#include "core/frame/WebLocalFrameBase.h"
 #include "core/html/HTMLIFrameElement.h"
 #include "core/html/HTMLInputElement.h"
 #include "core/html/HTMLTextAreaElement.h"
 #include "core/layout/api/LayoutViewItem.h"
 #include "core/loader/DocumentLoader.h"
 #include "core/loader/FrameLoadRequest.h"
 #include "core/page/Page.h"
 #include "core/page/PrintContext.h"
 #include "core/page/ScopedPageSuspender.h"
 #include "core/paint/PaintLayer.h"
@@ skipping 41 matching lines @@
 #include "public/web/WebSettings.h"
 #include "public/web/WebTreeScopeType.h"
 #include "public/web/WebViewClient.h"
 #include "public/web/WebWidget.h"
 #include "public/web/WebWidgetClient.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "web/DevToolsEmulator.h"
 #include "web/WebInputMethodControllerImpl.h"
-#include "web/WebLocalFrameImpl.h"
 #include "web/WebSettingsImpl.h"
 #include "web/tests/FrameTestHelpers.h"
 
 #if OS(MACOSX)
 #include "public/web/mac/WebSubstringUtil.h"
 #endif
 
 using blink::FrameTestHelpers::LoadFrame;
 using blink::URLTestHelpers::ToKURL;
 using blink::URLTestHelpers::RegisterMockedURLLoad;
@@ skipping 384 matching lines @@
   EXPECT_TRUE(GreenChannel(color));
 }
 
 TEST_P(WebViewTest, FocusIsInactive) {
   RegisterMockedHttpURLLoad("visible_iframe.html");
   WebViewBase* web_view =
       web_view_helper_.InitializeAndLoad(base_url_ + "visible_iframe.html");
 
   web_view->SetFocus(true);
   web_view->SetIsActive(true);
-  WebLocalFrameImpl* frame = web_view->MainFrameImpl();
+  WebLocalFrameBase* frame = web_view->MainFrameImpl();
   EXPECT_TRUE(frame->GetFrame()->GetDocument()->IsHTMLDocument());
 
   Document* document = frame->GetFrame()->GetDocument();
   EXPECT_TRUE(document->hasFocus());
   web_view->SetFocus(false);
   web_view->SetIsActive(false);
   EXPECT_FALSE(document->hasFocus());
   web_view->SetFocus(true);
   web_view->SetIsActive(true);
   EXPECT_TRUE(document->hasFocus());
@@ skipping 141 matching lines @@
     VerticalScrollbarState expected_vertical_state) {
   AutoResizeWebViewClient client;
   std::string url =
       base_url_ + "specify_size.html?" + page_width + ":" + page_height;
   URLTestHelpers::RegisterMockedURLLoad(
       ToKURL(url), testing::WebTestDataPath("specify_size.html"));
   WebViewBase* web_view =
       web_view_helper_.InitializeAndLoad(url, true, 0, &client);
   client.GetTestData().SetWebView(web_view);
 
-  WebLocalFrameImpl* frame = web_view->MainFrameImpl();
+  WebLocalFrameBase* frame = web_view->MainFrameImpl();
   FrameView* frame_view = frame->GetFrame()->View();
   frame_view->UpdateLayout();
   EXPECT_FALSE(frame_view->LayoutPending());
   EXPECT_FALSE(frame_view->NeedsLayout());
 
   web_view->EnableAutoResizeMode(min_auto_resize, max_auto_resize);
   EXPECT_TRUE(frame_view->LayoutPending());
   EXPECT_TRUE(frame_view->NeedsLayout());
   frame_view->UpdateLayout();
 
@@ skipping 86 matching lines @@
   TestAutoResize(min_auto_resize, max_auto_resize, page_width, page_height,
                  expected_width, expected_height, kNoHorizontalScrollbar,
                  kNoVerticalScrollbar);
 }
 
 void WebViewTest::TestTextInputType(WebTextInputType expected_type,
                                     const std::string& html_file) {
   RegisterMockedHttpURLLoad(html_file);
   WebViewBase* web_view =
       web_view_helper_.InitializeAndLoad(base_url_ + html_file);
-  WebInputMethodControllerImpl* controller =
+  WebInputMethodController* controller =
       web_view->MainFrameImpl()->GetInputMethodController();
   EXPECT_EQ(kWebTextInputTypeNone, controller->TextInputType());
   EXPECT_EQ(kWebTextInputTypeNone, controller->TextInputInfo().type);
   web_view->SetInitialFocus(false);
   EXPECT_EQ(expected_type, controller->TextInputType());
   EXPECT_EQ(expected_type, controller->TextInputInfo().type);
   web_view->ClearFocusedElement();
   EXPECT_EQ(kWebTextInputTypeNone, controller->TextInputType());
   EXPECT_EQ(kWebTextInputTypeNone, controller->TextInputInfo().type);
 }
@@ skipping 105 matching lines @@
                               ->TextInputInfo();
 
   EXPECT_EQ("foo\xef\xbf\xbc", info.value.Utf8());
 }
 
 TEST_P(WebViewTest, SetEditableSelectionOffsetsAndTextInputInfo) {
   RegisterMockedHttpURLLoad("input_field_populated.html");
   WebViewBase* web_view = web_view_helper_.InitializeAndLoad(
       base_url_ + "input_field_populated.html");
   web_view->SetInitialFocus(false);
-  WebLocalFrameImpl* frame = web_view->MainFrameImpl();
-  WebInputMethodControllerImpl* active_input_method_controller =
+  WebLocalFrameBase* frame = web_view->MainFrameImpl();
+  WebInputMethodController* active_input_method_controller =
       frame->GetInputMethodController();
   frame->SetEditableSelectionOffsets(5, 13);
   EXPECT_EQ("56789abc", frame->SelectionAsText());
   WebTextInputInfo info = active_input_method_controller->TextInputInfo();
   EXPECT_EQ("0123456789abcdefghijklmnopqrstuvwxyz", info.value);
   EXPECT_EQ(5, info.selection_start);
   EXPECT_EQ(13, info.selection_end);
   EXPECT_EQ(-1, info.composition_start);
   EXPECT_EQ(-1, info.composition_end);
 
@@ skipping 401 matching lines @@
   RegisterMockedHttpURLLoad("form_with_input.html");
   WebViewBase* web_view =
       web_view_helper_.InitializeAndLoad(base_url_ + "form_with_input.html");
   web_view->Resize(WebSize(800, 600));
   web_view->SetInitialFocus(false);
   EXPECT_EQ(0, web_view->MainFrame()->GetScrollOffset().width);
   EXPECT_EQ(0, web_view->MainFrame()->GetScrollOffset().height);
 
   // Set up a composition from existing text that needs to be committed.
   Vector<CompositionUnderline> empty_underlines;
-  WebLocalFrameImpl* frame = web_view->MainFrameImpl();
+  WebLocalFrameBase* frame = web_view->MainFrameImpl();
   frame->GetFrame()->GetInputMethodController().SetCompositionFromExistingText(
       empty_underlines, 0, 3);
 
   // Scroll the input field out of the viewport.
   Element* element = static_cast<Element*>(
       web_view->MainFrame()->GetDocument().GetElementById("btn"));
   element->scrollIntoView();
   float offset_height = web_view->MainFrame()->GetScrollOffset().height;
   EXPECT_EQ(0, web_view->MainFrame()->GetScrollOffset().width);
   EXPECT_LT(0, offset_height);
@@ skipping 10 matching lines @@
 }
 
 TEST_P(WebViewTest, InsertNewLinePlacementAfterFinishComposingText) {
   RegisterMockedHttpURLLoad("text_area_populated.html");
   WebViewBase* web_view = web_view_helper_.InitializeAndLoad(
       base_url_ + "text_area_populated.html");
   web_view->SetInitialFocus(false);
 
   WebVector<WebCompositionUnderline> empty_underlines;
 
-  WebLocalFrameImpl* frame = web_view->MainFrameImpl();
+  WebLocalFrameBase* frame = web_view->MainFrameImpl();
   WebInputMethodController* active_input_method_controller =
       frame->GetInputMethodController();
   frame->SetEditableSelectionOffsets(4, 4);
   frame->SetCompositionFromExistingText(8, 12, empty_underlines);
 
   WebTextInputInfo info = active_input_method_controller->TextInputInfo();
   EXPECT_EQ("0123456789abcdefghijklmnopqrstuvwxyz",
             std::string(info.value.Utf8().data()));
   EXPECT_EQ(4, info.selection_start);
   EXPECT_EQ(4, info.selection_end);
@@ skipping 18 matching lines @@
   EXPECT_EQ(-1, info.composition_start);
   EXPECT_EQ(-1, info.composition_end);
   EXPECT_EQ("0123\n456789abcdefghijklmnopqrstuvwxyz",
             std::string(info.value.Utf8().data()));
 }
 
 TEST_P(WebViewTest, ExtendSelectionAndDelete) {
   RegisterMockedHttpURLLoad("input_field_populated.html");
   WebViewBase* web_view = web_view_helper_.InitializeAndLoad(
       base_url_ + "input_field_populated.html");
-  WebLocalFrameImpl* frame = web_view->MainFrameImpl();
+  WebLocalFrameBase* frame = web_view->MainFrameImpl();
   web_view->SetInitialFocus(false);
   frame->SetEditableSelectionOffsets(10, 10);
   frame->ExtendSelectionAndDelete(5, 8);
   WebInputMethodController* active_input_method_controller =
       frame->GetInputMethodController();
   WebTextInputInfo info = active_input_method_controller->TextInputInfo();
   EXPECT_EQ("01234ijklmnopqrstuvwxyz", std::string(info.value.Utf8().data()));
   EXPECT_EQ(5, info.selection_start);
   EXPECT_EQ(5, info.selection_end);
   frame->ExtendSelectionAndDelete(10, 0);
   info = active_input_method_controller->TextInputInfo();
   EXPECT_EQ("ijklmnopqrstuvwxyz", std::string(info.value.Utf8().data()));
 }
 
 TEST_P(WebViewTest, DeleteSurroundingText) {
   RegisterMockedHttpURLLoad("input_field_populated.html");
   WebView* web_view = web_view_helper_.InitializeAndLoad(
       base_url_ + "input_field_populated.html");
-  WebLocalFrameImpl* frame = ToWebLocalFrameImpl(web_view->MainFrame());
+  WebLocalFrameBase* frame = ToWebLocalFrameBase(web_view->MainFrame());
   WebInputMethodController* active_input_method_controller =
       frame->GetInputMethodController();
   web_view->SetInitialFocus(false);
 
   frame->SetEditableSelectionOffsets(10, 10);
   frame->DeleteSurroundingText(5, 8);
   WebTextInputInfo info = active_input_method_controller->TextInputInfo();
   EXPECT_EQ("01234ijklmnopqrstuvwxyz", std::string(info.value.Utf8().data()));
   EXPECT_EQ(5, info.selection_start);
   EXPECT_EQ(5, info.selection_end);
@@ skipping 25 matching lines @@
   EXPECT_EQ(0, info.selection_end);
 }
 
 TEST_P(WebViewTest, SetCompositionFromExistingText) {
   RegisterMockedHttpURLLoad("input_field_populated.html");
   WebViewBase* web_view = web_view_helper_.InitializeAndLoad(
       base_url_ + "input_field_populated.html");
   web_view->SetInitialFocus(false);
   WebVector<WebCompositionUnderline> underlines(static_cast<size_t>(1));
   underlines[0] = WebCompositionUnderline(0, 4, 0, false, 0);
-  WebLocalFrameImpl* frame = web_view->MainFrameImpl();
+  WebLocalFrameBase* frame = web_view->MainFrameImpl();
   WebInputMethodController* active_input_method_controller =
       frame->GetInputMethodController();
   frame->SetEditableSelectionOffsets(4, 10);
   frame->SetCompositionFromExistingText(8, 12, underlines);
   WebTextInputInfo info = active_input_method_controller->TextInputInfo();
   EXPECT_EQ(4, info.selection_start);
   EXPECT_EQ(10, info.selection_end);
   EXPECT_EQ(8, info.composition_start);
   EXPECT_EQ(12, info.composition_end);
   WebVector<WebCompositionUnderline> empty_underlines;
   frame->SetCompositionFromExistingText(0, 0, empty_underlines);
   info = active_input_method_controller->TextInputInfo();
   EXPECT_EQ(4, info.selection_start);
   EXPECT_EQ(10, info.selection_end);
   EXPECT_EQ(-1, info.composition_start);
   EXPECT_EQ(-1, info.composition_end);
 }
 
 TEST_P(WebViewTest, SetCompositionFromExistingTextInTextArea) {
   RegisterMockedHttpURLLoad("text_area_populated.html");
   WebViewBase* web_view = web_view_helper_.InitializeAndLoad(
       base_url_ + "text_area_populated.html");
   web_view->SetInitialFocus(false);
   WebVector<WebCompositionUnderline> underlines(static_cast<size_t>(1));
   underlines[0] = WebCompositionUnderline(0, 4, 0, false, 0);
-  WebLocalFrameImpl* frame = web_view->MainFrameImpl();
+  WebLocalFrameBase* frame = web_view->MainFrameImpl();
   WebInputMethodController* active_input_method_controller =
       frame->FrameWidget()->GetActiveWebInputMethodController();
   frame->SetEditableSelectionOffsets(27, 27);
   std::string new_line_text("\n");
   WebVector<WebCompositionUnderline> empty_underlines;
   active_input_method_controller->CommitText(
       WebString::FromUTF8(new_line_text.c_str()), empty_underlines, WebRange(),
       0);
   WebTextInputInfo info = active_input_method_controller->TextInputInfo();
   EXPECT_EQ("0123456789abcdefghijklmnopq\nrstuvwxyz",
@@ skipping 22 matching lines @@
   EXPECT_EQ(-1, info.composition_end);
 }
 
 TEST_P(WebViewTest, SetCompositionFromExistingTextInRichText) {
   RegisterMockedHttpURLLoad("content_editable_rich_text.html");
   WebViewBase* web_view = web_view_helper_.InitializeAndLoad(
       base_url_ + "content_editable_rich_text.html");
   web_view->SetInitialFocus(false);
   WebVector<WebCompositionUnderline> underlines(static_cast<size_t>(1));
   underlines[0] = WebCompositionUnderline(0, 4, 0, false, 0);
-  WebLocalFrameImpl* frame = web_view->MainFrameImpl();
+  WebLocalFrameBase* frame = web_view->MainFrameImpl();
   frame->SetEditableSelectionOffsets(1, 1);
   WebDocument document = web_view->MainFrame()->GetDocument();
   EXPECT_FALSE(document.GetElementById("bold").IsNull());
   frame->SetCompositionFromExistingText(0, 4, underlines);
   EXPECT_FALSE(document.GetElementById("bold").IsNull());
 }
 
 TEST_P(WebViewTest, SetEditableSelectionOffsetsKeepsComposition) {
   RegisterMockedHttpURLLoad("input_field_populated.html");
   WebViewBase* web_view = web_view_helper_.InitializeAndLoad(
@@ skipping 14 matching lines @@
       WebString::FromUTF8(composition_text_second.c_str()), empty_underlines,
       WebRange(), 5, 5);
 
   WebTextInputInfo info = active_input_method_controller->TextInputInfo();
   EXPECT_EQ("hello world", std::string(info.value.Utf8().data()));
   EXPECT_EQ(11, info.selection_start);
   EXPECT_EQ(11, info.selection_end);
   EXPECT_EQ(6, info.composition_start);
   EXPECT_EQ(11, info.composition_end);
 
-  WebLocalFrameImpl* frame = web_view->MainFrameImpl();
+  WebLocalFrameBase* frame = web_view->MainFrameImpl();
   frame->SetEditableSelectionOffsets(6, 6);
   info = active_input_method_controller->TextInputInfo();
   EXPECT_EQ("hello world", std::string(info.value.Utf8().data()));
   EXPECT_EQ(6, info.selection_start);
   EXPECT_EQ(6, info.selection_end);
   EXPECT_EQ(6, info.composition_start);
   EXPECT_EQ(11, info.composition_end);
 
   frame->SetEditableSelectionOffsets(8, 8);
   info = active_input_method_controller->TextInputInfo();
@@ skipping 700 matching lines @@
   web_view->Resize(WebSize(500, 500));
   web_view->UpdateAllLifecyclePhases();
   RunPendingTasks();
 
   WebGestureEvent event(WebInputEvent::kGestureLongPress,
                         WebInputEvent::kNoModifiers,
                         WebInputEvent::kTimeStampForTesting);
   event.source_device = kWebGestureDeviceTouchscreen;
   event.x = 300;
   event.y = 300;
-  WebLocalFrameImpl* frame = web_view->MainFrameImpl();
+  WebLocalFrameBase* frame = web_view->MainFrameImpl();
 
   EXPECT_EQ(WebInputEventResult::kHandledSystem,
             web_view->HandleInputEvent(WebCoalescedInputEvent(event)));
   EXPECT_TRUE(frame->SelectionAsText().IsEmpty());
 }
 
 TEST_P(WebViewTest, LongPressSelection) {
   RegisterMockedHttpURLLoad("longpress_selection.html");
 
   WebViewBase* web_view = web_view_helper_.InitializeAndLoad(
       base_url_ + "longpress_selection.html", true);
   web_view->Resize(WebSize(500, 300));
   web_view->UpdateAllLifecyclePhases();
   RunPendingTasks();
 
   WebString target = WebString::FromUTF8("target");
   WebString onselectstartfalse = WebString::FromUTF8("onselectstartfalse");
-  WebLocalFrameImpl* frame = web_view->MainFrameImpl();
+  WebLocalFrameBase* frame = web_view->MainFrameImpl();
 
   EXPECT_TRUE(
       TapElementById(WebInputEvent::kGestureLongPress, onselectstartfalse));
   EXPECT_EQ("", std::string(frame->SelectionAsText().Utf8().data()));
   EXPECT_TRUE(TapElementById(WebInputEvent::kGestureLongPress, target));
   EXPECT_EQ("testword", std::string(frame->SelectionAsText().Utf8().data()));
 }
 
 TEST_P(WebViewTest, FinishComposingTextDoesNotDismissHandles) {
   RegisterMockedHttpURLLoad("longpress_selection.html");
 
   WebViewBase* web_view = web_view_helper_.InitializeAndLoad(
       base_url_ + "longpress_selection.html", true);
   web_view->Resize(WebSize(500, 300));
   web_view->UpdateAllLifecyclePhases();
   RunPendingTasks();
 
   WebString target = WebString::FromUTF8("target");
-  WebLocalFrameImpl* frame = web_view->MainFrameImpl();
+  WebLocalFrameBase* frame = web_view->MainFrameImpl();
   WebInputMethodController* active_input_method_controller =
       frame->FrameWidget()->GetActiveWebInputMethodController();
   EXPECT_TRUE(TapElementById(WebInputEvent::kGestureTap, target));
   WebVector<WebCompositionUnderline> empty_underlines;
   frame->SetEditableSelectionOffsets(8, 8);
   EXPECT_TRUE(active_input_method_controller->SetComposition(
       "12345", empty_underlines, WebRange(), 8, 13));
   EXPECT_TRUE(frame->GetFrame()->GetInputMethodController().HasComposition());
   EXPECT_EQ("", std::string(frame->SelectionAsText().Utf8().data()));
   EXPECT_FALSE(frame->GetFrame()->Selection().IsHandleVisible());
@@ skipping 15 matching lines @@
 TEST_P(WebViewTest, TouchDoesntSelectEmptyTextarea) {
   RegisterMockedHttpURLLoad("longpress_textarea.html");
 
   WebViewBase* web_view = web_view_helper_.InitializeAndLoad(
       base_url_ + "longpress_textarea.html", true);
   web_view->Resize(WebSize(500, 300));
   web_view->UpdateAllLifecyclePhases();
   RunPendingTasks();
 
   WebString blanklinestextbox = WebString::FromUTF8("blanklinestextbox");
-  WebLocalFrameImpl* frame = web_view->MainFrameImpl();
+  WebLocalFrameBase* frame = web_view->MainFrameImpl();
 
   // Long-press on carriage returns.
   EXPECT_TRUE(
       TapElementById(WebInputEvent::kGestureLongPress, blanklinestextbox));
   EXPECT_TRUE(frame->SelectionAsText().IsEmpty());
 
   // Double-tap on carriage returns.
   WebGestureEvent event(WebInputEvent::kGestureTap, WebInputEvent::kNoModifiers,
                         WebInputEvent::kTimeStampForTesting);
   event.source_device = kWebGestureDeviceTouchscreen;
@@ skipping 40 matching lines @@
 TEST_P(WebViewTest, BlinkCaretAfterLongPress) {
   RegisterMockedHttpURLLoad("blink_caret_on_typing_after_long_press.html");
 
   WebViewBase* web_view = web_view_helper_.InitializeAndLoad(
       base_url_ + "blink_caret_on_typing_after_long_press.html", true);
   web_view->Resize(WebSize(640, 480));
   web_view->UpdateAllLifecyclePhases();
   RunPendingTasks();
 
   WebString target = WebString::FromUTF8("target");
-  WebLocalFrameImpl* main_frame = web_view->MainFrameImpl();
+  WebLocalFrameBase* main_frame = web_view->MainFrameImpl();
 
   EXPECT_TRUE(TapElementById(WebInputEvent::kGestureLongPress, target));
   EXPECT_FALSE(main_frame->GetFrame()->Selection().IsCaretBlinkingSuspended());
 }
 
 TEST_P(WebViewTest, BlinkCaretOnClosingContextMenu) {
   RegisterMockedHttpURLLoad("form.html");
   WebViewBase* web_view =
       web_view_helper_.InitializeAndLoad(base_url_ + "form.html", true);
 
   web_view->SetInitialFocus(false);
   RunPendingTasks();
 
   // We suspend caret blinking when pressing with mouse right button.
   // Note that we do not send MouseUp event here since it will be consumed
   // by the context menu once it shows up.
   WebMouseEvent mouse_event(WebInputEvent::kMouseDown,
                             WebInputEvent::kNoModifiers,
                             WebInputEvent::kTimeStampForTesting);
 
   mouse_event.button = WebMouseEvent::Button::kRight;
   mouse_event.SetPositionInWidget(1, 1);
   mouse_event.click_count = 1;
   web_view->HandleInputEvent(WebCoalescedInputEvent(mouse_event));
   RunPendingTasks();
 
-  WebLocalFrameImpl* main_frame = web_view->MainFrameImpl();
+  WebLocalFrameBase* main_frame = web_view->MainFrameImpl();
   EXPECT_TRUE(main_frame->GetFrame()->Selection().IsCaretBlinkingSuspended());
 
   // Caret blinking is still suspended after showing context menu.
   web_view->ShowContextMenu();
   EXPECT_TRUE(main_frame->GetFrame()->Selection().IsCaretBlinkingSuspended());
 
   // Caret blinking will be resumed only after context menu is closed.
   web_view->DidCloseContextMenu();
 
   EXPECT_FALSE(main_frame->GetFrame()->Selection().IsCaretBlinkingSuspended());
 }
 
 TEST_P(WebViewTest, SelectionOnReadOnlyInput) {
   RegisterMockedHttpURLLoad("selection_readonly.html");
   WebViewBase* web_view = web_view_helper_.InitializeAndLoad(
       base_url_ + "selection_readonly.html", true);
   web_view->Resize(WebSize(640, 480));
   web_view->UpdateAllLifecyclePhases();
   RunPendingTasks();
 
   std::string test_word = "This text should be selected.";
 
-  WebLocalFrameImpl* frame = web_view->MainFrameImpl();
+  WebLocalFrameBase* frame = web_view->MainFrameImpl();
   EXPECT_EQ(test_word, std::string(frame->SelectionAsText().Utf8().data()));
 
   WebRange range = web_view->CaretOrSelectionRange();
   EXPECT_FALSE(range.IsNull());
   EXPECT_EQ(0, range.StartOffset());
   EXPECT_EQ(static_cast<int>(test_word.length()), range.length());
 }
 
 TEST_P(WebViewTest, KeyDownScrollsHandled) {
   RegisterMockedHttpURLLoad("content-width-1000.html");
@@ skipping 154 matching lines @@
   int text_changes_;
   int text_changes_from_user_gesture_;
   int user_gesture_notifications_count_;
 };
 
 TEST_P(WebViewTest, LosingFocusDoesNotTriggerAutofillTextChange) {
   RegisterMockedHttpURLLoad("input_field_populated.html");
   MockAutofillClient client;
   WebViewBase* web_view = web_view_helper_.InitializeAndLoad(
       base_url_ + "input_field_populated.html");
-  WebLocalFrameImpl* frame = web_view->MainFrameImpl();
+  WebLocalFrameBase* frame = web_view->MainFrameImpl();
   frame->SetAutofillClient(&client);
   web_view->SetInitialFocus(false);
 
   // Set up a composition that needs to be committed.
   WebVector<WebCompositionUnderline> empty_underlines;
   frame->SetEditableSelectionOffsets(4, 10);
   frame->SetCompositionFromExistingText(8, 12, empty_underlines);
   WebTextInputInfo info = frame->GetInputMethodController()->TextInputInfo();
   EXPECT_EQ(4, info.selection_start);
   EXPECT_EQ(10, info.selection_end);
@@ skipping 21 matching lines @@
   EXPECT_EQ(selection_end, info.selection_end) << fail_message;
   EXPECT_EQ(composition_start, info.composition_start) << fail_message;
   EXPECT_EQ(composition_end, info.composition_end) << fail_message;
 }
 
 TEST_P(WebViewTest, CompositionNotCancelledByBackspace) {
   RegisterMockedHttpURLLoad("composition_not_cancelled_by_backspace.html");
   MockAutofillClient client;
   WebViewBase* web_view = web_view_helper_.InitializeAndLoad(
       base_url_ + "composition_not_cancelled_by_backspace.html");
-  WebLocalFrameImpl* frame = web_view->MainFrameImpl();
+  WebLocalFrameBase* frame = web_view->MainFrameImpl();
   frame->SetAutofillClient(&client);
   web_view->SetInitialFocus(false);
 
   // Test both input elements.
   for (int i = 0; i < 2; ++i) {
     // Select composition and do sanity check.
     WebVector<WebCompositionUnderline> empty_underlines;
     frame->SetEditableSelectionOffsets(6, 6);
     WebInputMethodController* active_input_method_controller =
         frame->FrameWidget()->GetActiveWebInputMethodController();
@@ skipping 25 matching lines @@
   }
 
   frame->SetAutofillClient(0);
 }
 
 TEST_P(WebViewTest, FinishComposingTextDoesntTriggerAutofillTextChange) {
   RegisterMockedHttpURLLoad("input_field_populated.html");
   MockAutofillClient client;
   WebViewBase* web_view = web_view_helper_.InitializeAndLoad(
       base_url_ + "input_field_populated.html");
-  WebLocalFrameImpl* frame = web_view->MainFrameImpl();
+  WebLocalFrameBase* frame = web_view->MainFrameImpl();
   frame->SetAutofillClient(&client);
   web_view->SetInitialFocus(false);
 
   WebDocument document = web_view->MainFrame()->GetDocument();
   HTMLFormControlElement* form =
       ToHTMLFormControlElement(document.GetElementById("sample"));
 
   WebInputMethodController* active_input_method_controller =
       frame->FrameWidget()->GetActiveWebInputMethodController();
   // Set up a composition that needs to be committed.
@@ skipping 21 matching lines @@
 
   frame->SetAutofillClient(0);
 }
 
 TEST_P(WebViewTest,
        SetCompositionFromExistingTextDoesntTriggerAutofillTextChange) {
   RegisterMockedHttpURLLoad("input_field_populated.html");
   MockAutofillClient client;
   WebViewBase* web_view = web_view_helper_.InitializeAndLoad(
       base_url_ + "input_field_populated.html", true);
-  WebLocalFrameImpl* frame = web_view->MainFrameImpl();
+  WebLocalFrameBase* frame = web_view->MainFrameImpl();
   frame->SetAutofillClient(&client);
   web_view->SetInitialFocus(false);
 
   WebVector<WebCompositionUnderline> empty_underlines;
 
   client.ClearChangeCounts();
   frame->SetCompositionFromExistingText(8, 12, empty_underlines);
 
   WebTextInputInfo info = frame->GetInputMethodController()->TextInputInfo();
   EXPECT_EQ("0123456789abcdefghijklmnopqrstuvwxyz",
@@ skipping 42 matching lines @@
 
   WebURL base_url = URLTestHelpers::ToKURL("http://example.com/");
   FrameTestHelpers::LoadHTMLString(
       web_view_impl->MainFrame(),
       "<html><body><iframe src=\"about:blank\"></iframe></body></html>",
       base_url);
 
   // Make a request from a local frame.
   WebURLRequest web_url_request_with_target_start;
   LocalFrame* local_frame =
-      ToWebLocalFrameImpl(web_view_impl->MainFrame()->FirstChild())->GetFrame();
+      ToWebLocalFrameBase(web_view_impl->MainFrame()->FirstChild())->GetFrame();
   FrameLoadRequest request_with_target_start(
       local_frame->GetDocument(),
       web_url_request_with_target_start.ToResourceRequest(), "_top");
   local_frame->Loader().Load(request_with_target_start);
   EXPECT_FALSE(client.DidFocusCalled());
 
   web_view_helper.Reset();  // Remove dependency on locally scoped client.
 }
 
 TEST_P(WebViewTest, FocusExistingFrameOnNavigate) {
   ViewCreatingWebViewClient client;
   FrameTestHelpers::WebViewHelper web_view_helper;
   WebViewBase* web_view_impl = web_view_helper.Initialize(true, 0, &client);
-  WebLocalFrameImpl* frame = web_view_impl->MainFrameImpl();
+  WebLocalFrameBase* frame = web_view_impl->MainFrameImpl();
   frame->SetName("_start");
 
   // Make a request that will open a new window
   WebURLRequest web_url_request;
   FrameLoadRequest request(0, web_url_request.ToResourceRequest(), "_blank");
   ToLocalFrame(web_view_impl->GetPage()->MainFrame())->Loader().Load(request);
   ASSERT_TRUE(client.CreatedWebView());
   EXPECT_FALSE(client.DidFocusCalled());
 
   // Make a request from the new window that will navigate the original window.
@@ skipping 531 matching lines @@
 
   EXPECT_FALSE(registry.HasEventHandlers(EventHandlerRegistry::kScrollEvent));
 }
 
 // This test verifies the text input flags are correctly exposed to script.
 TEST_P(WebViewTest, TextInputFlags) {
   std::string url = RegisterMockedHttpURLLoad("text_input_flags.html");
   WebViewBase* web_view_impl = web_view_helper_.InitializeAndLoad(url, true);
   web_view_impl->SetInitialFocus(false);
 
-  WebLocalFrameImpl* frame = web_view_impl->MainFrameImpl();
-  WebInputMethodControllerImpl* active_input_method_controller =
+  WebLocalFrameBase* frame = web_view_impl->MainFrameImpl();
+  WebInputMethodController* active_input_method_controller =
       frame->GetInputMethodController();
   Document* document = frame->GetFrame()->GetDocument();
 
   // (A) <input>
   // (A.1) Verifies autocorrect/autocomplete/spellcheck flags are Off and
   // autocapitalize is set to none.
   HTMLInputElement* input_element =
       toHTMLInputElement(document->getElementById("input"));
   document->SetFocusedElement(
       input_element,
@@ skipping 37 matching lines @@
   web_view_helper_.Reset();
 }
 
 // Check that the WebAutofillClient is correctly notified about first user
 // gestures after load, following various input events.
 TEST_P(WebViewTest, FirstUserGestureObservedKeyEvent) {
   RegisterMockedHttpURLLoad("form.html");
   MockAutofillClient client;
   WebViewBase* web_view =
       web_view_helper_.InitializeAndLoad(base_url_ + "form.html", true);
-  WebLocalFrameImpl* frame = web_view->MainFrameImpl();
+  WebLocalFrameBase* frame = web_view->MainFrameImpl();
   frame->SetAutofillClient(&client);
   web_view->SetInitialFocus(false);
 
   EXPECT_EQ(0, client.GetUserGestureNotificationsCount());
 
   WebKeyboardEvent key_event(WebInputEvent::kRawKeyDown,
                              WebInputEvent::kNoModifiers,
                              WebInputEvent::kTimeStampForTesting);
   key_event.dom_key = Platform::Current()->DomKeyEnumFromString(" ");
   key_event.windows_key_code = VKEY_SPACE;
   web_view->HandleInputEvent(WebCoalescedInputEvent(key_event));
   key_event.SetType(WebInputEvent::kKeyUp);
   web_view->HandleInputEvent(WebCoalescedInputEvent(key_event));
 
   EXPECT_EQ(2, client.GetUserGestureNotificationsCount());
   frame->SetAutofillClient(0);
 }
 
 TEST_P(WebViewTest, FirstUserGestureObservedMouseEvent) {
   RegisterMockedHttpURLLoad("form.html");
   MockAutofillClient client;
   WebViewBase* web_view =
       web_view_helper_.InitializeAndLoad(base_url_ + "form.html", true);
-  WebLocalFrameImpl* frame = web_view->MainFrameImpl();
+  WebLocalFrameBase* frame = web_view->MainFrameImpl();
   frame->SetAutofillClient(&client);
   web_view->SetInitialFocus(false);
 
   EXPECT_EQ(0, client.GetUserGestureNotificationsCount());
 
   WebMouseEvent mouse_event(WebInputEvent::kMouseDown,
                             WebInputEvent::kNoModifiers,
                             WebInputEvent::kTimeStampForTesting);
   mouse_event.button = WebMouseEvent::Button::kLeft;
   mouse_event.SetPositionInWidget(1, 1);
   mouse_event.click_count = 1;
   web_view->HandleInputEvent(WebCoalescedInputEvent(mouse_event));
   mouse_event.SetType(WebInputEvent::kMouseUp);
   web_view->HandleInputEvent(WebCoalescedInputEvent(mouse_event));
 
   EXPECT_EQ(1, client.GetUserGestureNotificationsCount());
   frame->SetAutofillClient(0);
 }
 
 TEST_P(WebViewTest, CompositionIsUserGesture) {
   RegisterMockedHttpURLLoad("input_field_populated.html");
   WebViewBase* web_view = web_view_helper_.InitializeAndLoad(
       base_url_ + "input_field_populated.html");
-  WebLocalFrameImpl* frame = web_view->MainFrameImpl();
+  WebLocalFrameBase* frame = web_view->MainFrameImpl();
   MockAutofillClient client;
   frame->SetAutofillClient(&client);
   web_view->SetInitialFocus(false);
 
   EXPECT_TRUE(
       frame->FrameWidget()->GetActiveWebInputMethodController()->SetComposition(
           WebString::FromUTF8(std::string("hello").c_str()),
           WebVector<WebCompositionUnderline>(), WebRange(), 3, 3));
   EXPECT_EQ(1, client.TextChangesFromUserGesture());
   EXPECT_FALSE(UserGestureIndicator::ProcessingUserGesture());
   EXPECT_TRUE(frame->HasMarkedText());
 
   frame->SetAutofillClient(0);
 }
 
 TEST_P(WebViewTest, CompareSelectAllToContentAsText) {
   RegisterMockedHttpURLLoad("longpress_selection.html");
   WebViewBase* web_view = web_view_helper_.InitializeAndLoad(
       base_url_ + "longpress_selection.html", true);
 
-  WebLocalFrameImpl* frame = web_view->MainFrameImpl();
+  WebLocalFrameBase* frame = web_view->MainFrameImpl();
   frame->ExecuteScript(WebScriptSource(
       WebString::FromUTF8("document.execCommand('SelectAll', false, null)")));
   std::string actual = frame->SelectionAsText().Utf8();
 
   const int kMaxOutputCharacters = 1024;
   std::string expected =
       WebFrameContentDumper::DumpWebViewAsText(web_view, kMaxOutputCharacters)
           .Utf8();
   EXPECT_EQ(expected, actual);
 }
@@ skipping 173 matching lines @@
 TEST_P(WebViewTest, ShowUnhandledTapUIIfNeededWithMutateDom) {
   std::string test_file = "show_unhandled_tap.html";
   RegisterMockedHttpURLLoad("Ahem.ttf");
   RegisterMockedHttpURLLoad(test_file);
   UnhandledTapWebViewClient client;
   WebViewBase* web_view = web_view_helper_.InitializeAndLoad(
       base_url_ + test_file, true, 0, &client);
   web_view->Resize(WebSize(500, 300));
   web_view->UpdateAllLifecyclePhases();
   RunPendingTasks();
-  WebLocalFrameImpl* frame = web_view->MainFrameImpl();
+  WebLocalFrameBase* frame = web_view->MainFrameImpl();
 
   // Test dom mutation.
   TEST_EACH_MOUSEEVENT("mutateDom", TRUE);
 
   // Test without any DOM mutation.
   client.Reset();
   frame->ExecuteScript(WebScriptSource("setTest('none');"));
   EXPECT_TRUE(TapElementById(WebInputEvent::kGestureTap,
                              WebString::FromUTF8("target")));
   EXPECT_FALSE(client.GetPageChanged());
 
   web_view_helper_.Reset();  // Remove dependency on locally scoped client.
 }
 
 TEST_P(WebViewTest, ShowUnhandledTapUIIfNeededWithMutateStyle) {
   std::string test_file = "show_unhandled_tap.html";
   RegisterMockedHttpURLLoad("Ahem.ttf");
   RegisterMockedHttpURLLoad(test_file);
   UnhandledTapWebViewClient client;
   WebViewBase* web_view = web_view_helper_.InitializeAndLoad(
       base_url_ + test_file, true, 0, &client);
   web_view->Resize(WebSize(500, 300));
   web_view->UpdateAllLifecyclePhases();
   RunPendingTasks();
-  WebLocalFrameImpl* frame = web_view->MainFrameImpl();
+  WebLocalFrameBase* frame = web_view->MainFrameImpl();
 
   // Test style mutation.
   TEST_EACH_MOUSEEVENT("mutateStyle", TRUE);
 
   // Test checkbox:indeterminate style mutation.
   TEST_EACH_MOUSEEVENT("mutateIndeterminate", TRUE);
 
   // Test click div with :active style but it is not covered for now.
   client.Reset();
   EXPECT_TRUE(TapElementById(WebInputEvent::kGestureTap,
@@ skipping 13 matching lines @@
 TEST_P(WebViewTest, ShowUnhandledTapUIIfNeededWithPreventDefault) {
   std::string test_file = "show_unhandled_tap.html";
   RegisterMockedHttpURLLoad("Ahem.ttf");
   RegisterMockedHttpURLLoad(test_file);
   UnhandledTapWebViewClient client;
   WebViewBase* web_view = web_view_helper_.InitializeAndLoad(
       base_url_ + test_file, true, 0, &client);
   web_view->Resize(WebSize(500, 300));
   web_view->UpdateAllLifecyclePhases();
   RunPendingTasks();
-  WebLocalFrameImpl* frame = web_view->MainFrameImpl();
+  WebLocalFrameBase* frame = web_view->MainFrameImpl();
 
   // Testswallowing.
   TEST_EACH_MOUSEEVENT("preventDefault", FALSE);
 
   // Test without any preventDefault.
   client.Reset();
   frame->ExecuteScript(WebScriptSource("setTest('none');"));
   EXPECT_TRUE(TapElementById(WebInputEvent::kGestureTap,
                              WebString::FromUTF8("target")));
   EXPECT_TRUE(client.GetWasCalled());
@@ skipping 18 matching lines @@
   EXPECT_FALSE(document->GetFrame()->IsLoading());
 }
 
 #if OS(MACOSX)
 TEST_P(WebViewTest, WebSubstringUtil) {
   RegisterMockedHttpURLLoad("content_editable_populated.html");
   WebViewBase* web_view = web_view_helper_.InitializeAndLoad(
       base_url_ + "content_editable_populated.html");
   web_view->GetSettings()->SetDefaultFontSize(12);
   web_view->Resize(WebSize(400, 400));
-  WebLocalFrameImpl* frame = web_view->MainFrameImpl();
+  WebLocalFrameBase* frame = web_view->MainFrameImpl();
 
   WebPoint baseline_point;
   NSAttributedString* result = WebSubstringUtil::AttributedSubstringInRange(
       frame, 10, 3, &baseline_point);
   ASSERT_TRUE(!!result);
 
   WebPoint point(baseline_point.x, baseline_point.y);
   result = WebSubstringUtil::AttributedWordAtPoint(frame->FrameWidget(), point,
                                                    baseline_point);
   ASSERT_TRUE(!!result);
 
   web_view->SetZoomLevel(3);
 
   result = WebSubstringUtil::AttributedSubstringInRange(frame, 5, 5,
                                                         &baseline_point);
   ASSERT_TRUE(!!result);
 
   point = WebPoint(baseline_point.x, baseline_point.y);
   result = WebSubstringUtil::AttributedWordAtPoint(frame->FrameWidget(), point,
                                                    baseline_point);
   ASSERT_TRUE(!!result);
 }
 
 TEST_P(WebViewTest, WebSubstringUtilPinchZoom) {
   RegisterMockedHttpURLLoad("content_editable_populated.html");
   WebViewBase* web_view = web_view_helper_.InitializeAndLoad(
       base_url_ + "content_editable_populated.html");
   web_view->GetSettings()->SetDefaultFontSize(12);
   web_view->Resize(WebSize(400, 400));
-  WebLocalFrameImpl* frame = web_view->MainFrameImpl();
+  WebLocalFrameBase* frame = web_view->MainFrameImpl();
   NSAttributedString* result = nil;
 
   WebPoint baseline_point;
   result = WebSubstringUtil::AttributedSubstringInRange(frame, 10, 3,
                                                         &baseline_point);
   ASSERT_TRUE(!!result);
 
   web_view->SetPageScaleFactor(3);
 
   WebPoint point_after_zoom;
   result = WebSubstringUtil::AttributedSubstringInRange(frame, 10, 3,
                                                         &point_after_zoom);
   ASSERT_TRUE(!!result);
 
   // We won't have moved by a full factor of 3 because of the translations, but
   // we should move by a factor of >2.
   EXPECT_LT(2 * baseline_point.x, point_after_zoom.x);
   EXPECT_LT(2 * baseline_point.y, point_after_zoom.y);
 }
 
 TEST_P(WebViewTest, WebSubstringUtilIframe) {
   RegisterMockedHttpURLLoad("single_iframe.html");
   RegisterMockedHttpURLLoad("visible_iframe.html");
   WebViewBase* web_view =
       web_view_helper_.InitializeAndLoad(base_url_ + "single_iframe.html");
   web_view->GetSettings()->SetDefaultFontSize(12);
   web_view->GetSettings()->SetJavaScriptEnabled(true);
   web_view->Resize(WebSize(400, 400));
-  WebLocalFrameImpl* main_frame = web_view->MainFrameImpl();
-  WebLocalFrameImpl* child_frame = WebLocalFrameImpl::FromFrame(
+  WebLocalFrameBase* main_frame = web_view->MainFrameImpl();
+  WebLocalFrameBase* child_frame = WebLocalFrameBase::FromFrame(
       ToLocalFrame(main_frame->GetFrame()->Tree().FirstChild()));
 
   WebPoint baseline_point;
   NSAttributedString* result = WebSubstringUtil::AttributedSubstringInRange(
       child_frame, 11, 7, &baseline_point);
   ASSERT_NE(result, nullptr);
 
   WebPoint point(baseline_point.x, baseline_point.y);
   result = WebSubstringUtil::AttributedWordAtPoint(main_frame->FrameWidget(),
                                                    point, baseline_point);
@@ skipping 13 matching lines @@
   EXPECT_EQ(y_before_change, baseline_point.y - 100);
 }
 
 #endif
 
 TEST_P(WebViewTest, PasswordFieldEditingIsUserGesture) {
   RegisterMockedHttpURLLoad("input_field_password.html");
   MockAutofillClient client;
   WebViewBase* web_view = web_view_helper_.InitializeAndLoad(
       base_url_ + "input_field_password.html", true);
-  WebLocalFrameImpl* frame = web_view->MainFrameImpl();
+  WebLocalFrameBase* frame = web_view->MainFrameImpl();
   frame->SetAutofillClient(&client);
   web_view->SetInitialFocus(false);
 
   WebVector<WebCompositionUnderline> empty_underlines;
 
   EXPECT_TRUE(
       frame->FrameWidget()->GetActiveWebInputMethodController()->CommitText(
           WebString::FromUTF8(std::string("hello").c_str()), empty_underlines,
           WebRange(), 0));
   EXPECT_EQ(1, client.TextChangesFromUserGesture());
@@ skipping 247 matching lines @@
 
   WebURL base_url = URLTestHelpers::ToKURL("http://example.com/");
   FrameTestHelpers::LoadHTMLString(web_view->MainFrame(),
                                    "<style>"
                                    "  body { margin: 0px; }"
                                    "  #vw { width: 100vw; height: 100vh; }"
                                    "</style>"
                                    "<div id=vw></div>",
                                    base_url);
 
-  WebLocalFrameImpl* frame = web_view->MainFrameImpl();
+  WebLocalFrameBase* frame = web_view->MainFrameImpl();
   Document* document = frame->GetFrame()->GetDocument();
   Element* vw_element = document->getElementById("vw");
 
   EXPECT_EQ(800, vw_element->OffsetWidth());
 
   FloatSize page_size(300, 360);
 
   WebPrintParams print_params;
   print_params.print_content_area.width = page_size.Width();
   print_params.print_content_area.height = page_size.Height();
@@ skipping 24 matching lines @@
   WebURL base_url = URLTestHelpers::ToKURL("http://example.com/");
   FrameTestHelpers::LoadHTMLString(web_view->MainFrame(),
                                    "<style>"
                                    "  @media (max-width: 600px) {"
                                    "    div { color: green }"
                                    "  }"
                                    "</style>"
                                    "<div id=d></div>",
                                    base_url);
 
-  WebLocalFrameImpl* frame = web_view->MainFrameImpl();
+  WebLocalFrameBase* frame = web_view->MainFrameImpl();
   Document* document = frame->GetFrame()->GetDocument();
   Element* div = document->getElementById("d");
 
   EXPECT_EQ(MakeRGB(0, 128, 0),
             div->GetComputedStyle()->VisitedDependentColor(CSSPropertyColor));
 
   FloatSize page_size(300, 360);
 
   WebPrintParams print_params;
   print_params.print_content_area.width = page_size.Width();
@@ skipping 15 matching lines @@
   FrameTestHelpers::LoadHTMLString(web_view->MainFrame(),
                                    "<style>"
                                    "  body { margin: 0 }"
                                    "  #t1 { width: 100% }"
                                    "  #t2 { width: 100vw }"
                                    "</style>"
                                    "<div id=t1></div>"
                                    "<div id=t2></div>",
                                    base_url);
 
-  WebLocalFrameImpl* frame = web_view->MainFrameImpl();
+  WebLocalFrameBase* frame = web_view->MainFrameImpl();
   Document* document = frame->GetFrame()->GetDocument();
   Element* t1 = document->getElementById("t1");
   Element* t2 = document->getElementById("t2");
 
   EXPECT_EQ(400, t1->OffsetWidth());
   EXPECT_EQ(400, t2->OffsetWidth());
 
   FloatSize page_size(600, 720);
   int expected_width = PrintICBSizeFromPageSize(page_size).Width();
 
@@ skipping 16 matching lines @@
   WebURL base_url = URLTestHelpers::ToKURL("http://example.com/");
   FrameTestHelpers::LoadHTMLString(web_view->MainFrame(),
                                    "<!doctype html>"
                                    "<meta name='viewport'"
                                    "    content='width=device-width'>"
                                    "<style>"
                                    "  body {margin: 0px; height:3000px;}"
                                    "</style>",
                                    base_url);
 
-  WebLocalFrameImpl* frame = web_view->MainFrameImpl();
+  WebLocalFrameBase* frame = web_view->MainFrameImpl();
   auto* frame_view = frame->GetFrameView();
   EXPECT_FALSE(frame_view->VisualViewportSuppliesScrollbars());
   if (RuntimeEnabledFeatures::rootLayerScrollingEnabled()) {
     EXPECT_NE(nullptr,
               frame_view->LayoutViewportScrollableArea()->VerticalScrollbar());
   } else {
     EXPECT_NE(nullptr, frame_view->VerticalScrollbar());
   }
 
   WebDeviceEmulationParams params;
@@ skipping 15 matching lines @@
   EXPECT_FALSE(frame_view->VisualViewportSuppliesScrollbars());
   if (RuntimeEnabledFeatures::rootLayerScrollingEnabled()) {
     EXPECT_NE(nullptr,
               frame_view->LayoutViewportScrollableArea()->VerticalScrollbar());
   } else {
     EXPECT_NE(nullptr, frame_view->VerticalScrollbar());
   }
 }
 
 }  // namespace blink