Rename FrameView fields and methods *Widget* to ...FrameViewBase...

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 136 matching lines @@
   } while (false)
 
 namespace blink {
 
 // A4 Portrait dimensions in pixels
 const int kA4PortraitPageWidth = 595;
 const int kA4PortraitPageHeight = 842;
 
 using namespace HTMLNames;
 
-// The maximum number of updateWidgets iterations that should be done before
-// returning.
-static const unsigned maxUpdateWidgetsIterations = 2;
+// The maximum number of updateFrameViewBases iterations that should be done
+// before returning.
+static const unsigned maxUpdateFrameViewBasesIterations = 2;
 static const double resourcePriorityUpdateDelayAfterScroll = 0.250;
 
 static bool s_initialTrackAllPaintInvalidations = false;
 
 FrameView::FrameView(LocalFrame& frame)
     : m_frame(frame),
       m_displayMode(WebDisplayModeBrowser),
       m_canHaveScrollbars(true),
       m_hasPendingLayout(false),
       m_inSynchronousPostLayout(false),
       m_postLayoutTasksTimer(
           TaskRunnerHelper::get(TaskType::UnspecedTimer, &frame),
           this,
           &FrameView::postLayoutTimerFired),
-      m_updateWidgetsTimer(
+      m_updateFrameViewBasesTimer(
           TaskRunnerHelper::get(TaskType::UnspecedTimer, &frame),
           this,
-          &FrameView::updateWidgetsTimerFired),
+          &FrameView::updateFrameViewBasesTimerFired),
       m_isTransparent(false),
       m_baseBackgroundColor(Color::white),
       m_mediaType(MediaTypeNames::screen),
       m_safeToPropagateScrollToParent(true),
       m_scrollCorner(nullptr),
       m_stickyPositionObjectCount(0),
       m_inputEventsScaleFactorForEmulation(1),
       m_layoutSizeFixedToFrameSize(true),
       m_didScrollTimer(TaskRunnerHelper::get(TaskType::UnspecedTimer, &frame),
                        this,
                        &FrameView::didScrollTimerFired),
-      m_needsUpdateWidgetGeometries(false),
+      m_needsUpdateGeometries(false),
       m_horizontalScrollbarMode(ScrollbarAuto),
       m_verticalScrollbarMode(ScrollbarAuto),
       m_horizontalScrollbarLock(false),
       m_verticalScrollbarLock(false),
       m_scrollbarsSuppressed(false),
       m_inUpdateScrollbars(false),
       m_frameTimingRequestsDirty(true),
       m_hiddenForThrottling(false),
       m_subtreeThrottled(false),
       m_lifecycleUpdatesThrottled(false),
@@ skipping 54 matching lines @@
   // properly.
   if (RuntimeEnabledFeatures::
           renderingPipelineThrottlingLoadingIframesEnabled())
     m_lifecycleUpdatesThrottled = !frame().isMainFrame();
   m_hasPendingLayout = false;
   m_layoutSchedulingEnabled = true;
   m_inSynchronousPostLayout = false;
   m_layoutCount = 0;
   m_nestedLayoutCount = 0;
   m_postLayoutTasksTimer.stop();
-  m_updateWidgetsTimer.stop();
+  m_updateFrameViewBasesTimer.stop();
   m_firstLayout = true;
   m_safeToPropagateScrollToParent = true;
   m_lastViewportSize = IntSize();
   m_lastZoomFactor = 1.0f;
   m_trackedObjectPaintInvalidations = WTF::wrapUnique(
       s_initialTrackAllPaintInvalidations ? new Vector<ObjectPaintInvalidation>
                                           : nullptr);
   m_visuallyNonEmptyCharacterCount = 0;
   m_visuallyNonEmptyPixelCount = 0;
   m_isVisuallyNonEmpty = false;
@@ skipping 208 matching lines @@
     updateScrollbarGeometry();
     updateScrollCorner();
     positionScrollbarLayers();
   }
 }
 
 void FrameView::invalidateAllCustomScrollbarsOnActiveChanged() {
   bool usesWindowInactiveSelector =
       m_frame->document()->styleEngine().usesWindowInactiveSelector();
 
-  const ChildrenWidgetSet* viewChildren = children();
+  const ChildrenFrameViewBaseSet* viewChildren = children();
   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();
     }
   }
@@ skipping 952 matching lines @@
 }
 
 void FrameView::addPart(LayoutPart* object) {
   m_parts.insert(object);
 }
 
 void FrameView::removePart(LayoutPart* object) {
   m_parts.erase(object);
 }
 
-void FrameView::updateWidgetGeometries() {
+void FrameView::updateGeometries() {
   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 (FrameViewBase* frameViewBase = part->widget()) {
@@ skipping 518 matching lines @@
       DisableCompositingQueryAsserts disabler;
       layer->updateLayerPositionsAfterOverflowScroll();
       layoutObject->setMayNeedPaintInvalidationSubtree();
     }
   }
 
   // If there fixed position elements, scrolling may cause compositing layers to
   // change.  Update FrameViewBase and layer positions after scrolling, but only
   // if we're not inside of layout.
   if (!m_nestedLayoutCount) {
-    updateWidgetGeometries();
+    updateGeometries();
     LayoutViewItem layoutViewItem = this->layoutViewItem();
     if (!layoutViewItem.isNull())
       layoutViewItem.layer()->setNeedsCompositingInputsUpdate();
   }
 }
 
 bool FrameView::computeCompositedSelection(LocalFrame& frame,
                                            CompositedSelection& selection) {
   if (!frame.view() || frame.view()->shouldThrottleRendering())
     return false;
@@ skipping 386 matching lines @@
       cache->handleScrolledToAnchor(anchorNode);
   }
 
   // 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 FrameViewBases to
-  // update. Thus I believe we can stop checking isEmpty here, and just ASSERT
-  // isEmpty:
+bool FrameView::updateFrameViewBases() {
+  // This is always called from updateFrameViewBasesTimerFired.
+  // m_updateFrameViewBasesTimer 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 15 matching lines @@
     object.updateWidgetGeometry();
 
     // Prevent plugins from causing infinite updates of themselves.
     // FIXME: Do we really need to prevent this?
     m_partUpdateSet.erase(&object);
   }
 
   return m_partUpdateSet.isEmpty();
 }
 
-void FrameView::updateWidgetsTimerFired(TimerBase*) {
+void FrameView::updateFrameViewBasesTimerFired(TimerBase*) {
   ASSERT(!isInPerformLayout());
-  for (unsigned i = 0; i < maxUpdateWidgetsIterations; ++i) {
-    if (updateWidgets())
+  for (unsigned i = 0; i < maxUpdateFrameViewBasesIterations; ++i) {
+    if (updateFrameViewBases())
       return;
   }
 }
 
 void FrameView::flushAnyPendingPostLayoutTasks() {
   ASSERT(!isInPerformLayout());
   if (m_postLayoutTasksTimer.isActive())
     performPostLayoutTasks();
-  if (m_updateWidgetsTimer.isActive()) {
-    m_updateWidgetsTimer.stop();
-    updateWidgetsTimerFired(nullptr);
+  if (m_updateFrameViewBasesTimer.isActive()) {
+    m_updateFrameViewBasesTimer.stop();
+    updateFrameViewBasesTimerFired(nullptr);
   }
 }
 
-void FrameView::scheduleUpdateWidgetsIfNecessary() {
+void FrameView::scheduleUpdateFrameViewBasesIfNecessary() {
   ASSERT(!isInPerformLayout());
-  if (m_updateWidgetsTimer.isActive() || m_partUpdateSet.isEmpty())
+  if (m_updateFrameViewBasesTimer.isActive() || m_partUpdateSet.isEmpty())
     return;
-  m_updateWidgetsTimer.startOneShot(0, BLINK_FROM_HERE);
+  m_updateFrameViewBasesTimer.startOneShot(0, BLINK_FROM_HERE);
 }
 
 void FrameView::performPostLayoutTasks() {
   // FIXME: We can reach here, even when the page is not active!
   // http/tests/inspector/elements/html-link-import.html and many other
   // tests hit that case.
   // We should ASSERT(isActive()); or at least return early if we can!
 
   // Always called before or after performLayout(), part of the highest-level
   // layout() call.
   ASSERT(!isInPerformLayout());
   TRACE_EVENT0("blink,benchmark", "FrameView::performPostLayoutTasks");
 
   m_postLayoutTasksTimer.stop();
 
   m_frame->selection().didLayout();
 
   ASSERT(m_frame->document());
 
   FontFaceSet::didLayout(*m_frame->document());
   // Cursor update scheduling is done by the local root, which is the main frame
   // if there are no RemoteFrame ancestors in the frame tree. Use of
   // localFrameRoot() is discouraged but will change when cursor update
   // scheduling is moved from EventHandler to PageEventHandler.
   frame().localFrameRoot()->eventHandler().scheduleCursorUpdate();
 
-  updateWidgetGeometries();
+  updateGeometries();
 
-  // Plugins could have torn down the page inside updateWidgetGeometries().
+  // Plugins could have torn down the page inside
+  // updateGeometries().
   if (layoutViewItem().isNull())
     return;
 
-  scheduleUpdateWidgetsIfNecessary();
+  scheduleUpdateFrameViewBasesIfNecessary();
 
   if (ScrollingCoordinator* scrollingCoordinator = this->scrollingCoordinator())
     scrollingCoordinator->notifyGeometryChanged();
 
   scrollToFragmentAnchor();
   sendResizeEventIfNeeded();
 }
 
 bool FrameView::wasViewportResized() {
   ASSERT(m_frame);
@@ skipping 331 matching lines @@
 
   if (hasHorizontalScrollbar != shouldHaveHorizontalScrollbar ||
       hasVerticalScrollbar != shouldHaveVerticalScrollbar) {
     scrollbarExistenceDidChange();
 
     if (!visualViewportSuppliesScrollbars())
       updateScrollbarGeometry();
   }
 }
 
-void FrameView::updateWidgetGeometriesIfNeeded() {
-  if (!m_needsUpdateWidgetGeometries)
+void FrameView::updateGeometriesIfNeeded() {
+  if (!m_needsUpdateGeometries)
     return;
 
-  m_needsUpdateWidgetGeometries = false;
+  m_needsUpdateGeometries = false;
 
-  updateWidgetGeometries();
+  updateGeometries();
 }
 
 GeometryMapper& FrameView::geometryMapper() {
   DCHECK(RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled());
   DCHECK(lifecycle().state() >= DocumentLifecycle::InPrePaint);
 
   if (m_frame->isLocalRoot()) {
     if (!m_geometryMapper)
       m_geometryMapper = GeometryMapper::create();
     return *m_geometryMapper.get();
@@ skipping 424 matching lines @@
   if (needsLayout())
     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();
+  const ChildrenFrameViewBaseSet* viewChildren = children();
   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()) {
     if (!child->isLocalFrame())
       continue;
     if (FrameView* view = toLocalFrame(child)->view())
       frameViews.push_back(view);
   }
 
   for (const auto& frameView : frameViews)
     frameView->updateStyleAndLayoutIfNeededRecursiveInternal();
 
   // These asserts ensure that parent frames are clean, when child frames
   // finished updating layout and style.
   checkDoesNotNeedLayout();
 #if DCHECK_IS_ON()
   m_frame->document()->layoutView()->assertLaidOut();
 #endif
 
-  updateWidgetGeometriesIfNeeded();
+  updateGeometriesIfNeeded();
 
   if (lifecycle().state() < DocumentLifecycle::LayoutClean)
     lifecycle().advanceTo(DocumentLifecycle::LayoutClean);
 
   // Ensure that we become visually non-empty eventually.
   // TODO(esprehn): This should check isRenderingReady() instead.
   if (frame().document()->hasFinishedParsing() &&
       frame().loader().stateMachine()->committedFirstRealDocumentLoad())
     m_isVisuallyNonEmpty = true;
 
@@ skipping 1901 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