Rename (updateLayout/updateStyle).*.() to updateStyleAndLayout.*.()

third_party/WebKit/Source/core/dom/Document.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  *           (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) 2008, 2009, 2011, 2012 Google Inc. All rights reserved.
  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) Research In Motion Limited 2010-2011. All rights reserved.
@@ skipping 624 matching lines @@
     if (!isInMainFrame())
         return documentElement();
 
     FrameHost* host = frameHost();
     if (!host)
         return nullptr;
 
     RootScroller* rootScroller = host->rootScroller();
     DCHECK(rootScroller);
 
-    updateLayoutIgnorePendingStylesheets();
+    updateStyleAndLayoutIgnorePendingStylesheets();
 
     return rootScroller->get();
 }
 
 bool Document::isInMainFrame() const
 {
     return frame() && frame()->isMainFrame();
 }
 
 AtomicString Document::convertLocalName(const AtomicString& name)
@@ skipping 504 matching lines @@
         return nullptr;
 
     Position rangeCompliantPosition = positionWithAffinity.position().parentAnchoredEquivalent();
     return Range::createAdjustedToTreeScope(*this, rangeCompliantPosition);
 }
 
 Element* Document::scrollingElement()
 {
     if (RuntimeEnabledFeatures::scrollTopLeftInteropEnabled()) {
         if (inQuirksMode()) {
-            updateLayoutTree();
+            updateStyleAndLayoutTree();
             HTMLBodyElement* body = firstBodyElement();
             if (body && body->layoutObject() && body->layoutObject()->hasOverflowClip())
                 return nullptr;
 
             return body;
         }
 
         return documentElement();
     }
 
@@ skipping 506 matching lines @@
         DCHECK(!node.childNeedsStyleRecalc());
         DCHECK(!node.childNeedsDistributionRecalc());
         DCHECK(!node.needsStyleInvalidation());
         DCHECK(!node.childNeedsStyleInvalidation());
         for (ShadowRoot* shadowRoot = node.youngestShadowRoot(); shadowRoot; shadowRoot = shadowRoot->olderShadowRoot())
             assertLayoutTreeUpdated(*shadowRoot);
     }
 }
 #endif
 
-void Document::updateLayoutTree()
+void Document::updateStyleAndLayoutTree()
 {
     DCHECK(isMainThread());
 
     ScriptForbiddenScope forbidScript;
     // We should forbid script execution for plugins here because update while layout is changing,
     // HTMLPlugin element can be reattached and plugin can be destroyed. Plugin can execute scripts
     // on destroy. It produces crash without PluginScriptForbiddenScope: crbug.com/550427.
     PluginScriptForbiddenScope pluginForbidScript;
 
     if (!view() || !isActive())
@@ skipping 158 matching lines @@
 
     if (needsFullLayoutTreeUpdate() || node.needsStyleRecalc() || node.needsStyleInvalidation())
         return true;
     for (const ContainerNode* ancestor = LayoutTreeBuilderTraversal::parent(node); ancestor; ancestor = LayoutTreeBuilderTraversal::parent(*ancestor)) {
         if (ancestor->needsStyleRecalc() || ancestor->needsStyleInvalidation() || ancestor->needsAdjacentStyleRecalc())
             return true;
     }
     return false;
 }
 
-void Document::updateLayoutTreeForNode(const Node* node)
+void Document::updateStyleAndLayoutTreeForNode(const Node* node)
 {
     DCHECK(node);
     if (!needsLayoutTreeUpdateForNode(*node))
         return;
-    updateLayoutTree();
+    updateStyleAndLayoutTree();
 }
 
-void Document::updateLayoutIgnorePendingStylesheetsForNode(Node* node)
+void Document::updateStyleAndLayoutIgnorePendingStylesheetsForNode(Node* node)
 {
     DCHECK(node);
     if (!node->inActiveDocument())
         return;
-    updateLayoutIgnorePendingStylesheets();
+    updateStyleAndLayoutIgnorePendingStylesheets();
 }
 
-void Document::updateLayout()
+void Document::updateStyleAndLayout()
 {
     DCHECK(isMainThread());
 
     ScriptForbiddenScope forbidScript;
 
     FrameView* frameView = view();
     if (frameView && frameView->isInPerformLayout()) {
         // View layout should not be re-entrant.
         ASSERT_NOT_REACHED();
         return;
     }
 
     if (HTMLFrameOwnerElement* owner = localOwner())
-        owner->document().updateLayout();
+        owner->document().updateStyleAndLayout();
 
-    updateLayoutTree();
+    updateStyleAndLayoutTree();
 
     if (!isActive())
         return;
 
     if (frameView->needsLayout())
         frameView->layout();
 
     if (lifecycle().state() < DocumentLifecycle::LayoutClean)
         lifecycle().advanceTo(DocumentLifecycle::LayoutClean);
 }
@@ skipping 34 matching lines @@
 }
 
 void Document::clearFocusedElementSoon()
 {
     if (!m_clearFocusedElementTimer.isActive())
         m_clearFocusedElementTimer.startOneShot(0, BLINK_FROM_HERE);
 }
 
 void Document::clearFocusedElementTimerFired(Timer<Document>*)
 {
-    updateLayoutTree();
+    updateStyleAndLayoutTree();
     m_clearFocusedElementTimer.stop();
 
     if (m_focusedElement && !m_focusedElement->isFocusable())
         m_focusedElement->blur();
 }
 
 // FIXME: This is a bad idea and needs to be removed eventually.
 // Other browsers load stylesheets before they continue parsing the web page.
 // Since we don't, we can run JavaScript code that needs answers before the
 // stylesheets are loaded. Doing a layout ignoring the pending stylesheets
 // lets us get reasonable answers. The long term solution to this problem is
 // to instead suspend JavaScript execution.
-void Document::updateLayoutTreeIgnorePendingStylesheets()
+void Document::updateStyleAndLayoutTreeIgnorePendingStylesheets()
 {
     StyleEngine::IgnoringPendingStylesheet ignoring(styleEngine());
 
     if (styleEngine().hasPendingScriptBlockingSheets()) {
         // FIXME: We are willing to attempt to suppress painting with outdated style info only once.
         // Our assumption is that it would be dangerous to try to stop it a second time, after page
         // content has already been loaded and displayed with accurate style information. (Our
         // suppression involves blanking the whole page at the moment. If it were more refined, we
         // might be able to do something better.) It's worth noting though that this entire method
         // is a hack, since what we really want to do is suspend JS instead of doing a layout with
         // inaccurate information.
         HTMLElement* bodyElement = body();
         if (bodyElement && !bodyElement->layoutObject() && m_pendingSheetLayout == NoLayoutWithPendingSheets) {
             m_pendingSheetLayout = DidLayoutWithPendingSheets;
             styleEngine().resolverChanged(FullStyleUpdate);
         } else if (m_hasNodesWithPlaceholderStyle) {
             // If new nodes have been added or style recalc has been done with style sheets still
             // pending, some nodes may not have had their real style calculated yet. Normally this
             // gets cleaned when style sheets arrive but here we need up-to-date style immediately.
             setNeedsStyleRecalc(SubtreeStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::CleanupPlaceholderStyles));
         }
     }
-    updateLayoutTree();
+    updateStyleAndLayoutTree();
 }
 
-void Document::updateLayoutIgnorePendingStylesheets(Document::RunPostLayoutTasks runPostLayoutTasks)
+void Document::updateStyleAndLayoutIgnorePendingStylesheets(Document::RunPostLayoutTasks runPostLayoutTasks)
 {
-    updateLayoutTreeIgnorePendingStylesheets();
-    updateLayout();
+    updateStyleAndLayoutTreeIgnorePendingStylesheets();
+    updateStyleAndLayout();
 
     if (runPostLayoutTasks == RunPostLayoutTasksSynchronously && view())
         view()->flushAnyPendingPostLayoutTasks();
 }
 
 PassRefPtr<ComputedStyle> Document::styleForElementIgnoringPendingStylesheets(Element* element)
 {
     DCHECK_EQ(element->document(), this);
     StyleEngine::IgnoringPendingStylesheet ignoring(styleEngine());
     return ensureStyleResolver().styleForElement(element, element->parentNode() ? element->parentNode()->ensureComputedStyle() : 0);
@@ skipping 642 matching lines @@
         // Just bail out. Before or during the onload we were shifted to another page.
         // The old i-Bench suite does this. When this happens don't bother painting or laying out.
         m_loadEventProgress = LoadEventCompleted;
         return;
     }
 
     // We used to force a synchronous display and flush here.  This really isn't
     // necessary and can in fact be actively harmful if pages are loading at a rate of > 60fps
     // (if your platform is syncing flushes and limiting them to 60fps).
     if (!localOwner() || (localOwner()->layoutObject() && !localOwner()->layoutObject()->needsLayout())) {
-        updateLayoutTree();
+        updateStyleAndLayoutTree();
 
         // Always do a layout after loading if needed.
         if (view() && layoutView() && (!layoutView()->firstChild() || layoutView()->needsLayout()))
             view()->layout();
     }
 
     m_loadEventProgress = LoadEventCompleted;
 
     if (frame() && layoutView() && settings()->accessibilityEnabled()) {
         if (AXObjectCache* cache = axObjectCache()) {
@@ skipping 914 matching lines @@
         if (view()) {
             Widget* oldWidget = widgetForElement(*oldFocusedElement);
             if (oldWidget)
                 oldWidget->setFocus(false, params.type);
             else
                 view()->setFocus(false, params.type);
         }
     }
 
     if (newFocusedElement)
-        updateLayoutTreeForNode(newFocusedElement);
+        updateStyleAndLayoutTreeForNode(newFocusedElement);
     if (newFocusedElement && newFocusedElement->isFocusable()) {
         if (newFocusedElement->isRootEditableElement() && !acceptsEditingFocus(*newFocusedElement)) {
             // delegate blocks focus change
             focusChangeBlocked = true;
             goto SetFocusedElementDone;
         }
         // Set focus on the new node
         m_focusedElement = newFocusedElement;
         setSequentialFocusNavigationStartingPoint(m_focusedElement.get());
 
@@ skipping 40 matching lines @@
             frame()->spellChecker().didBeginEditing(m_focusedElement.get());
 
         // eww, I suck. set the qt focus correctly
         // ### find a better place in the code for this
         if (view()) {
             Widget* focusWidget = widgetForElement(*m_focusedElement);
             if (focusWidget) {
                 // Make sure a widget has the right size before giving it focus.
                 // Otherwise, we are testing edge cases of the Widget code.
                 // Specifically, in WebCore this does not work well for text fields.
-                updateLayout();
+                updateStyleAndLayout();
                 // Re-get the widget in case updating the layout changed things.
                 focusWidget = widgetForElement(*m_focusedElement);
             }
             if (focusWidget)
                 focusWidget->setFocus(true, params.type);
             else
                 view()->setFocus(true, params.type);
         }
     }
 
     if (!focusChangeBlocked && m_focusedElement) {
         // Create the AXObject cache in a focus change because Chromium relies on it.
         if (AXObjectCache* cache = axObjectCache())
             cache->handleFocusedUIElementChanged(oldFocusedElement, newFocusedElement);
     }
 
     if (!focusChangeBlocked && frameHost())
         frameHost()->chromeClient().focusedNodeChanged(oldFocusedElement, m_focusedElement.get());
 
 SetFocusedElementDone:
-    updateLayoutTree();
+    updateStyleAndLayoutTree();
     if (LocalFrame* frame = this->frame())
         frame->selection().didChangeFocus();
     return !focusChangeBlocked;
 }
 
 void Document::clearFocusedElement()
 {
     setFocusedElement(nullptr, FocusParams(SelectionBehaviorOnFocus::None, WebFocusTypeNone, nullptr));
 }
 
@@ skipping 767 matching lines @@
 }
 
 // Support for Javascript execCommand, and related methods
 
 static Editor::Command command(Document* document, const String& commandName)
 {
     LocalFrame* frame = document->frame();
     if (!frame || frame->document() != document)
         return Editor::Command();
 
-    document->updateLayoutTree();
+    document->updateStyleAndLayoutTree();
     return frame->editor().createCommand(commandName, CommandFromDOM);
 }
 
 bool Document::execCommand(const String& commandName, bool, const String& value, ExceptionState& exceptionState)
 {
     if (!isHTMLDocument() && !isXHTMLDocument()) {
         exceptionState.throwDOMException(InvalidStateError, "execCommand is only supported on HTML documents.");
         return false;
     }
     if (focusedElement() && isHTMLTextFormControlElement(*focusedElement()))
@@ skipping 303 matching lines @@
         const bool mainResourceWasAlreadyRequested = frame->loader().stateMachine()->committedFirstRealDocumentLoad();
 
         // FrameLoader::finishedParsing() might end up calling Document::implicitClose() if all
         // resource loads are complete. HTMLObjectElements can start loading their resources from
         // post attach callbacks triggered by recalcStyle().  This means if we parse out an <object>
         // tag and then reach the end of the document without updating styles, we might not have yet
         // started the resource load and might fire the window load event too early.  To avoid this
         // we force the styles to be up to date before calling FrameLoader::finishedParsing().
         // See https://bugs.webkit.org/show_bug.cgi?id=36864 starting around comment 35.
         if (mainResourceWasAlreadyRequested)
-            updateLayoutTree();
+            updateStyleAndLayoutTree();
 
         beginLifecycleUpdatesIfRenderingReady();
 
         frame->loader().finishedParsing();
 
         TRACE_EVENT_INSTANT1("devtools.timeline", "MarkDOMContent", TRACE_EVENT_SCOPE_THREAD, "data", InspectorMarkLoadEvent::data(frame));
         InspectorInstrumentation::domContentLoadedEventFired(frame);
     }
 
     // Schedule dropping of the ElementDataCache. We keep it alive for a while after parsing finishes
@@ skipping 316 matching lines @@
 void Document::cancelFocusAppearanceUpdate()
 {
     m_updateFocusAppearanceTimer.stop();
 }
 
 void Document::updateFocusAppearanceTimerFired(Timer<Document>*)
 {
     Element* element = focusedElement();
     if (!element)
         return;
-    updateLayout();
+    updateStyleAndLayout();
     if (element->isFocusable())
         element->updateFocusAppearance(m_updateFocusAppearanceSelectionBahavior);
 }
 
 void Document::attachRange(Range* range)
 {
     DCHECK(!m_ranges.contains(range));
     m_ranges.add(range);
 }
 
@@ skipping 228 matching lines @@
 
 void Document::loadPluginsSoon()
 {
     // FIXME: Remove this timer once we don't need to compute layout to load plugins.
     if (!m_pluginLoadingTimer.isActive())
         m_pluginLoadingTimer.startOneShot(0, BLINK_FROM_HERE);
 }
 
 void Document::pluginLoadingTimerFired(Timer<Document>*)
 {
-    updateLayout();
+    updateStyleAndLayout();
 }
 
 ScriptedAnimationController& Document::ensureScriptedAnimationController()
 {
     if (!m_scriptedAnimationController) {
         m_scriptedAnimationController = ScriptedAnimationController::create(this);
         // We need to make sure that we don't start up the animation controller on a background tab, for example.
         if (!page())
             m_scriptedAnimationController->suspend();
     }
@@ skipping 622 matching lines @@
 #ifndef NDEBUG
 using namespace blink;
 void showLiveDocumentInstances()
 {
     Document::WeakDocumentSet& set = Document::liveDocumentSet();
     fprintf(stderr, "There are %u documents currently alive:\n", set.size());
     for (Document* document : set)
         fprintf(stderr, "- Document %p URL: %s\n", document, document->url().getString().utf8().data());
 }
 #endif