Rename platform/Widget to platform/FrameViewBase in core.

third_party/WebKit/Source/core/frame/FrameView.cpp

 /*
  * Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
  *                     1999 Lars Knoll <knoll@kde.org>
  *                     1999 Antti Koivisto <koivisto@kde.org>
  *                     2000 Dirk Mueller <mueller@kde.org>
  * Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
  *           (C) 2006 Graham Dennis (graham.dennis@gmail.com)
  *           (C) 2006 Alexey Proskuryakov (ap@nypop.com)
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
@@ skipping 202 matching lines @@
 }
 
 FrameView* FrameView::create(LocalFrame& frame) {
   FrameView* view = new FrameView(frame);
   view->show();
   return view;
 }
 
 FrameView* FrameView::create(LocalFrame& frame, const IntSize& initialSize) {
   FrameView* view = new FrameView(frame);
-  view->Widget::setFrameRect(IntRect(view->location(), initialSize));
+  view->FrameViewBase::setFrameRect(IntRect(view->location(), initialSize));
   view->setLayoutSizeInternal(initialSize);
 
   view->show();
   return view;
 }
 
 FrameView::~FrameView() {
   ASSERT(m_hasBeenDisposed);
 }
 
 DEFINE_TRACE(FrameView) {
   visitor->trace(m_frame);
   visitor->trace(m_fragmentAnchor);
   visitor->trace(m_scrollableAreas);
   visitor->trace(m_animatingScrollableAreas);
   visitor->trace(m_autoSizeInfo);
   visitor->trace(m_children);
   visitor->trace(m_viewportScrollableArea);
   visitor->trace(m_visibilityObserver);
   visitor->trace(m_scrollAnchor);
   visitor->trace(m_anchoringAdjustmentQueue);
   visitor->trace(m_scrollbarManager);
   visitor->trace(m_printContext);
-  Widget::trace(visitor);
+  FrameViewBase::trace(visitor);
   ScrollableArea::trace(visitor);
 }
 
 void FrameView::reset() {
   // The compositor throttles the main frame using deferred commits, we can't
   // throttle it here or it seems the root compositor doesn't get setup
   // properly.
   if (RuntimeEnabledFeatures::
           renderingPipelineThrottlingLoadingIframesEnabled())
     m_lifecycleUpdatesThrottled = !frame().isMainFrame();
@@ skipping 106 matching lines @@
   // Destroy |m_autoSizeInfo| as early as possible, to avoid dereferencing
   // partially destroyed |this| via |m_autoSizeInfo->m_frameView|.
   m_autoSizeInfo.clear();
 
   m_postLayoutTasksTimer.stop();
   m_didScrollTimer.stop();
 
   // FIXME: Do we need to do something here for OOPI?
   HTMLFrameOwnerElement* ownerElement = m_frame->deprecatedLocalOwner();
   // TODO(dcheng): It seems buggy that we can have an owner element that points
-  // to another Widget. This can happen when a plugin element loads a frame
-  // (widget A of type FrameView) and then loads a plugin (widget B of type
-  // WebPluginContainerImpl). In this case, the frame's view is A and the frame
-  // element's owned widget is B. See https://crbug.com/673170 for an example.
+  // to another FrameViewBase. This can happen when a plugin element loads a
+  // frame (FrameViewBase A of type FrameView) and then loads a plugin
+  // (FrameViewBase B of type WebPluginContainerImpl). In this case, the frame's
+  // view is A and the frame element's owned FrameViewBase is B. See
+  // https://crbug.com/673170 for an example.
   if (ownerElement && ownerElement->ownedWidget() == this)
     ownerElement->setWidget(nullptr);
 
 #if DCHECK_IS_ON()
   m_hasBeenDisposed = true;
 #endif
 }
 
 void FrameView::detachScrollbars() {
   // Previously, we detached custom scrollbars as early as possible to prevent
@@ skipping 95 matching lines @@
     updateScrollCorner();
     positionScrollbarLayers();
   }
 }
 
 void FrameView::invalidateAllCustomScrollbarsOnActiveChanged() {
   bool usesWindowInactiveSelector =
       m_frame->document()->styleEngine().usesWindowInactiveSelector();
 
   const ChildrenWidgetSet* viewChildren = children();
-  for (const Member<Widget>& child : *viewChildren) {
-    Widget* widget = child.get();
-    if (widget->isFrameView())
-      toFrameView(widget)->invalidateAllCustomScrollbarsOnActiveChanged();
-    else if (usesWindowInactiveSelector && widget->isScrollbar() &&
-             toScrollbar(widget)->isCustomScrollbar())
-      toScrollbar(widget)->styleChanged();
+  for (const Member<FrameViewBase>& child : *viewChildren) {
+    FrameViewBase* frameViewBase = child.get();
+    if (frameViewBase->isFrameView()) {
+      toFrameView(frameViewBase)
+          ->invalidateAllCustomScrollbarsOnActiveChanged();
+    } else if (usesWindowInactiveSelector && frameViewBase->isScrollbar() &&
+               toScrollbar(frameViewBase)->isCustomScrollbar()) {
+      toScrollbar(frameViewBase)->styleChanged();
+    }
   }
   if (usesWindowInactiveSelector)
     recalculateCustomScrollbarStyle();
 }
 
 void FrameView::clear() {
   reset();
   setScrollbarsSuppressed(true);
 }
 
@@ skipping 14 matching lines @@
   // state. crbug.com/457415
   DisablePaintInvalidationStateAsserts paintInvalidationAssertDisabler;
   layoutItem.invalidatePaintRectangle(LayoutRect(paintInvalidationRect));
 }
 
 void FrameView::setFrameRect(const IntRect& newRect) {
   IntRect oldRect = frameRect();
   if (newRect == oldRect)
     return;
 
-  Widget::setFrameRect(newRect);
+  FrameViewBase::setFrameRect(newRect);
 
   const bool frameSizeChanged = oldRect.size() != newRect.size();
 
   m_needsScrollbarsUpdate = frameSizeChanged;
   // TODO(wjmaclean): find out why scrollbars fail to resize for complex
   // subframes after changing the zoom level. For now always calling
   // updateScrollbarsIfNeeded() here fixes the issue, but it would be good to
   // discover the deeper cause of this. http://crbug.com/607987.
   updateScrollbarsIfNeeded();
 
@@ skipping 588 matching lines @@
   if (!m_inSynchronousPostLayout) {
     m_inSynchronousPostLayout = true;
     // Calls resumeScheduledEvents()
     performPostLayoutTasks();
     m_inSynchronousPostLayout = false;
   }
 
   if (!m_postLayoutTasksTimer.isActive() &&
       (needsLayout() || m_inSynchronousPostLayout)) {
     // If we need layout or are already in a synchronous call to
-    // postLayoutTasks(), defer widget updates and event dispatch until after we
-    // return.  postLayoutTasks() can make us need to update again, and we can
-    // get stuck in a nasty cycle unless we call it through the timer here.
+    // postLayoutTasks(), defer FrameViewBase updates and event dispatch until
+    // after we return.  postLayoutTasks() can make us need to update again, and
+    // we can get stuck in a nasty cycle unless we call it through the timer
+    // here.
     m_postLayoutTasksTimer.startOneShot(0, BLINK_FROM_HERE);
     if (needsLayout())
       layout();
   }
 }
 
 void FrameView::layout() {
   // We should never layout a Document which is not in a LocalFrame.
   ASSERT(m_frame);
   ASSERT(m_frame->view() == this);
@@ skipping 306 matching lines @@
 void FrameView::updateWidgetGeometries() {
   Vector<RefPtr<LayoutPart>> parts;
   copyToVector(m_parts, parts);
 
   for (auto part : parts) {
     // Script or plugins could detach the frame so abort processing if that
     // happens.
     if (layoutViewItem().isNull())
       break;
 
-    if (Widget* widget = part->widget()) {
-      if (widget->isFrameView()) {
-        FrameView* frameView = toFrameView(widget);
+    if (FrameViewBase* frameViewBase = part->widget()) {
+      if (frameViewBase->isFrameView()) {
+        FrameView* frameView = toFrameView(frameViewBase);
         bool didNeedLayout = frameView->needsLayout();
         part->updateWidgetGeometry();
         if (!didNeedLayout && !frameView->shouldThrottleRendering())
           frameView->checkDoesNotNeedLayout();
       } else {
         part->updateWidgetGeometry();
       }
     }
   }
 }
 
 void FrameView::addPartToUpdate(LayoutEmbeddedObject& object) {
   ASSERT(isInPerformLayout());
-  // Tell the DOM element that it needs a widget update.
+  // Tell the DOM element that it needs a FrameViewBase update.
   Node* node = object.node();
   ASSERT(node);
   if (isHTMLObjectElement(*node) || isHTMLEmbedElement(*node))
     toHTMLPlugInElement(node)->setNeedsWidgetUpdate(true);
 
   m_partUpdateSet.insert(&object);
 }
 
 void FrameView::setDisplayMode(WebDisplayMode mode) {
   if (mode == m_displayMode)
@@ skipping 489 matching lines @@
         !constraintsMap.at(layer).hasAncestorStickyElement()) {
       // TODO(skobes): Resolve circular dependency between scroll offset and
       // compositing state, and remove this disabler. https://crbug.com/420741
       DisableCompositingQueryAsserts disabler;
       layer->updateLayerPositionsAfterOverflowScroll();
       layoutObject->setMayNeedPaintInvalidationSubtree();
     }
   }
 
   // If there fixed position elements, scrolling may cause compositing layers to
-  // change.  Update widget and layer positions after scrolling, but only if
-  // we're not inside of layout.
+  // change.  Update FrameViewBase and layer positions after scrolling, but only
+  // if we're not inside of layout.
   if (!m_nestedLayoutCount) {
     updateWidgetGeometries();
     LayoutViewItem layoutViewItem = this->layoutViewItem();
     if (!layoutViewItem.isNull())
       layoutViewItem.layer()->setNeedsCompositingInputsUpdate();
   }
 }
 
 bool FrameView::computeCompositedSelection(LocalFrame& frame,
                                            CompositedSelection& selection) {
@@ skipping 390 matching lines @@
 
   // The fragment anchor should only be maintained while the frame is still
   // loading.  If the frame is done loading, clear the anchor now. Otherwise,
   // restore it since it may have been cleared during scrollRectToVisible.
   m_fragmentAnchor =
       m_frame->document()->isLoadCompleted() ? nullptr : anchorNode;
 }
 
 bool FrameView::updateWidgets() {
   // This is always called from updateWidgetsTimerFired.
-  // m_updateWidgetsTimer should only be scheduled if we have widgets to update.
-  // Thus I believe we can stop checking isEmpty here, and just ASSERT isEmpty:
+  // m_updateWidgetsTimer should only be scheduled if we have FrameViewBases to
+  // update. Thus I believe we can stop checking isEmpty here, and just ASSERT
+  // isEmpty:
   // FIXME: This assert has been temporarily removed due to
   // https://crbug.com/430344
   if (m_nestedLayoutCount > 1 || m_partUpdateSet.isEmpty())
     return true;
 
   // Need to swap because script will run inside the below loop and invalidate
   // the iterator.
   EmbeddedObjectSet objects;
   objects.swap(m_partUpdateSet);
 
@@ skipping 876 matching lines @@
     layout();
 
   checkDoesNotNeedLayout();
 
   // WebView plugins need to update regardless of whether the
   // LayoutEmbeddedObject that owns them needed layout.
   // TODO(leviw): This currently runs the entire lifecycle on plugin WebViews.
   // We should have a way to only run these other Documents to the same
   // lifecycle stage as this frame.
   const ChildrenWidgetSet* viewChildren = children();
-  for (const Member<Widget>& child : *viewChildren) {
+  for (const Member<FrameViewBase>& child : *viewChildren) {
     if ((*child).isPluginContainer())
       toPluginView(child.get())->updateAllLifecyclePhases();
   }
   checkDoesNotNeedLayout();
 
   // FIXME: Calling layout() shouldn't trigger script execution or have any
   // observable effects on the frame tree but we're not quite there yet.
   HeapVector<Member<FrameView>> frameViews;
   for (Frame* child = m_frame->tree().firstChild(); child;
        child = child->tree().nextSibling()) {
@@ skipping 417 matching lines @@
     m_animatingScrollableAreas = new ScrollableAreaSet;
   m_animatingScrollableAreas->insert(scrollableArea);
 }
 
 void FrameView::removeAnimatingScrollableArea(ScrollableArea* scrollableArea) {
   if (!m_animatingScrollableAreas)
     return;
   m_animatingScrollableAreas->erase(scrollableArea);
 }
 
-void FrameView::setParent(Widget* parentView) {
+void FrameView::setParent(FrameViewBase* parentView) {
   if (parentView == parent())
     return;
 
-  Widget::setParent(parentView);
+  FrameViewBase::setParent(parentView);
 
   updateParentScrollableAreaSet();
   setupRenderThrottling();
 
   if (parentFrameView())
     m_subtreeThrottled = parentFrameView()->canThrottleRendering();
 }
 
-void FrameView::removeChild(Widget* child) {
+void FrameView::removeChild(FrameViewBase* child) {
   ASSERT(child->parent() == this);
 
   if (child->isFrameView() &&
       !RuntimeEnabledFeatures::rootLayerScrollingEnabled())
     removeScrollableArea(toFrameView(child));
 
   child->setParent(0);
   m_children.erase(child);
 }
 
@@ skipping 75 matching lines @@
   TopDocumentRootScrollerController& controller =
       host->globalRootScrollerController();
   if (layoutViewport == controller.rootScrollerArea())
     visibleSize = controller.rootScrollerVisibleArea();
 
   IntSize maximumOffset =
       toIntSize(-scrollOrigin() + (contentBounds - visibleSize));
   return maximumOffset.expandedTo(minimumScrollOffsetInt());
 }
 
-void FrameView::addChild(Widget* child) {
+void FrameView::addChild(FrameViewBase* child) {
   ASSERT(child != this && !child->parent());
   child->setParent(this);
   m_children.insert(child);
 }
 
 void FrameView::setScrollbarModes(ScrollbarMode horizontalMode,
                                   ScrollbarMode verticalMode,
                                   bool horizontalLock,
                                   bool verticalLock) {
   bool needsUpdate = false;
@@ skipping 434 matching lines @@
 
   if (!scrollContentsFastPath(-scrollDelta))
     scrollContentsSlowPath();
 
   if (RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled() &&
       !RuntimeEnabledFeatures::rootLayerScrollingEnabled()) {
     // Need to update scroll translation property.
     setNeedsPaintPropertyUpdate();
   }
 
-  // This call will move children with native widgets (plugins) and invalidate
-  // them as well.
+  // This call will move children with native FrameViewBases (plugins) and
+  // invalidate them as well.
   frameRectsChanged();
 }
 
 IntPoint FrameView::contentsToFrame(const IntPoint& pointInContentSpace) const {
   return pointInContentSpace - scrollOffsetInt();
 }
 
 IntRect FrameView::contentsToFrame(const IntRect& rectInContentSpace) const {
   return IntRect(contentsToFrame(rectInContentSpace.location()),
                  rectInContentSpace.size());
@@ skipping 145 matching lines @@
                            ? m_horizontalScrollbarMode
                            : m_verticalScrollbarMode;
 
   return mode == ScrollbarAuto || mode == ScrollbarAlwaysOn;
 }
 
 bool FrameView::shouldPlaceVerticalScrollbarOnLeft() const {
   return false;
 }
 
-Widget* FrameView::getWidget() {
+FrameViewBase* FrameView::getWidget() {
   return this;
 }
 
 LayoutRect FrameView::scrollIntoView(const LayoutRect& rectInContent,
                                      const ScrollAlignment& alignX,
                                      const ScrollAlignment& alignY,
                                      ScrollType scrollType) {
   LayoutRect viewRect(visibleContentRect());
   LayoutRect exposeRect =
       ScrollAlignment::getRectToExpose(viewRect, rectInContent, alignX, alignY);
@@ skipping 147 matching lines @@
 }
 
 void FrameView::setParentVisible(bool visible) {
   if (isParentVisible() == visible)
     return;
 
   // As parent visibility changes, we may need to recomposite this frame view
   // and potentially child frame views.
   setNeedsCompositingUpdate(layoutViewItem(), CompositingUpdateRebuildTree);
 
-  Widget::setParentVisible(visible);
+  FrameViewBase::setParentVisible(visible);
 
   if (!isSelfVisible())
     return;
 
   for (const auto& child : m_children)
     child->setParentVisible(visible);
 }
 
 void FrameView::show() {
   if (!isSelfVisible()) {
     setSelfVisible(true);
     if (ScrollingCoordinator* scrollingCoordinator =
             this->scrollingCoordinator())
       scrollingCoordinator->frameViewVisibilityDidChange();
     setNeedsCompositingUpdate(layoutViewItem(), CompositingUpdateRebuildTree);
     updateParentScrollableAreaSet();
     if (RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled() &&
         !RuntimeEnabledFeatures::rootLayerScrollingEnabled()) {
       // The existance of scrolling properties depends on visibility through
       // isScrollable() so ensure properties are updated if visibility changes.
       setNeedsPaintPropertyUpdate();
     }
     if (isParentVisible()) {
       for (const auto& child : m_children)
         child->setParentVisible(true);
     }
   }
 
-  Widget::show();
+  FrameViewBase::show();
 }
 
 void FrameView::hide() {
   if (isSelfVisible()) {
     if (isParentVisible()) {
       for (const auto& child : m_children)
         child->setParentVisible(false);
     }
     setSelfVisible(false);
     if (ScrollingCoordinator* scrollingCoordinator =
             this->scrollingCoordinator())
       scrollingCoordinator->frameViewVisibilityDidChange();
     setNeedsCompositingUpdate(layoutViewItem(), CompositingUpdateRebuildTree);
     updateParentScrollableAreaSet();
     if (RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled() &&
         !RuntimeEnabledFeatures::rootLayerScrollingEnabled()) {
       // The existance of scrolling properties depends on visibility through
       // isScrollable() so ensure properties are updated if visibility changes.
       setNeedsPaintPropertyUpdate();
     }
   }
 
-  Widget::hide();
+  FrameViewBase::hide();
 }
 
 int FrameView::viewportWidth() const {
   int viewportWidth = layoutSize(IncludeScrollbars).width();
   return adjustForAbsoluteZoom(viewportWidth, layoutView());
 }
 
 ScrollableArea* FrameView::getScrollableArea() {
   if (m_viewportScrollableArea)
     return m_viewportScrollableArea.get();
@@ skipping 30 matching lines @@
     return;
 
   layoutObject.addAnnotatedRegions(regions);
   for (LayoutObject* curr = layoutObject.slowFirstChild(); curr;
        curr = curr->nextSibling())
     collectAnnotatedRegions(*curr, regions);
 }
 
 void FrameView::updateViewportIntersectionsForSubtree(
     DocumentLifecycle::LifecycleState targetState) {
-  // TODO(dcheng): Since widget tree updates are deferred, FrameViews might
-  // still be in the widget hierarchy even though the associated Document is
-  // already detached. Investigate if this check and a similar check in
-  // lifecycle updates are still needed when there are no more deferred widget
-  // updates: https://crbug.com/561683
+  // TODO(dcheng): Since FrameViewBase tree updates are deferred, FrameViews
+  // might still be in the FrameViewBase hierarchy even though the associated
+  // Document is already detached. Investigate if this check and a similar check
+  // in lifecycle updates are still needed when there are no more deferred
+  // FrameViewBase updates: https://crbug.com/561683
   if (!frame().document()->isActive())
     return;
 
   if (targetState == DocumentLifecycle::PaintClean) {
     recordDeferredLoadingStats();
     // Notify javascript IntersectionObservers
     if (frame().document()->intersectionObserverController()) {
       frame()
           .document()
           ->intersectionObserverController()
@@ skipping 54 matching lines @@
   bool becameUnthrottled = wasThrottled && !isThrottled;
 
   // If this FrameView became unthrottled or throttled, we must make sure all
   // its children are notified synchronously. Otherwise we 1) might attempt to
   // paint one of the children with an out-of-date layout before
   // |updateRenderThrottlingStatus| has made it throttled or 2) fail to
   // unthrottle a child whose parent is unthrottled by a later notification.
   if (notifyChildrenBehavior == NotifyChildren &&
       (wasThrottled != isThrottled ||
        forceThrottlingInvalidationBehavior == ForceThrottlingInvalidation)) {
-    for (const Member<Widget>& child : *children()) {
+    for (const Member<FrameViewBase>& child : *children()) {
       if (child->isFrameView()) {
         FrameView* childView = toFrameView(child);
         childView->updateRenderThrottlingStatus(
             childView->m_hiddenForThrottling, isThrottled);
       }
     }
   }
 
   ScrollingCoordinator* scrollingCoordinator = this->scrollingCoordinator();
   if (becameUnthrottled ||
@@ skipping 408 matching lines @@
 void FrameView::setAnimationHost(
     std::unique_ptr<CompositorAnimationHost> host) {
   m_animationHost = std::move(host);
 }
 
 LayoutUnit FrameView::caretWidth() const {
   return LayoutUnit(getHostWindow()->windowToViewportScalar(1));
 }
 
 }  // namespace blink