Remove the Pagination struct, clean up viewport scroll policy propagation.

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 324 matching lines @@
 }
 
 static void printNavigationErrorMessage(const Frame& frame, const KURL& activeURL, const char* reason)
 {
     String message = "Unsafe JavaScript attempt to initiate navigation for frame with URL '" + frame.document()->url().string() + "' from frame with URL '" + activeURL.string() + "'. " + reason + "\n";
 
     // FIXME: should we print to the console of the document performing the navigation instead?
     frame.domWindow()->printErrorMessage(message);
 }
 
+// Decide which element that is to define the viewport's overflow policy. Any parameter may be
+// 0. Avoid calling Element::renderStyle() here; require style as separate parameters instead. The
+// reason for this is that style may not have been associated with the elements yet - in which case
+// it may have been calculated on the fly (without associating it with the actual element)
+// somewhere. This isn't very pretty, but if we want to avoid duplicating the code that chooses
+// between root and body for overflow propagation, this is about as pretty as it gets.

[rune, 2014/02/07 16:44:27]

You could consolidate this code with the viewportDefiningElement method making
it a member of Document, have rootStyle and bodyStyle as parameters (potentially
default to 0), and retrieve rootStyle and bodyStyle from documentElement() and
body() when passed as 0.

That gives an extra cost of retrieving body() an extra time when called from
inheritHtmlAndBodyElementStyles, but prettier I think.

[mstensho (USE GERRIT), 2014/02/11 10:44:14]

Done.

+// The |bodyElement| passed must either be 0 or set to the document's primary body element.
+static Element* pickViewportDefiningElement(Element* rootElement, RenderStyle* rootStyle, Element* bodyElement, RenderStyle* bodyStyle)

[ojan, 2014/02/08 01:40:19]

Do we need to pass the RenderStyles? Can't we just grab them off
rootElement/bodyElement?

[mstensho (USE GERRIT), 2014/02/11 10:44:14]

That's not always going to work. The comment tries to explain why.

+{
+    // 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.
+    if (!rootElement || !rootStyle)
+        return 0;
+    ASSERT(!bodyElement || bodyElement == bodyElement->document().body());
+    if (bodyElement && bodyStyle && rootStyle->isOverflowVisible() && rootElement->hasTagName(htmlTag))
+        return bodyElement;
+    return rootElement;
+}
+
 uint64_t Document::s_globalTreeVersion = 0;
 
 // This class doesn't work with non-Document ExecutionContext.
 class AutofocusTask FINAL : public ExecutionContextTask {
 public:
     static PassOwnPtr<AutofocusTask> create()
     {
         return adoptPtr(new AutofocusTask());
     }
     virtual ~AutofocusTask() { }
@@ skipping 1243 matching lines @@
     }
     Node* root = node;
     while (Node* host = root->shadowHost())
         root = host;
     while (Node* ancestor = root->parentOrShadowHostNode())
         root = ancestor;
     if (root->childNeedsDistributionRecalc())
         root->recalcDistribution();
 }
 
 void Document::setStyleDependentState(RenderStyle* documentStyle)

[ojan, 2014/02/08 01:40:19]

Nit: maybe rename this method to setupFontBuilder or something since that's all
it does now.

[mstensho (USE GERRIT), 2014/02/11 10:44:14]

Done.

 {
-    const Pagination& pagination = view()->pagination();
-    if (pagination.mode != Pagination::Unpaginated) {
-        Pagination::setStylesForPaginationMode(pagination.mode, documentStyle);
-        documentStyle->setColumnGap(pagination.gap);
-        if (renderView()->hasColumns())
-            renderView()->updateColumnInfoFromStyle(documentStyle);
-    }
-
     FontBuilder fontBuilder;
     fontBuilder.initForStyleResolve(*this, documentStyle, isSVGDocument());
     RefPtr<CSSFontSelector> selector = m_styleEngine->fontSelector();
     fontBuilder.createFontForDocument(selector, documentStyle);
 }
 
 void Document::inheritHtmlAndBodyElementStyles(StyleRecalcChange change)
 {
     ASSERT(inStyleRecalc());
     ASSERT(documentElement());
 
     RefPtr<RenderStyle> documentElementStyle = documentElement()->renderStyle();
     if (!documentElementStyle || documentElement()->needsStyleRecalc() || change == Force)
         documentElementStyle = ensureStyleResolver().styleForElement(documentElement());
 
     WritingMode rootWritingMode = documentElementStyle->writingMode();
     TextDirection rootDirection = documentElementStyle->direction();
+
     HTMLElement* body = this->body();
-
+    RefPtr<RenderStyle> bodyStyle;
     if (body) {
-        RefPtr<RenderStyle> bodyStyle = body->renderStyle();
+        bodyStyle = body->renderStyle();
         if (!bodyStyle || body->needsStyleRecalc() || documentElement()->needsStyleRecalc() || change == Force)
             bodyStyle = ensureStyleResolver().styleForElement(body, documentElementStyle.get());
         if (!writingModeSetOnDocumentElement())
             rootWritingMode = bodyStyle->writingMode();
         if (!directionSetOnDocumentElement())
             rootDirection = bodyStyle->direction();
     }
 
+    RefPtr<RenderStyle> overflowStyle;
+    if (Element* element = pickViewportDefiningElement(documentElement(), documentElementStyle.get(), body, bodyStyle.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())) {
         ensureStyleResolver().invalidateMatchedPropertiesCache();
         documentElement()->setNeedsStyleRecalc(SubtreeStyleChange);
     }
 
     RefPtr<RenderStyle> documentStyle = renderView()->style();
-    if (documentStyle->writingMode() != rootWritingMode || documentStyle->direction() != rootDirection) {
+    if (documentStyle->writingMode() != rootWritingMode
+        || documentStyle->direction() != rootDirection
+        || (overflowStyle && (documentStyle->overflowX() != overflowStyle->overflowX() || documentStyle->overflowY() != overflowStyle->overflowY()))) {
         RefPtr<RenderStyle> newStyle = RenderStyle::clone(documentStyle.get());
         newStyle->setWritingMode(rootWritingMode);
         newStyle->setDirection(rootDirection);
+        EOverflow overflowX = OAUTO;
+        EOverflow overflowY = OAUTO;
+        if (overflowStyle) {
+            overflowX = overflowStyle->overflowX();
+            overflowY = overflowStyle->overflowY();
+            // Visible overflow on the viewport is meaningless.
+            if (overflowX == OVISIBLE)
+                overflowX = OAUTO;

[ojan, 2014/02/08 01:40:19]

We need to do this because pagination doesn't work with overflow:visible? A
comment explaining why we need to do this might help.

[mstensho (USE GERRIT), 2014/02/11 10:44:14]

overflow:visible is meaningless on the viewport, regardless of pagination. The
spec [1] has this to say: "The 'visible' value when used for the viewport must
be interpreted as 'auto'.". But I'll improve the comment.

[1] http://www.w3.org/TR/CSS2/visufx.html#overflow

+            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.
+            newStyle->setColumnGap(overflowStyle->columnGap());
+        }
+        newStyle->setOverflowX(overflowX);
+        newStyle->setOverflowY(overflowY);
         renderView()->setStyle(newStyle);
         setStyleDependentState(newStyle.get());
     }
 
     if (body) {
         if (RenderStyle* style = body->renderStyle()) {
             if (style->direction() != rootDirection || style->writingMode() != rootWritingMode)
                 body->setNeedsStyleRecalc(SubtreeStyleChange);
         }
     }
@@ skipping 659 matching lines @@
     if (!de)
         return 0;
 
     for (Node* node = de->firstChild(); node; node = node->nextSibling()) {
         if (node->hasTagName(headTag))
             return toHTMLHeadElement(node);
     }
     return 0;
 }
 
+Element* Document::viewportDefiningElement() const
+{
+    Element* rootElement = documentElement();
+    Element* bodyElement = body();
+    return pickViewportDefiningElement(
+        rootElement, rootElement ? rootElement->renderStyle() : 0,
+        bodyElement, bodyElement ? bodyElement->renderStyle() : 0);
+}
+
 void Document::close()
 {
     // FIXME: We should follow the specification more closely:
     //        http://www.whatwg.org/specs/web-apps/current-work/#dom-document-close
 
     if (!scriptableDocumentParser() || !scriptableDocumentParser()->wasCreatedByScript() || !scriptableDocumentParser()->isParsing())
         return;
 
     explicitClose();
 }
@@ skipping 3045 matching lines @@
 void Document::defaultEventHandler(Event* event)
 {
     if (frame() && frame()->remotePlatformLayer()) {
         frame()->chromeClient().forwardInputEvent(this, event);
         return;
     }
     Node::defaultEventHandler(event);
 }
 
 } // namespace WebCore