Rename updateWidgets to updatePlugins

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
+// The maximum number of updatePlugins iterations that should be done before
 // returning.
-static const unsigned maxUpdateWidgetsIterations = 2;
+static const unsigned maxUpdatePluginsIterations = 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_updatePluginsTimer(
           TaskRunnerHelper::get(TaskType::UnspecedTimer, &frame),
           this,
-          &FrameView::updateWidgetsTimerFired),
+          &FrameView::updatePluginsTimerFired),
       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,
@@ skipping 66 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_updatePluginsTimer.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 1214 matching lines @@
     }
   }
 }
 
 void FrameView::addPartToUpdate(LayoutEmbeddedObject& object) {
   ASSERT(isInPerformLayout());
   // 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);
+    toHTMLPlugInElement(node)->setNeedsPluginUpdate(true);
 
   m_partUpdateSet.insert(&object);
 }
 
 void FrameView::setDisplayMode(WebDisplayMode mode) {
   if (mode == m_displayMode)
     return;
 
   m_displayMode = mode;
 
@@ skipping 895 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
+bool FrameView::updatePlugins() {
+  // This is always called from updatePluginsTimerFired.
+  // m_updatePluginsTimer 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);
 
   for (const auto& embeddedObject : objects) {
     LayoutEmbeddedObject& object = *embeddedObject;
     HTMLPlugInElement* element = toHTMLPlugInElement(object.node());
 
     // The object may have already been destroyed (thus node cleared),
     // but FrameView holds a manual ref, so it won't have been deleted.
     if (!element)
       continue;
 
     // No need to update if it's already crashed or known to be missing.
     if (object.showsUnavailablePluginIndicator())
       continue;
 
-    if (element->needsWidgetUpdate())
-      element->updateWidget();
+    if (element->needsPluginUpdate())
+      element->updatePlugin();
     object.updateGeometry();
 
     // 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::updatePluginsTimerFired(TimerBase*) {
   ASSERT(!isInPerformLayout());
-  for (unsigned i = 0; i < maxUpdateWidgetsIterations; ++i) {
-    if (updateWidgets())
+  for (unsigned i = 0; i < maxUpdatePluginsIterations; ++i) {
+    if (updatePlugins())
       return;
   }
 }
 
 void FrameView::flushAnyPendingPostLayoutTasks() {
   ASSERT(!isInPerformLayout());
   if (m_postLayoutTasksTimer.isActive())
     performPostLayoutTasks();
-  if (m_updateWidgetsTimer.isActive()) {
-    m_updateWidgetsTimer.stop();
-    updateWidgetsTimerFired(nullptr);
+  if (m_updatePluginsTimer.isActive()) {
+    m_updatePluginsTimer.stop();
+    updatePluginsTimerFired(nullptr);
   }
 }
 
-void FrameView::scheduleUpdateWidgetsIfNecessary() {
+void FrameView::scheduleUpdatePluginsIfNecessary() {
   ASSERT(!isInPerformLayout());
-  if (m_updateWidgetsTimer.isActive() || m_partUpdateSet.isEmpty())
+  if (m_updatePluginsTimer.isActive() || m_partUpdateSet.isEmpty())
     return;
-  m_updateWidgetsTimer.startOneShot(0, BLINK_FROM_HERE);
+  m_updatePluginsTimer.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.
@@ skipping 12 matching lines @@
   // localFrameRoot() is discouraged but will change when cursor update
   // scheduling is moved from EventHandler to PageEventHandler.
   frame().localFrameRoot()->eventHandler().scheduleCursorUpdate();
 
   updateGeometries();
 
   // Plugins could have torn down the page inside updateGeometries().
   if (layoutViewItem().isNull())
     return;
 
-  scheduleUpdateWidgetsIfNecessary();
+  scheduleUpdatePluginsIfNecessary();
 
   if (ScrollingCoordinator* scrollingCoordinator = this->scrollingCoordinator())
     scrollingCoordinator->notifyGeometryChanged();
 
   scrollToFragmentAnchor();
   sendResizeEventIfNeeded();
 }
 
 bool FrameView::wasViewportResized() {
   ASSERT(m_frame);
@@ skipping 2732 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