Rename LayoutStyle to papayawhip

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 63 matching lines @@
 #include "core/dom/ElementRegistrationOptions.h"
 #include "core/dom/ElementTraversal.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/ExecutionContextTask.h"
 #include "core/dom/MainThreadTaskRunner.h"
 #include "core/dom/Microtask.h"
 #include "core/dom/MutationObserver.h"
 #include "core/dom/NodeChildRemovalTracker.h"
 #include "core/dom/NodeFilter.h"
 #include "core/dom/NodeIterator.h"
-#include "core/dom/NodeLayoutStyle.h"
+#include "core/dom/NodeComputedStyle.h"
 #include "core/dom/NodeRareData.h"
 #include "core/dom/NodeRenderingTraversal.h"
 #include "core/dom/NodeTraversal.h"
 #include "core/dom/NodeWithIndex.h"
 #include "core/dom/ProcessingInstruction.h"
 #include "core/dom/RequestAnimationFrameCallback.h"
 #include "core/dom/ScriptRunner.h"
 #include "core/dom/ScriptedAnimationController.h"
 #include "core/dom/SelectorQuery.h"
 #include "core/dom/StaticNodeList.h"
@@ skipping 1483 matching lines @@
     if (!isActive())
         return;
     if (!childNeedsStyleInvalidation())
         return;
     TRACE_EVENT0("blink", "Document::updateStyleInvalidationIfNeeded");
     ASSERT(styleResolver());
 
     styleResolver()->ruleFeatureSet().styleInvalidator().invalidate(*this);
 }
 
-void Document::setupFontBuilder(LayoutStyle& documentStyle)
+void Document::setupFontBuilder(ComputedStyle& documentStyle)
 {
     FontBuilder fontBuilder(*this);
     RefPtrWillBeRawPtr<CSSFontSelector> selector = styleEngine().fontSelector();
     fontBuilder.createFontForDocument(selector, documentStyle);
 }
 
 void Document::inheritHtmlAndBodyElementStyles(StyleRecalcChange change)
 {
     ASSERT(inStyleRecalc());
     ASSERT(documentElement());
 
     bool didRecalcDocumentElement = false;
-    RefPtr<LayoutStyle> documentElementStyle = documentElement()->mutableLayoutStyle();
+    RefPtr<ComputedStyle> documentElementStyle = documentElement()->mutableComputedStyle();
     if (change == Force)
         documentElement()->clearAnimationStyleChange();
     if (!documentElementStyle || documentElement()->needsStyleRecalc() || change == Force) {
         documentElementStyle = ensureStyleResolver().styleForElement(documentElement());
         didRecalcDocumentElement = true;
     }
 
     WritingMode rootWritingMode = documentElementStyle->writingMode();
     TextDirection rootDirection = documentElementStyle->direction();
 
     HTMLElement* body = this->body();
-    RefPtr<LayoutStyle> bodyStyle;
+    RefPtr<ComputedStyle> bodyStyle;
 
     if (body) {
-        bodyStyle = body->mutableLayoutStyle();
+        bodyStyle = body->mutableComputedStyle();
         if (didRecalcDocumentElement)
             body->clearAnimationStyleChange();
         if (!bodyStyle || body->needsStyleRecalc() || didRecalcDocumentElement)
             bodyStyle = ensureStyleResolver().styleForElement(body, documentElementStyle.get());
         rootWritingMode = bodyStyle->writingMode();
         rootDirection = bodyStyle->direction();
     }
 
-    RefPtr<LayoutStyle> overflowStyle;
+    RefPtr<ComputedStyle> overflowStyle;
     if (Element* element = viewportDefiningElement(documentElementStyle.get())) {
         if (element == body) {
             overflowStyle = bodyStyle;
         } else {
             ASSERT(element == documentElement());
             overflowStyle = documentElementStyle;
         }
     }
 
     // Resolved rem units are stored in the matched properties cache so we need to make sure to
     // invalidate the cache if the documentElement needed to reattach or the font size changed
     // and then trigger a full document recalc. We also need to clear it here since the
     // call to styleForElement on the body above can cache bad values for rem units if the
     // documentElement's style was dirty. We could keep track of which elements depend on
     // rem units like we do for viewport styles, but we assume root font size changes are
     // rare and just invalidate the cache for now.
-    if (styleEngine().usesRemUnits() && (documentElement()->needsAttach() || documentElement()->computedStyle()->fontSize() != documentElementStyle->fontSize())) {
+    if (styleEngine().usesRemUnits() && (documentElement()->needsAttach() || documentElement()->ensureComputedStyle()->fontSize() != documentElementStyle->fontSize())) {
         ensureStyleResolver().invalidateMatchedPropertiesCache();
         documentElement()->setNeedsStyleRecalc(SubtreeStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::FontSizeChange));
     }
 
     EOverflow overflowX = OAUTO;
     EOverflow overflowY = OAUTO;
     float columnGap = 0;
     if (overflowStyle) {
         overflowX = overflowStyle->overflowX();
         overflowY = overflowStyle->overflowY();
         // Visible overflow on the viewport is meaningless, and the spec says to treat it as 'auto':
         if (overflowX == OVISIBLE)
             overflowX = OAUTO;
         if (overflowY == OVISIBLE)
             overflowY = OAUTO;
         // Column-gap is (ab)used by the current paged overflow implementation (in lack of other
         // ways to specify gaps between pages), so we have to propagate it too.
         columnGap = overflowStyle->columnGap();
     }
 
     WebScrollBlocksOn scrollBlocksOn = documentElementStyle->scrollBlocksOn();
 
-    RefPtr<LayoutStyle> documentStyle = layoutView()->style();
+    RefPtr<ComputedStyle> documentStyle = layoutView()->style();
     if (documentStyle->writingMode() != rootWritingMode
         || documentStyle->direction() != rootDirection
         || documentStyle->overflowX() != overflowX
         || documentStyle->overflowY() != overflowY
         || documentStyle->columnGap() != columnGap
         || documentStyle->scrollBlocksOn() != scrollBlocksOn) {
-        RefPtr<LayoutStyle> newStyle = LayoutStyle::clone(*documentStyle);
+        RefPtr<ComputedStyle> newStyle = ComputedStyle::clone(*documentStyle);
         newStyle->setWritingMode(rootWritingMode);
         newStyle->setDirection(rootDirection);
         newStyle->setColumnGap(columnGap);
         newStyle->setOverflowX(overflowX);
         newStyle->setOverflowY(overflowY);
         newStyle->setScrollBlocksOn(scrollBlocksOn);
         layoutView()->setStyle(newStyle);
         setupFontBuilder(*newStyle);
     }
 
     if (body) {
-        if (const LayoutStyle* style = body->layoutStyle()) {
+        if (const ComputedStyle* style = body->computedStyle()) {
             if (style->direction() != rootDirection || style->writingMode() != rootWritingMode)
                 body->setNeedsStyleRecalc(SubtreeStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::WritingModeChange));
         }
     }
 
-    if (const LayoutStyle* style = documentElement()->layoutStyle()) {
+    if (const ComputedStyle* style = documentElement()->computedStyle()) {
         if (style->direction() != rootDirection || style->writingMode() != rootWritingMode)
             documentElement()->setNeedsStyleRecalc(SubtreeStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::WritingModeChange));
     }
 }
 
 void Document::updateRenderTree(StyleRecalcChange change)
 {
     ASSERT(isMainThread());
 
     ScriptForbiddenScope forbidScript;
@@ skipping 70 matching lines @@
     if (styleChangeType() >= SubtreeStyleChange)
         change = Force;
 
     // FIXME: Cannot access the ensureStyleResolver() before calling styleForDocument below because
     // apparently the StyleResolver's constructor has side effects. We should fix it.
     // See printing/setPrinting.html, printing/width-overflow.html though they only fail on
     // mac when accessing the resolver by what appears to be a viewport size difference.
 
     if (change == Force) {
         m_hasNodesWithPlaceholderStyle = false;
-        RefPtr<LayoutStyle> documentStyle = StyleResolver::styleForDocument(*this);
-        StyleRecalcChange localChange = LayoutStyle::stylePropagationDiff(documentStyle.get(), layoutView()->style());
+        RefPtr<ComputedStyle> documentStyle = StyleResolver::styleForDocument(*this);
+        StyleRecalcChange localChange = ComputedStyle::stylePropagationDiff(documentStyle.get(), layoutView()->style());
         if (localChange != NoChange)
             layoutView()->setStyle(documentStyle.release());
     }
 
     clearNeedsStyleRecalc();
 
     // Uncomment to enable printing of statistics about style sharing and the matched property cache.
     // Optionally pass StyleResolver::ReportSlowStats to print numbers that require crawling the
     // entire DOM (where collecting them is very slow).
     // FIXME: Expose this as a runtime flag.
@@ skipping 126 matching lines @@
             updateRenderTree(Force);
         }
     }
 
     updateLayout();
 
     if (runPostLayoutTasks == RunPostLayoutTasksSynchronously && view())
         view()->flushAnyPendingPostLayoutTasks();
 }
 
-PassRefPtr<LayoutStyle> Document::styleForElementIgnoringPendingStylesheets(Element* element)
+PassRefPtr<ComputedStyle> Document::styleForElementIgnoringPendingStylesheets(Element* element)
 {
     ASSERT_ARG(element, element->document() == this);
     StyleEngine::IgnoringPendingStylesheet ignoring(styleEngine());
-    return ensureStyleResolver().styleForElement(element, element->parentNode() ? element->parentNode()->computedStyle() : 0);
+    return ensureStyleResolver().styleForElement(element, element->parentNode() ? element->parentNode()->ensureComputedStyle() : 0);
 }
 
-PassRefPtr<LayoutStyle> Document::styleForPage(int pageIndex)
+PassRefPtr<ComputedStyle> Document::styleForPage(int pageIndex)
 {
     updateDistribution();
     return ensureStyleResolver().styleForPage(pageIndex);
 }
 
 bool Document::isPageBoxVisible(int pageIndex)
 {
     return styleForPage(pageIndex)->visibility() != HIDDEN; // display property doesn't apply to @page.
 }
 
 void Document::pageSizeAndMarginsInPixels(int pageIndex, IntSize& pageSize, int& marginTop, int& marginRight, int& marginBottom, int& marginLeft)
 {
-    RefPtr<LayoutStyle> style = styleForPage(pageIndex);
+    RefPtr<ComputedStyle> style = styleForPage(pageIndex);
 
     int width = pageSize.width();
     int height = pageSize.height();
     switch (style->pageSizeType()) {
     case PAGE_SIZE_AUTO:
         break;
     case PAGE_SIZE_AUTO_LANDSCAPE:
         if (width < height)
             std::swap(width, height);
         break;
@@ skipping 413 matching lines @@
 
 HTMLHeadElement* Document::head() const
 {
     Node* de = documentElement();
     if (!de)
         return 0;
 
     return Traversal<HTMLHeadElement>::firstChild(*de);
 }
 
-Element* Document::viewportDefiningElement(const LayoutStyle* rootStyle) const
+Element* Document::viewportDefiningElement(const ComputedStyle* rootStyle) const
 {
     // If a BODY element sets non-visible overflow, it is to be propagated to the viewport, as long
     // as the following conditions are all met:
     // (1) The root element is HTML.
     // (2) It is the primary BODY element (we only assert for this, expecting callers to behave).
     // (3) The root element has visible overflow.
     // Otherwise it's the root element's properties that are to be propagated.
     Element* rootElement = documentElement();
     Element* bodyElement = body();
     if (!rootElement)
         return 0;
     if (!rootStyle) {
-        rootStyle = rootElement->layoutStyle();
+        rootStyle = rootElement->computedStyle();
         if (!rootStyle)
             return 0;
     }
     if (bodyElement && rootStyle->isOverflowVisible() && isHTMLHtmlElement(*rootElement))
         return bodyElement;
     return rootElement;
 }
 
 void Document::close(ExceptionState& exceptionState)
 {
@@ skipping 3319 matching lines @@
 #ifndef NDEBUG
 using namespace blink;
 void showLiveDocumentInstances()
 {
     WeakDocumentSet& set = 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().string().utf8().data());
 }
 #endif