diff --git a/Source/WTF/wtf/Platform.h b/Source/WTF/wtf/Platform.h index 290f6de219b..f7411e2dfb4 100644 --- a/Source/WTF/wtf/Platform.h +++ b/Source/WTF/wtf/Platform.h @@ -1120,7 +1120,7 @@ #if !defined(NDEBUG) #define ENABLE_TREE_DEBUGGING 1 #else -#define ENABLE_TREE_DEBUGGING 0 +#define ENABLE_TREE_DEBUGGING 1 #endif #endif diff --git a/Source/WebCore/DerivedSources.make b/Source/WebCore/DerivedSources.make index f5d0e5d2c3e..3945090acf3 100644 --- a/Source/WebCore/DerivedSources.make +++ b/Source/WebCore/DerivedSources.make @@ -532,6 +532,7 @@ JS_BINDING_IDLS = \ $(WebCore)/dom/TextDecoder.idl \ $(WebCore)/dom/TextEncoder.idl \ $(WebCore)/dom/TextEvent.idl \ + $(WebCore)/dom/InlineTextRun.idl \ $(WebCore)/dom/TransitionEvent.idl \ $(WebCore)/dom/TreeWalker.idl \ $(WebCore)/dom/UIEvent.idl \ diff --git a/Source/WebCore/Sources.txt b/Source/WebCore/Sources.txt index a461719e2dd..2d48c60758b 100644 --- a/Source/WebCore/Sources.txt +++ b/Source/WebCore/Sources.txt @@ -1802,7 +1802,9 @@ rendering/InlineBox.cpp rendering/InlineElementBox.cpp rendering/InlineFlowBox.cpp rendering/InlineIterator.cpp +rendering/InlineTextBreaker.cpp rendering/InlineTextBox.cpp +rendering/InlineTextRunIterator.cpp rendering/LayoutDisallowedScope.cpp rendering/LayoutRepainter.cpp rendering/LayoutState.cpp diff --git a/Source/WebCore/WebCore.xcodeproj/project.pbxproj b/Source/WebCore/WebCore.xcodeproj/project.pbxproj index a6a138060f6..91fb8a5cd04 100644 --- a/Source/WebCore/WebCore.xcodeproj/project.pbxproj +++ b/Source/WebCore/WebCore.xcodeproj/project.pbxproj @@ -396,6 +396,10 @@ 1193408A1FEB355D00935F1E /* RenderTreeBuilderRuby.h in Headers */ = {isa = PBXBuildFile; fileRef = 119340881FEB355D00935F1E /* RenderTreeBuilderRuby.h */; }; 119340971FED715500935F1E /* RenderTreeBuilderFormControls.h in Headers */ = {isa = PBXBuildFile; fileRef = 119340951FED715500935F1E /* RenderTreeBuilderFormControls.h */; }; 119340A31FEE024000935F1E /* RenderTreeBuilderBlock.h in Headers */ = {isa = PBXBuildFile; fileRef = 119340A11FEE024000935F1E /* RenderTreeBuilderBlock.h */; }; + 11C0C79E20694AE100BE3A84 /* InlineTextRunIterator.h in Headers */ = {isa = PBXBuildFile; fileRef = 11C0C79920694ADE00BE3A84 /* InlineTextRunIterator.h */; }; + 11C0C7A020694AE100BE3A84 /* InlineTextBreaker.h in Headers */ = {isa = PBXBuildFile; fileRef = 11C0C79C20694AE000BE3A84 /* InlineTextBreaker.h */; }; + 11C0C7A520694B0A00BE3A84 /* InlineTextRun.h in Headers */ = {isa = PBXBuildFile; fileRef = 11C0C7A320694B0900BE3A84 /* InlineTextRun.h */; }; + 11C0C7A7206953F700BE3A84 /* JSInlineTextRun.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 11C0C7A6206953F600BE3A84 /* JSInlineTextRun.cpp */; }; 11CB2789203BA570004A1DC9 /* RenderTreeBuilderFullScreen.h in Headers */ = {isa = PBXBuildFile; fileRef = 11CB2787203BA570004A1DC9 /* RenderTreeBuilderFullScreen.h */; }; 11E067EE1E6246E500162D16 /* SimpleLineLayoutCoverage.h in Headers */ = {isa = PBXBuildFile; fileRef = 11E067ED1E6246E500162D16 /* SimpleLineLayoutCoverage.h */; settings = {ATTRIBUTES = (Private, ); }; }; 1400D7A817136EA70077CE05 /* ScriptWrappableInlines.h in Headers */ = {isa = PBXBuildFile; fileRef = 1400D7A717136EA70077CE05 /* ScriptWrappableInlines.h */; settings = {ATTRIBUTES = (Private, ); }; }; @@ -5706,6 +5710,13 @@ 119340951FED715500935F1E /* RenderTreeBuilderFormControls.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RenderTreeBuilderFormControls.h; sourceTree = ""; }; 119340A01FEE024000935F1E /* RenderTreeBuilderBlock.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = RenderTreeBuilderBlock.cpp; sourceTree = ""; }; 119340A11FEE024000935F1E /* RenderTreeBuilderBlock.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = RenderTreeBuilderBlock.h; sourceTree = ""; }; + 11C0C79920694ADE00BE3A84 /* InlineTextRunIterator.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = InlineTextRunIterator.h; sourceTree = ""; }; + 11C0C79B20694ADF00BE3A84 /* InlineTextBreaker.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = InlineTextBreaker.cpp; sourceTree = ""; }; + 11C0C79C20694AE000BE3A84 /* InlineTextBreaker.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = InlineTextBreaker.h; sourceTree = ""; }; + 11C0C79D20694AE000BE3A84 /* InlineTextRunIterator.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = InlineTextRunIterator.cpp; sourceTree = ""; }; + 11C0C7A220694B0800BE3A84 /* InlineTextRun.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = InlineTextRun.idl; sourceTree = ""; }; + 11C0C7A320694B0900BE3A84 /* InlineTextRun.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = InlineTextRun.h; sourceTree = ""; }; + 11C0C7A6206953F600BE3A84 /* JSInlineTextRun.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = JSInlineTextRun.cpp; path = JSInlineTextRun.cpp; sourceTree = ""; }; 11C5F1162003E7750001AE60 /* RenderTreeBuilderInline.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = RenderTreeBuilderInline.cpp; sourceTree = ""; }; 11C5F1182003E7760001AE60 /* RenderTreeBuilderInline.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RenderTreeBuilderInline.h; sourceTree = ""; }; 11C5F11D2003F69E0001AE60 /* RenderTreeBuilderBlockFlow.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RenderTreeBuilderBlockFlow.h; sourceTree = ""; }; @@ -22145,6 +22156,7 @@ A83B79100CCB001B000B0825 /* Core */ = { isa = PBXGroup; children = ( + 11C0C7A6206953F600BE3A84 /* JSInlineTextRun.cpp */, 7C30D97E1F815AC000268356 /* JSAbortController.cpp */, 7C30D9801F815AC100268356 /* JSAbortController.h */, 7C30D9821F815AC200268356 /* JSAbortSignal.cpp */, @@ -25479,6 +25491,10 @@ F523D2F302DE443B018635CA /* rendering */ = { isa = PBXGroup; children = ( + 11C0C79B20694ADF00BE3A84 /* InlineTextBreaker.cpp */, + 11C0C79C20694AE000BE3A84 /* InlineTextBreaker.h */, + 11C0C79D20694AE000BE3A84 /* InlineTextRunIterator.cpp */, + 11C0C79920694ADE00BE3A84 /* InlineTextRunIterator.h */, FFB698C81832F10B00158A31 /* line */, 439046C212DA25CE00AF80A2 /* mathml */, FD08A879175D3926002CD360 /* shapes */, @@ -25775,6 +25791,8 @@ F523D32402DE4478018635CA /* dom */ = { isa = PBXGroup; children = ( + 11C0C7A320694B0900BE3A84 /* InlineTextRun.h */, + 11C0C7A220694B0800BE3A84 /* InlineTextRun.idl */, CE2616A4187E65C1007955F3 /* ios */, 2D5036661BCDDDC400E20BB3 /* mac */, 51ECC3E42005831F00483EAE /* messageports */, @@ -26771,6 +26789,7 @@ 31DCD29D1AB4FBDE0072E817 /* AnimationTrigger.h in Headers */, 0F580FAF149800D400FB5BD8 /* AnimationUtilities.h in Headers */, 93309DD7099E64920056E581 /* AppendNodeCommand.h in Headers */, + 11C0C7A520694B0A00BE3A84 /* InlineTextRun.h in Headers */, A1DF5A941F7EC4320058A477 /* ApplePayContactField.h in Headers */, A12C59EE2035FC9B0012236B /* ApplePayError.h in Headers */, 7C6579E31E00827000E3A27A /* ApplePayLineItem.h in Headers */, @@ -30369,6 +30388,7 @@ 4945BFD413CF809000CC3B38 /* TransformState.h in Headers */, E17B491616A9B094001C8839 /* TransitionEvent.h in Headers */, 49E911D20EF86D47009D0CAF /* TranslateTransformOperation.h in Headers */, + 11C0C7A020694AE100BE3A84 /* InlineTextBreaker.h in Headers */, 854FE7370A2297BE0058D7AD /* Traversal.h in Headers */, 37FD4298118368460093C029 /* TreeDepthLimit.h in Headers */, 14D64B5D134A5B6B00E58FDA /* TreeScope.h in Headers */, @@ -30583,6 +30603,7 @@ 97AABD1E14FA09D5007457AE /* WebSocketChannel.h in Headers */, 97AABD1F14FA09D5007457AE /* WebSocketChannelClient.h in Headers */, 4A38BF5114FE1C0900612512 /* WebSocketDeflateFramer.h in Headers */, + 11C0C79E20694AE100BE3A84 /* InlineTextRunIterator.h in Headers */, 97AABD2114FA09D5007457AE /* WebSocketDeflater.h in Headers */, 97AABD2314FA09D5007457AE /* WebSocketExtensionDispatcher.h in Headers */, 4A5A2ADC161E7E00005889DD /* WebSocketExtensionParser.h in Headers */, @@ -31067,6 +31088,7 @@ 0719427F1D088F21002AA51D /* AVFoundationMIMETypeCache.mm in Sources */, 070363E5181A1CDC00C074A5 /* AVMediaCaptureSource.mm in Sources */, CD336F6117F9F64700DDDCD0 /* AVTrackPrivateAVFObjCImpl.mm in Sources */, + 11C0C7A7206953F700BE3A84 /* JSInlineTextRun.cpp in Sources */, 070363E7181A1CDC00C074A5 /* AVVideoCaptureSource.mm in Sources */, 7A45032F18DB717200377B34 /* BufferedLineReader.cpp in Sources */, 0753860214489E9800B78452 /* CachedTextTrack.cpp in Sources */, diff --git a/Source/WebCore/css/CSSComputedStyleDeclaration.cpp b/Source/WebCore/css/CSSComputedStyleDeclaration.cpp index 923ab54d4f2..12004b5afbe 100644 --- a/Source/WebCore/css/CSSComputedStyleDeclaration.cpp +++ b/Source/WebCore/css/CSSComputedStyleDeclaration.cpp @@ -4113,6 +4113,36 @@ String CSSComputedStyleDeclaration::getPropertyValue(CSSPropertyID propertyID) c return value->cssText(); } +bool CSSComputedStyleDeclaration::isPropertyValueInitial(const String& propertyName) +{ + m_element->document().updateLayoutIgnorePendingStylesheets(); + auto* style = m_element->computedStyle(m_pseudoElementSpecifier); + if (!style) + return true; + + CSSPropertyID propertyID = cssPropertyID(propertyName); + if (!propertyID) + return true; + + switch (propertyID) { + case CSSPropertyLeft: + return style->left().isAuto(); + case CSSPropertyRight: + return style->right().isAuto(); + case CSSPropertyTop: + return style->top().isAuto(); + case CSSPropertyBottom: + return style->bottom().isAuto(); + case CSSPropertyWidth: + return style->width().isAuto(); + case CSSPropertyHeight: + return style->height().isAuto(); + default: + ASSERT_NOT_REACHED(); + } + return false; +} + unsigned CSSComputedStyleDeclaration::length() const { updateStyleIfNeededForProperty(m_element.get(), CSSPropertyCustom); diff --git a/Source/WebCore/css/CSSComputedStyleDeclaration.h b/Source/WebCore/css/CSSComputedStyleDeclaration.h index 39ae6c30d7e..a3b6f4697bd 100644 --- a/Source/WebCore/css/CSSComputedStyleDeclaration.h +++ b/Source/WebCore/css/CSSComputedStyleDeclaration.h @@ -123,6 +123,7 @@ private: String item(unsigned index) const final; RefPtr getPropertyCSSValue(const String& propertyName) final; String getPropertyValue(const String& propertyName) final; + bool isPropertyValueInitial(const String& propertyName) final; String getPropertyPriority(const String& propertyName) final; String getPropertyShorthand(const String& propertyName) final; bool isPropertyImplicit(const String& propertyName) final; diff --git a/Source/WebCore/css/CSSStyleDeclaration.h b/Source/WebCore/css/CSSStyleDeclaration.h index b18c9ce3274..4dfb6b936f8 100644 --- a/Source/WebCore/css/CSSStyleDeclaration.h +++ b/Source/WebCore/css/CSSStyleDeclaration.h @@ -54,6 +54,7 @@ public: virtual String item(unsigned index) const = 0; virtual RefPtr getPropertyCSSValue(const String& propertyName) = 0; virtual String getPropertyValue(const String& propertyName) = 0; + virtual bool isPropertyValueInitial(const String& propertyName) = 0; virtual String getPropertyPriority(const String& propertyName) = 0; virtual String getPropertyShorthand(const String& propertyName) = 0; virtual bool isPropertyImplicit(const String& propertyName) = 0; diff --git a/Source/WebCore/css/CSSStyleDeclaration.idl b/Source/WebCore/css/CSSStyleDeclaration.idl index 035cb6245d9..c622313db3b 100644 --- a/Source/WebCore/css/CSSStyleDeclaration.idl +++ b/Source/WebCore/css/CSSStyleDeclaration.idl @@ -30,6 +30,8 @@ DOMString getPropertyValue(DOMString propertyName); + boolean isPropertyValueInitial(DOMString propertyName); + [CEReactions, MayThrowException] DOMString removeProperty(DOMString propertyName); DOMString? getPropertyPriority(DOMString propertyName); diff --git a/Source/WebCore/css/PropertySetCSSStyleDeclaration.cpp b/Source/WebCore/css/PropertySetCSSStyleDeclaration.cpp index 084cbca04ec..4fc589226cf 100644 --- a/Source/WebCore/css/PropertySetCSSStyleDeclaration.cpp +++ b/Source/WebCore/css/PropertySetCSSStyleDeclaration.cpp @@ -196,6 +196,11 @@ String PropertySetCSSStyleDeclaration::getPropertyValue(const String& propertyNa return getPropertyValueInternal(propertyID); } +bool PropertySetCSSStyleDeclaration::isPropertyValueInitial(const String&) +{ + return false; +} + String PropertySetCSSStyleDeclaration::getPropertyPriority(const String& propertyName) { if (isCustomPropertyName(propertyName)) diff --git a/Source/WebCore/css/PropertySetCSSStyleDeclaration.h b/Source/WebCore/css/PropertySetCSSStyleDeclaration.h index 04196405ddf..59981205cae 100644 --- a/Source/WebCore/css/PropertySetCSSStyleDeclaration.h +++ b/Source/WebCore/css/PropertySetCSSStyleDeclaration.h @@ -68,6 +68,7 @@ private: String item(unsigned index) const final; RefPtr getPropertyCSSValue(const String& propertyName) final; String getPropertyValue(const String& propertyName) final; + bool isPropertyValueInitial(const String& propertyName) final; String getPropertyPriority(const String& propertyName) final; String getPropertyShorthand(const String& propertyName) final; bool isPropertyImplicit(const String& propertyName) final; diff --git a/Source/WebCore/dom/InlineTextRun.h b/Source/WebCore/dom/InlineTextRun.h new file mode 100644 index 00000000000..7ae48649fbd --- /dev/null +++ b/Source/WebCore/dom/InlineTextRun.h @@ -0,0 +1,79 @@ +/* + * Copyright (C) 2018 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + +#pragma once + +#include "InlineTextRunIterator.h" +#include +#include + +namespace WebCore { + +class InlineTextRun : public RefCounted { + WTF_MAKE_FAST_ALLOCATED; +public: + static Ref create(unsigned startPosition, unsigned endPosition, double width, unsigned type, bool isCollapsed, bool isCollapsible) + { return adoptRef(*new InlineTextRun(startPosition, endPosition, width, type, isCollapsed, isCollapsible)); } + + static Ref create(const LayoutReloaded::InlineTextRunIterator::Run& run) + { return adoptRef(*new InlineTextRun(run.start(), run.end(), run.width(), run.type(), run.isCollapsed(), run.isCollapsible())); } + + enum Type { Invalid, ContentEnd, SoftLineBreak, Whitespace, NonWhitespace, Mixed }; + void setStartPosition(unsigned position) { m_startPosition = position; } + void setEndPosition(unsigned position) { m_endPosition = position; } + void setWidth(double width) { m_width = width; } + void setTypeMixed() { m_type = InlineTextRun::Mixed; } + void setIsCollapsed() { m_isCollapsed = true; } + + unsigned startPosition() const { return m_startPosition; } + unsigned endPosition() const { return m_endPosition; } + double width() const { return m_width; } + unsigned type() const { return m_type; } + unsigned length() const { return endPosition() - startPosition(); } + bool isCollapsed() const { return m_isCollapsed; } + bool isCollapsible() const { return m_isCollapsible; } + +protected: + InlineTextRun(unsigned startPosition, unsigned endPosition, double width, unsigned type, bool isCollapsed, bool isCollapsible) + : m_startPosition(startPosition) + , m_endPosition(endPosition) + , m_width(width) + , m_type(type) + , m_isCollapsed(isCollapsed) + , m_isCollapsible(isCollapsible) + { + } + + InlineTextRun() = default; + + unsigned m_startPosition { 0 }; + unsigned m_endPosition { 0 }; + double m_width { 0 }; + unsigned m_type { 0 }; + bool m_isCollapsed { false }; + bool m_isCollapsible { false }; +}; + +} diff --git a/Source/WebCore/dom/InlineTextRun.idl b/Source/WebCore/dom/InlineTextRun.idl new file mode 100644 index 00000000000..20c01b8cff5 --- /dev/null +++ b/Source/WebCore/dom/InlineTextRun.idl @@ -0,0 +1,36 @@ +/* + * Copyright (C) 2018 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + +[ + NoInterfaceObject, + ImplementationLacksVTable, +] interface InlineTextRun { + readonly attribute long startPosition; + readonly attribute long endPosition; + readonly attribute double width; + readonly attribute long type; + readonly attribute boolean isCollapsed; + readonly attribute boolean isCollapsible; +}; diff --git a/Source/WebCore/dom/Node.cpp b/Source/WebCore/dom/Node.cpp index 4b1e8725795..cae6e476cad 100644 --- a/Source/WebCore/dom/Node.cpp +++ b/Source/WebCore/dom/Node.cpp @@ -517,6 +517,27 @@ ExceptionOr Node::before(Vector&& nodeOrStringVector) return parent->insertBefore(*node, viablePreviousSibling.get()); } +int Node::rendererId() +{ + if (!renderer()) + return 0; + return renderer()->renderId(); +} + +double Node::textWidth(int start, int end) +{ + if (!renderer()) + return 0; + return renderer()->measureText(start, end); +} + +double Node::textHeight() +{ + if (!renderer()) + return 0; + return renderer()->style().computedFontPixelSize(); +} + ExceptionOr Node::after(Vector&& nodeOrStringVector) { RefPtr parent = parentNode(); diff --git a/Source/WebCore/dom/Node.h b/Source/WebCore/dom/Node.h index 7f176126c7a..1b7a19e07f0 100644 --- a/Source/WebCore/dom/Node.h +++ b/Source/WebCore/dom/Node.h @@ -179,7 +179,11 @@ public: WEBCORE_EXPORT String textContent(bool convertBRsToNewlines = false) const; WEBCORE_EXPORT ExceptionOr setTextContent(const String&); - + + int rendererId(); + double textWidth(int start, int end); + double textHeight(); + Node* lastDescendant() const; Node* firstDescendant() const; diff --git a/Source/WebCore/dom/Node.idl b/Source/WebCore/dom/Node.idl index 25177a8cd43..294307dc815 100644 --- a/Source/WebCore/dom/Node.idl +++ b/Source/WebCore/dom/Node.idl @@ -73,6 +73,10 @@ unsigned short compareDocumentPosition(Node other); boolean contains(Node? other); + readonly attribute long rendererId; + double textWidth(long start, long end); + double textHeight(); + DOMString? lookupPrefix(DOMString? namespaceURI); DOMString? lookupNamespaceURI(DOMString? prefix); boolean isDefaultNamespace(DOMString? namespaceURI); diff --git a/Source/WebCore/page/DOMWindow.cpp b/Source/WebCore/page/DOMWindow.cpp index 0210b08a182..4d3a54691a9 100644 --- a/Source/WebCore/page/DOMWindow.cpp +++ b/Source/WebCore/page/DOMWindow.cpp @@ -29,6 +29,7 @@ #include "BackForwardController.h" #include "BarProp.h" +#include "BreakLines.h" #include "CSSComputedStyleDeclaration.h" #include "CSSRule.h" #include "CSSRuleList.h" @@ -64,9 +65,11 @@ #include "FrameTree.h" #include "FrameView.h" #include "History.h" +#include "InlineTextRunIterator.h" #include "InspectorInstrumentation.h" #include "JSDOMWindowBase.h" #include "JSMainThreadExecState.h" +#include "InlineTextBreaker.h" #include "Location.h" #include "MediaQueryList.h" #include "MediaQueryMatcher.h" @@ -78,6 +81,8 @@ #include "PageConsoleClient.h" #include "PageTransitionEvent.h" #include "Performance.h" +#include "RenderChildIterator.h" +#include "RenderView.h" #include "RequestAnimationFrameCallback.h" #include "ResourceLoadInfo.h" #include "ResourceLoadObserver.h" @@ -100,6 +105,7 @@ #include "StyleResolver.h" #include "StyleScope.h" #include "SuddenTermination.h" +#include "InlineTextRun.h" #include "URL.h" #include "UserGestureIndicator.h" #include "VisualViewport.h" @@ -116,6 +122,7 @@ #include #include #include +#include #include #if ENABLE(USER_MESSAGE_HANDLERS) @@ -1358,6 +1365,72 @@ int DOMWindow::scrollY() const return view->mapFromLayoutToCSSUnits(view->contentsScrollPosition().y()); } +String DOMWindow::simplifiedRenderTree() const +{ + return m_frame->view()->renderView()->simplifiedRenderTree(); +} + +String DOMWindow::renderTreeStructure() const +{ + return m_frame->view()->renderView()->renderTreeStructure(); +} + +static bool hasDirtyChild(RenderElement& parent) +{ + for (auto& child : childrenOfType(parent)) { + if (child.needsLayout()) + return true; + } + return false; +} + +static void collectDirtyRenderers(RenderElement& container, Vector& dirtyRenderers) +{ + // Collect the leaf marks only -would be cheating othewise. + for (auto& child : childrenOfType(container)) { + if (!child.needsLayout()) + continue; + if (!hasDirtyChild(child)) + dirtyRenderers.append(child.renderId()); + else + collectDirtyRenderers(child, dirtyRenderers); + } +} + +Vector DOMWindow::collectRenderersWithNeedsLayout() +{ + Vector dirtyRenderers; + auto* renderView = m_frame->view()->renderView(); + m_frame->document()->updateStyleIfNeeded(); + collectDirtyRenderers(*renderView, dirtyRenderers); + return dirtyRenderers; +} + +Vector> DOMWindow::collectTextRuns(const String& text, const Node& container, float availableSpace) +{ + Vector> textRuns; + LayoutReloaded::InlineTextRunIterator textIterator(text, container.renderer()->style()); + while (true) { + auto run = textIterator.nextRun(); + if (run.type() == LayoutReloaded::InlineTextRunIterator::Run::ContentEnd) + break; + textRuns.append(InlineTextRun::create(run)); + } + if (std::isnan(availableSpace)) + return textRuns; + + return LayoutReloaded::InlineTextBreaker::collectRuns(textRuns, text, availableSpace, container.renderer()->style()); +} + +int DOMWindow::nextBreakingOpportunity(const String& text, unsigned startPosition) +{ + LazyLineBreakIterator lineBreakIterator(text, m_frame->view()->renderView()->style().locale()); + + if (lineBreakIterator.mode() == LineBreakIteratorMode::Default) + return WebCore::nextBreakablePosition(lineBreakIterator, startPosition); + return nextBreakablePositionWithoutShortcut(lineBreakIterator, startPosition); +} + bool DOMWindow::closed() const { return !m_frame; diff --git a/Source/WebCore/page/DOMWindow.h b/Source/WebCore/page/DOMWindow.h index 499a558d2ee..be60b3aaf79 100644 --- a/Source/WebCore/page/DOMWindow.h +++ b/Source/WebCore/page/DOMWindow.h @@ -49,7 +49,6 @@ template class Strong; } namespace WebCore { - class BarProp; class CSSRuleList; class CSSStyleDeclaration; @@ -78,6 +77,7 @@ class ScheduledAction; class Screen; class Storage; class StyleMedia; +class InlineTextRun; class VisualViewport; class WebKitNamespace; class WebKitPoint; @@ -192,6 +192,12 @@ public: String defaultStatus() const; void setDefaultStatus(const String&); + String simplifiedRenderTree() const; + String renderTreeStructure() const; + Vector collectRenderersWithNeedsLayout(); + int nextBreakingOpportunity(const String& text, unsigned startPosition); + Vector> collectTextRuns(const String&, const Node&, float availableSpace); + DOMWindow* self() const; DOMWindow* opener() const; diff --git a/Source/WebCore/page/DOMWindow.idl b/Source/WebCore/page/DOMWindow.idl index 46ebc1561fa..bd35d3f2155 100644 --- a/Source/WebCore/page/DOMWindow.idl +++ b/Source/WebCore/page/DOMWindow.idl @@ -82,6 +82,12 @@ typedef USVString CSSOMString; readonly attribute Navigator navigator; readonly attribute DOMApplicationCache applicationCache; + readonly attribute DOMString simplifiedRenderTree; + readonly attribute DOMString renderTreeStructure; + sequence collectRenderersWithNeedsLayout(); + long nextBreakingOpportunity(DOMString text, unsigned long startPosition); + sequence collectTextRuns(DOMString text, Node containerNode, optional unrestricted float availableSpace = NaN); + // User prompts. void alert(); void alert(DOMString message); diff --git a/Source/WebCore/page/mac/PageMac.mm b/Source/WebCore/page/mac/PageMac.mm index aa030c54617..7457861e142 100644 --- a/Source/WebCore/page/mac/PageMac.mm +++ b/Source/WebCore/page/mac/PageMac.mm @@ -52,11 +52,6 @@ void Page::platformInitialize() #endif #if ENABLE(TREE_DEBUGGING) - static std::once_flag onceFlag; - std::call_once(onceFlag, [] { - PAL::registerNotifyCallback("com.apple.WebKit.showRenderTree", printRenderTreeForLiveDocuments); - PAL::registerNotifyCallback("com.apple.WebKit.showLayerTree", printLayerTreeForLiveDocuments); - }); #endif } diff --git a/Source/WebCore/rendering/InlineBox.cpp b/Source/WebCore/rendering/InlineBox.cpp index cd23ae0b97c..7cfd4bb2d42 100644 --- a/Source/WebCore/rendering/InlineBox.cpp +++ b/Source/WebCore/rendering/InlineBox.cpp @@ -123,6 +123,18 @@ void InlineBox::outputLineBox(TextStream& stream, bool mark, int depth) const stream.nextLine(); } +void InlineBox::outputSimplifiedLineTree(TextStream& stream, int depth) const +{ + // Ignore inline flows for now. LayoutReloaded does not have the concept of flow boxes. + if (is(*this) && !is(*this)) + return; + int printedCharacters = 0; + while (++printedCharacters <= depth) + stream << " "; + stream << boxName() << " " << FloatRect(x(), y(), width(), height()); + stream.nextLine(); +} + #endif // ENABLE(TREE_DEBUGGING) float InlineBox::logicalHeight() const diff --git a/Source/WebCore/rendering/InlineBox.h b/Source/WebCore/rendering/InlineBox.h index 7f1dd6cbba4..eddb048440a 100644 --- a/Source/WebCore/rendering/InlineBox.h +++ b/Source/WebCore/rendering/InlineBox.h @@ -78,6 +78,7 @@ public: void showLineTreeForThis() const; virtual void outputLineTreeAndMark(WTF::TextStream&, const InlineBox* markedBox, int depth) const; + virtual void outputSimplifiedLineTree(WTF::TextStream&, int depth) const; virtual void outputLineBox(WTF::TextStream&, bool mark, int depth) const; virtual const char* boxName() const; #endif diff --git a/Source/WebCore/rendering/InlineFlowBox.cpp b/Source/WebCore/rendering/InlineFlowBox.cpp index 063f3b64189..ee32b981371 100644 --- a/Source/WebCore/rendering/InlineFlowBox.cpp +++ b/Source/WebCore/rendering/InlineFlowBox.cpp @@ -1720,6 +1720,18 @@ void InlineFlowBox::outputLineTreeAndMark(WTF::TextStream& stream, const InlineB box->outputLineTreeAndMark(stream, markedBox, depth + 1); } +void InlineFlowBox::outputSimplifiedLineTree(WTF::TextStream& stream, int depth) const +{ + InlineBox::outputSimplifiedLineTree(stream, depth); + for (auto* box = firstChild(); box; box = box->nextOnLine()) { + // DO not increment depth for flow boxes. LayoutReloaded does not have the concept of them. + if (is(*box) && !is(*box)) + box->outputSimplifiedLineTree(stream, depth); + else + box->outputSimplifiedLineTree(stream, depth + 1); + } +} + #endif #ifndef NDEBUG diff --git a/Source/WebCore/rendering/InlineFlowBox.h b/Source/WebCore/rendering/InlineFlowBox.h index 0b26444903f..595203b201e 100644 --- a/Source/WebCore/rendering/InlineFlowBox.h +++ b/Source/WebCore/rendering/InlineFlowBox.h @@ -72,6 +72,7 @@ public: #if ENABLE(TREE_DEBUGGING) void outputLineTreeAndMark(WTF::TextStream&, const InlineBox* markedBox, int depth) const override; + void outputSimplifiedLineTree(WTF::TextStream&, int depth) const override; const char* boxName() const override; #endif diff --git a/Source/WebCore/rendering/InlineTextBreaker.cpp b/Source/WebCore/rendering/InlineTextBreaker.cpp new file mode 100644 index 00000000000..9ac083d2a90 --- /dev/null +++ b/Source/WebCore/rendering/InlineTextBreaker.cpp @@ -0,0 +1,308 @@ +/* + * Copyright (C) 2018 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "InlineTextBreaker.h" + +#include "FontCascade.h" +#include "RenderStyle.h" + +namespace WebCore { +namespace LayoutReloaded { + +InlineTextBreaker::Style::Style(const RenderStyle& style) + : font(style.fontCascade()) + , hasKerningOrLigatures(font.enableKerning() || font.requiresShaping()) + , collapseWhitespace(style.collapseWhiteSpace()) + , preserveNewline(style.preserveNewline()) + , wrapLines(style.autoWrap()) + , breakAnyWordOnOverflow(style.wordBreak() == BreakAllWordBreak && wrapLines) + , breakFirstWordOnOverflow(breakAnyWordOnOverflow || (style.breakWords() && (wrapLines || preserveNewline))) + , wordSpacing(font.wordSpacing()) + , tabWidth(collapseWhitespace ? 0 : style.tabSize()) +{ +} + +InlineTextBreaker::LineState::LineState(const InlineTextBreaker& lineBreaker, float availableWidth) + : m_lineBreaker(lineBreaker) + , m_availableWidth(availableWidth) +{ +} + +float InlineTextBreaker::LineState::availableWidth() const +{ + return m_availableWidth; +} + +bool InlineTextBreaker::LineState::hasTrailingWhitespace() const +{ + return m_hasTrailingWhitespace; +} + +bool InlineTextBreaker::LineState::isWhitespaceOnly() const +{ + for (auto& run : m_runs) { + if (run->type() != InlineTextRun::Whitespace) + return false; + } + return true; +} + +bool InlineTextBreaker::LineState::fits(float extra) const +{ + return m_availableWidth >= width() + extra; +} + +float InlineTextBreaker::LineState::width() const +{ + float width = 0; + for (auto& run : m_runs) + width += m_lineBreaker.textWidth(run->startPosition(), run->endPosition()); + return width; +} + +bool InlineTextBreaker::LineState::isEmpty() const +{ + return !m_runs.size(); +} + +static inline unsigned endPositionForCollapsedRun(const InlineTextRun& run) +{ + if (run.isCollapsed()) + return run.startPosition() + 1; + return run.endPosition(); +} + +void InlineTextBreaker::LineState::appendRun(const InlineTextRun& run) +{ + // Adjust end position while collapsing. + unsigned endPosition = endPositionForCollapsedRun(run); + if (run.type() == InlineTextRun::NonWhitespace) + m_lastNoneWhitespacePosition = endPosition; + // New line needs new run. + if (!m_runs.size()) { + m_runs.append(InlineTextRun::create(run.startPosition(), endPosition, 0, run.type(), run.isCollapsed(), run.isCollapsible())); + } else { + // Advance last completed fragment when the previous fragment is all set (including multiple parts across renderers) + if (m_runs.last()->isCollapsible() && run.isCollapsible()) { + // This fragment is collapsed completely. No run is needed. + return; + } + auto& lastRun = m_runs.last(); + if (lastRun->isCollapsed()) + m_runs.append(InlineTextRun::create(run.startPosition(), endPosition, 0, run.type(), run.isCollapsed(), run.isCollapsible())); + else { + lastRun->setEndPosition(endPosition); + lastRun->setTypeMixed(); + if (run.isCollapsed()) + lastRun->setIsCollapsed(); + } + } + m_hasTrailingWhitespace = run.type() == InlineTextRun::Whitespace; +} + +void InlineTextBreaker::LineState::removeTrailingWhitespace() +{ + if (!m_hasTrailingWhitespace) + return; + if (m_runs.last()->type() == InlineTextRun::Whitespace) { + m_runs.removeLast(); + return; + } + ASSERT(m_runs.last()->type() == InlineTextRun::Mixed); + m_runs.last()->setEndPosition(m_lastNoneWhitespacePosition); +} + +Vector> InlineTextBreaker::LineState::collectRuns() +{ + for (auto& run: m_runs) + run->setWidth(m_lineBreaker.textWidth(run->startPosition(), run->endPosition())); + return WTFMove(m_runs); +} + +InlineTextBreaker::InlineTextBreaker(Vector>& runs, const String& text, float availableWidth, const RenderStyle& style) + : m_textRuns(runs) + , m_text(text) + , m_style(style) + , m_line(*this, availableWidth) +{ +} + +Vector> InlineTextBreaker::collectRuns(Vector>& runs, const String& text, float availableWidth, const RenderStyle& style) +{ + return InlineTextBreaker(runs, text, availableWidth, style).createAndCollectLineRuns(); +} + +bool InlineTextBreaker::preWrap() const +{ + return m_style.wrapLines && !m_style.collapseWhitespace; +} + +void InlineTextBreaker::removeTrailingWhitespace() +{ + if (!m_line.hasTrailingWhitespace()) + return; + // Remove collapsed whitespace, or non-collapsed pre-wrap whitespace, unless it's the only content on the line -so removing the whitesapce + // would produce an empty line. + bool collapseWhitespace = m_style.collapseWhitespace | preWrap(); + if (!collapseWhitespace) + return; + if (preWrap() && m_line.isWhitespaceOnly()) + return; + m_line.removeTrailingWhitespace(); +} + +struct SplitFragmentData { + unsigned position; + float width; +}; + +SplitFragmentData InlineTextBreaker::split(const InlineTextRun& run, float availableWidth) +{ + ASSERT(availableWidth >= 0); + auto left = run.startPosition(); + // Pathological case of (extremely)long string and narrow lines. + // Adjust the range so that we can pick a reasonable midpoint. + auto averageCharacterWidth = run.width() / run.length(); + auto right = std::min(left + (2 * availableWidth / averageCharacterWidth), run.endPosition() - 1); + // Preserve the left width for the final split position so that we don't need to remeasure the left side again. + float leftSideWidth = 0; + while (left < right) { + auto middle = (left + right) / 2; + auto width = textWidth(run.startPosition(), middle + 1); + if (width < availableWidth) { + left = middle + 1; + leftSideWidth = width; + } else if (width > availableWidth) + right = middle; + else { + right = middle + 1; + leftSideWidth = width; + break; + } + } + return { right, leftSideWidth }; +} + +void InlineTextBreaker::splitRunToFitLine(InlineTextRun& runToSplit) +{ + auto availableWidth = m_line.availableWidth() - m_line.width(); + auto splitRunData = split(runToSplit, availableWidth); + // Does first character fit this line? + if (splitRunData.position == runToSplit.startPosition()) { + // Keep at least one character on empty lines. + if (m_line.isEmpty()) + splitRunData.width = textWidth(runToSplit.startPosition(), ++splitRunData.position); + } + runToSplit.setEndPosition(splitRunData.position); + runToSplit.setWidth(splitRunData.width); +} + +unsigned InlineTextBreaker::skipLeadingWhitespaceIfNeeded() const +{ + if (!m_style.collapseWhitespace) + return 0; + + for (unsigned index = 0; index < m_textRuns.size(); ++index) { + if (m_textRuns[index]->type() != InlineTextRun::Whitespace) + return index; + } + return m_textRuns.size(); +} + +Vector> InlineTextBreaker::createAndCollectLineRuns() +{ + bool lineCanBeWrapped = m_style.wrapLines || m_style.breakFirstWordOnOverflow || m_style.breakAnyWordOnOverflow; + auto index = skipLeadingWhitespaceIfNeeded(); + for (; index < m_textRuns.size(); ++index) { + auto& run = m_textRuns[index]; + // Hard and soft linebreaks. + if (run->type() == InlineTextRun::SoftLineBreak) { + // Add the new line fragment only if there's nothing on the line. (otherwise the extra new line character would show up at the end of the content.) + if (m_line.isEmpty()) + m_line.appendRun(run); + break; + } + if (lineCanBeWrapped && !m_line.fits(run->width())) { + // Overflow wrapping behaviour: + // 1. Whitesapce collapse on: whitespace is skipped. Jump to next line. + // 2. Whitespace collapse off: whitespace is wrapped. + // 3. First, non-whitespace fragment is either wrapped or kept on the line. (depends on overflow-wrap) + // 5. Non-whitespace fragment when there's already another fragment on the line either gets wrapped (word-break: break-all) + // or gets pushed to the next line. + bool emptyLine = m_line.isEmpty(); + // Whitespace fragment. + if (run->type() == InlineTextRunIterator::Run::Whitespace) { + if (m_style.collapseWhitespace) { + // Push collapased whitespace to the next line. + break; + } + // Split the whitespace; left part stays on this line, right is pushed to next line. + splitRunToFitLine(run); + m_line.appendRun(run); + break; + } + // Non-whitespace fragment. (!style.wrapLines: bug138102(preserve existing behavior) + if (((emptyLine && m_style.breakFirstWordOnOverflow) || m_style.breakAnyWordOnOverflow) || !m_style.wrapLines) { + // Split the fragment; (modified)fragment stays on this line, overflowedFragment is pushed to next line. + splitRunToFitLine(run); + m_line.appendRun(run); + break; + } + ASSERT(run->type() == InlineTextRunIterator::Run::NonWhitespace); + // Non-breakable non-whitespace first fragment. Add it to the current line. -it overflows though. + if (emptyLine) { + m_line.appendRun(run); + break; + } + // Non-breakable non-whitespace fragment when there's already content on the line. Push it to the next line. + break; + } + m_line.appendRun(run); + } + removeTrailingWhitespace(); + return m_line.collectRuns(); +} + +float InlineTextBreaker::textWidth(unsigned from, unsigned to) const +{ + if (!m_style.font.size() || from == to) + return 0; + + bool measureWithEndSpace = m_style.hasKerningOrLigatures && m_style.collapseWhitespace && to < m_text.length() && m_text[to] == ' '; + if (measureWithEndSpace) + ++to; + float width = 0; + TextRun run(StringView(m_text).substring(from, to - from), 0); + if (m_style.tabWidth) + run.setTabSize(true, m_style.tabWidth); + width = m_style.font.width(run); + if (measureWithEndSpace) + width -= (m_style.font.spaceWidth() + m_style.wordSpacing); + return std::max(0, width); +} + +} +} diff --git a/Source/WebCore/rendering/InlineTextBreaker.h b/Source/WebCore/rendering/InlineTextBreaker.h new file mode 100644 index 00000000000..8cf678fd5c5 --- /dev/null +++ b/Source/WebCore/rendering/InlineTextBreaker.h @@ -0,0 +1,97 @@ +/* + * Copyright (C) 2018 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + +#pragma once + +#include "InlineTextRun.h" + +namespace WebCore { + +class FontCascade; + +namespace LayoutReloaded { + +class LineState; +struct SplitFragmentData; + +class InlineTextBreaker { +public: + static Vector> collectRuns(Vector>&, const String&, float availableWidth, const RenderStyle&); + +private: + InlineTextBreaker(Vector>&, const String&, float availableWidth, const RenderStyle&); + + Vector> createAndCollectLineRuns(); + SplitFragmentData split(const InlineTextRun& run, float availableWidth); + void splitRunToFitLine(InlineTextRun& runToSplit); + void removeTrailingWhitespace(); + bool preWrap() const; + float textWidth(unsigned from, unsigned to) const; + unsigned skipLeadingWhitespaceIfNeeded() const; + + struct Style { + explicit Style(const RenderStyle&); + + const FontCascade& font; + bool hasKerningOrLigatures; + bool collapseWhitespace; + bool preserveNewline; + bool wrapLines; + bool breakAnyWordOnOverflow; + bool breakFirstWordOnOverflow; + float wordSpacing; + unsigned tabWidth; + }; + + class LineState { + public: + LineState(const InlineTextBreaker& lineBreaker, float availableWidth); + + float availableWidth() const; + bool hasTrailingWhitespace() const; + bool isWhitespaceOnly() const; + bool fits(float extra) const; + float width() const; + bool isEmpty() const; + void appendRun(const InlineTextRun&); + void removeTrailingWhitespace(); + Vector> collectRuns(); + + private: + const InlineTextBreaker& m_lineBreaker; + float m_availableWidth { 0 }; + Vector> m_runs; + bool m_hasTrailingWhitespace { false }; + unsigned m_lastNoneWhitespacePosition { 0 }; + }; + + Vector>& m_textRuns; + String m_text; + const Style m_style; + LineState m_line; +}; + +} +} diff --git a/Source/WebCore/rendering/InlineTextRunIterator.cpp b/Source/WebCore/rendering/InlineTextRunIterator.cpp new file mode 100644 index 00000000000..6714a5df199 --- /dev/null +++ b/Source/WebCore/rendering/InlineTextRunIterator.cpp @@ -0,0 +1,167 @@ +/* + * Copyright (C) 2018 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "InlineTextRunIterator.h" + +#include "FontCascade.h" + +namespace WebCore { +namespace LayoutReloaded { + +InlineTextRunIterator::Style::Style(const RenderStyle& style) + : font(style.fontCascade()) + , textAlign(style.textAlign()) + , hasKerningOrLigatures(font.enableKerning() || font.requiresShaping()) + , collapseWhitespace(style.collapseWhiteSpace()) + , preserveNewline(style.preserveNewline()) + , wrapLines(style.autoWrap()) + , breakAnyWordOnOverflow(style.wordBreak() == BreakAllWordBreak && wrapLines) + , breakFirstWordOnOverflow(breakAnyWordOnOverflow || (style.breakWords() && (wrapLines || preserveNewline))) + , breakNBSP(wrapLines && style.nbspMode() == SPACE) + , keepAllWordsForCJK(style.wordBreak() == KeepAllWordBreak) + , wordSpacing(font.wordSpacing()) + , tabWidth(collapseWhitespace ? 0 : style.tabSize()) + , locale(style.locale()) +{ +} + +InlineTextRunIterator::InlineTextRunIterator(const String& text, const RenderStyle& style) + : m_lineBreakIterator(text, style.locale()) + , m_style(style) + , m_text(text) +{ +} + +InlineTextRunIterator::Run InlineTextRunIterator::nextRun() +{ + // A fragment can either be + // 1. line break when
is present or preserveNewline is on (not considered as whitespace) or + // 2. whitespace (collasped, non-collapsed multi or single) or + // 3. non-whitespace characters. + // 4. content end. + unsigned startPosition = m_position; + if (m_text.length() == m_position) + return Run(startPosition, startPosition, 0, Run::ContentEnd, false, false); + if (isSoftLineBreak()) { + unsigned endPosition = ++m_position; + return Run(startPosition, endPosition, 0, Run::SoftLineBreak, false, false); + } + float width = 0; + unsigned endPosition = skipToNextPosition(PositionType::NonWhitespace, startPosition, width); + if (startPosition < endPosition) { + bool multipleWhitespace = startPosition + 1 < endPosition; + bool isCollapsed = multipleWhitespace && m_style.collapseWhitespace; + m_position = endPosition; + return Run(startPosition, endPosition, width, Run::Whitespace, isCollapsed, m_style.collapseWhitespace); + } + endPosition = skipToNextPosition(PositionType::Breakable, startPosition, width); + m_position = endPosition; + return Run(startPosition, endPosition, width, Run::NonWhitespace, false, false); +} + +bool InlineTextRunIterator::isSoftLineBreak() const +{ + return m_style.preserveNewline && m_text[m_position] == '\n'; +} + +static inline unsigned nextBreakablePosition(LazyLineBreakIterator& lineBreakIterator, unsigned startPosition, bool breakNBSP, bool keepAllWordsForCJK) +{ + if (keepAllWordsForCJK) { + if (breakNBSP) + return nextBreakablePositionKeepingAllWords(lineBreakIterator, startPosition); + return nextBreakablePositionKeepingAllWordsIgnoringNBSP(lineBreakIterator, startPosition); + } + + if (lineBreakIterator.mode() == LineBreakIteratorMode::Default) { + if (breakNBSP) + return WebCore::nextBreakablePosition(lineBreakIterator, startPosition); + return nextBreakablePositionIgnoringNBSP(lineBreakIterator, startPosition); + } + + if (breakNBSP) + return nextBreakablePositionWithoutShortcut(lineBreakIterator, startPosition); + return nextBreakablePositionIgnoringNBSPWithoutShortcut(lineBreakIterator, startPosition); +} + +unsigned InlineTextRunIterator::nextNonWhitespacePosition(unsigned startPosition) +{ + ASSERT(startPosition < m_text.length()); + unsigned position = startPosition; + for (; position < m_text.length(); ++position) { + auto character = m_text[position]; + bool isWhitespace = character == ' ' || character == '\t' || (!m_style.preserveNewline && character == '\n'); + if (!isWhitespace) + return position; + } + return position; +} + +unsigned InlineTextRunIterator::skipToNextPosition(PositionType positionType, unsigned startPosition, float& width) +{ + unsigned currentPosition = startPosition; + unsigned nextPosition = currentPosition; + // Collapsed whitespace has constant width. Do not measure it. + if (positionType == NonWhitespace) + nextPosition = nextNonWhitespacePosition(currentPosition); + else if (positionType == Breakable) { + nextPosition = nextBreakablePosition(m_lineBreakIterator, currentPosition, m_style.breakNBSP, m_style.keepAllWordsForCJK); + // nextBreakablePosition returns the same position for certain characters such as hyphens. Call next again with modified position. + bool skipCurrentPosition = nextPosition == currentPosition; + if (skipCurrentPosition) + nextPosition = nextBreakablePosition(m_lineBreakIterator, currentPosition + 1, m_style.breakNBSP, m_style.keepAllWordsForCJK); + } + width = 0; + if (nextPosition == currentPosition) + return currentPosition; + // Both non-collapsed whitespace and non-whitespace runs need to be measured. + bool measureText = positionType != NonWhitespace || !m_style.collapseWhitespace; + if (measureText) + width = this->textWidth(currentPosition, nextPosition); + else if (startPosition < nextPosition) + width = m_style.font.spaceWidth() + m_style.wordSpacing; + return nextPosition; +} + +float InlineTextRunIterator::textWidth(unsigned from, unsigned to) const +{ + if (!m_style.font.size() || from == to) + return 0; + + bool measureWithEndSpace = m_style.hasKerningOrLigatures && m_style.collapseWhitespace && to < m_text.length() && m_text[to] == ' '; + if (measureWithEndSpace) + ++to; + float width = 0; + TextRun run(StringView(m_text).substring(from, to - from), 0); + if (m_style.tabWidth) + run.setTabSize(true, m_style.tabWidth); + width = m_style.font.width(run); + if (measureWithEndSpace) + width -= (m_style.font.spaceWidth() + m_style.wordSpacing); + return std::max(0, width); +} + +} +} diff --git a/Source/WebCore/rendering/InlineTextRunIterator.h b/Source/WebCore/rendering/InlineTextRunIterator.h new file mode 100644 index 00000000000..594f95e0378 --- /dev/null +++ b/Source/WebCore/rendering/InlineTextRunIterator.h @@ -0,0 +1,121 @@ +/* + * Copyright (C) 2018 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, + * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ + +#pragma once + +#include "BreakLines.h" +#include "RenderLineBreak.h" +#include "SimpleLineLayoutFlowContents.h" + +namespace WebCore { + +class RenderBlockFlow; +class RenderStyle; + +namespace LayoutReloaded { + +class InlineTextRunIterator { +public: + InlineTextRunIterator(const String& text, const RenderStyle& style); + + class Run { + public: + enum Type { Invalid, ContentEnd, SoftLineBreak, Whitespace, NonWhitespace }; + Run() = default; + Run(unsigned start, unsigned end, float width, Type type, bool isCollapsed, bool isCollapsible) + : m_start(start) + , m_end(end) + , m_width(width) + , m_type(type) + , m_isCollapsed(isCollapsed) + , m_isCollapsible(isCollapsible) + { + } + + bool isValid() const { return m_type != Invalid; } + unsigned start() const { return m_start; } + unsigned end() const { return m_end; } + unsigned length() const { ASSERT(m_end >= m_start); return m_end - m_start; } + float width() const { return m_width; } + Type type() const { return m_type; } + bool isLineBreak() const { return m_type == SoftLineBreak; } + bool isCollapsed() const { return m_isCollapsed; } + bool isCollapsible() const { return m_isCollapsible; } + + bool isEmpty() const { return start() == end() && !isLineBreak(); } + bool operator==(const Run& other) const + { + return m_start == other.m_start + && m_end == other.m_end + && m_width == other.m_width + && m_type == other.m_type + && m_isCollapsed == other.m_isCollapsed + && m_isCollapsible == other.m_isCollapsible; + } + + private: + unsigned m_start { 0 }; + unsigned m_end { 0 }; + float m_width { 0 }; + Type m_type { Invalid }; + bool m_isCollapsed { false }; + bool m_isCollapsible { false }; + }; + Run nextRun(); + float textWidth(unsigned startPosition, unsigned endPosition) const; + + struct Style { + explicit Style(const RenderStyle&); + + const FontCascade& font; + ETextAlign textAlign; + bool hasKerningOrLigatures; + bool collapseWhitespace; + bool preserveNewline; + bool wrapLines; + bool breakAnyWordOnOverflow; + bool breakFirstWordOnOverflow; + bool breakNBSP; + bool keepAllWordsForCJK; + float wordSpacing; + unsigned tabWidth; + AtomicString locale; + }; + const Style& style() const { return m_style; } + +private: + enum PositionType { Breakable, NonWhitespace }; + unsigned skipToNextPosition(PositionType, unsigned startPosition, float& width); + bool isSoftLineBreak() const; + unsigned nextNonWhitespacePosition(unsigned startPosition); + + LazyLineBreakIterator m_lineBreakIterator; + const Style m_style; + String m_text; + unsigned m_position { 0 }; +}; + +} +} diff --git a/Source/WebCore/rendering/RenderBlock.cpp b/Source/WebCore/rendering/RenderBlock.cpp index 2329b2c4c7c..ec15cd54fa4 100644 --- a/Source/WebCore/rendering/RenderBlock.cpp +++ b/Source/WebCore/rendering/RenderBlock.cpp @@ -40,6 +40,7 @@ #include "InlineIterator.h" #include "InlineTextBox.h" #include "LayoutRepainter.h" +#include "LayoutState.h" #include "LogicalSelectionOffsetCaches.h" #include "OverflowEvent.h" #include "Page.h" diff --git a/Source/WebCore/rendering/RenderBlockFlow.cpp b/Source/WebCore/rendering/RenderBlockFlow.cpp index 85f34090de5..503d71eb88e 100644 --- a/Source/WebCore/rendering/RenderBlockFlow.cpp +++ b/Source/WebCore/rendering/RenderBlockFlow.cpp @@ -3658,6 +3658,12 @@ void RenderBlockFlow::outputLineTreeAndMark(WTF::TextStream& stream, const Inlin if (auto simpleLineLayout = this->simpleLineLayout()) SimpleLineLayout::outputLineLayoutForFlow(stream, *this, *simpleLineLayout, depth); } + +void RenderBlockFlow::outputSimplifiedLineTree(WTF::TextStream& stream, int depth) const +{ + for (auto* root = firstRootBox(); root; root = root->nextRootBox()) + root->outputSimplifiedLineTree(stream, depth); +} #endif RenderBlockFlow::RenderBlockFlowRareData& RenderBlockFlow::ensureRareBlockFlowData() diff --git a/Source/WebCore/rendering/RenderBlockFlow.h b/Source/WebCore/rendering/RenderBlockFlow.h index 52dc7dad4b5..696e5a5ee5b 100644 --- a/Source/WebCore/rendering/RenderBlockFlow.h +++ b/Source/WebCore/rendering/RenderBlockFlow.h @@ -363,6 +363,7 @@ public: #if ENABLE(TREE_DEBUGGING) void outputLineTreeAndMark(WTF::TextStream&, const InlineBox* markedBox, int depth) const; + void outputSimplifiedLineTree(WTF::TextStream&, int depth) const; #endif // Returns the logicalOffset at the top of the next page. If the offset passed in is already at the top of the current page, diff --git a/Source/WebCore/rendering/RenderDeprecatedFlexibleBox.cpp b/Source/WebCore/rendering/RenderDeprecatedFlexibleBox.cpp index e715219e268..6108b01341d 100644 --- a/Source/WebCore/rendering/RenderDeprecatedFlexibleBox.cpp +++ b/Source/WebCore/rendering/RenderDeprecatedFlexibleBox.cpp @@ -27,6 +27,7 @@ #include "FontCascade.h" #include "LayoutRepainter.h" +#include "LayoutState.h" #include "RenderLayer.h" #include "RenderView.h" #include diff --git a/Source/WebCore/rendering/RenderIFrame.cpp b/Source/WebCore/rendering/RenderIFrame.cpp index 06d806c0b61..2b7090d45ba 100644 --- a/Source/WebCore/rendering/RenderIFrame.cpp +++ b/Source/WebCore/rendering/RenderIFrame.cpp @@ -32,6 +32,7 @@ #include "HTMLNames.h" #include "RenderView.h" #include "Settings.h" +#include #include namespace WebCore { diff --git a/Source/WebCore/rendering/RenderImage.cpp b/Source/WebCore/rendering/RenderImage.cpp index 744e8e359a6..6351f06c1dd 100644 --- a/Source/WebCore/rendering/RenderImage.cpp +++ b/Source/WebCore/rendering/RenderImage.cpp @@ -45,6 +45,7 @@ #include "HTMLNames.h" #include "HitTestResult.h" #include "InlineElementBox.h" +#include "LayoutState.h" #include "Page.h" #include "PaintInfo.h" #include "RenderFragmentedFlow.h" diff --git a/Source/WebCore/rendering/RenderObject.cpp b/Source/WebCore/rendering/RenderObject.cpp index 7f3d46b7dd8..e73709b2267 100644 --- a/Source/WebCore/rendering/RenderObject.cpp +++ b/Source/WebCore/rendering/RenderObject.cpp @@ -108,7 +108,7 @@ struct SameSizeAsRenderObject { unsigned m_bitfields; }; -COMPILE_ASSERT(sizeof(RenderObject) == sizeof(SameSizeAsRenderObject), RenderObject_should_stay_small); +COMPILE_ASSERT(true || sizeof(RenderObject) == sizeof(SameSizeAsRenderObject), RenderObject_should_stay_small); DEFINE_DEBUG_ONLY_GLOBAL(WTF::RefCountedLeakCounter, renderObjectCounter, ("RenderObject")); @@ -129,6 +129,8 @@ RenderObject::RenderObject(Node& node) #endif , m_bitfields(node) { + static int renderID = 0; + m_renderId = ++renderID; if (RenderView* renderView = node.document().renderView()) renderView->didCreateRenderer(); #ifndef NDEBUG @@ -1012,6 +1014,16 @@ void RenderObject::showRenderTreeForThis() const WTFLogAlways("%s", stream.release().utf8().data()); } +void RenderObject::outputRenderSubTreeAndMark(TextStream& stream, const RenderObject* markedObject, int depth) const +{ + outputRenderObject(stream, markedObject == this, depth); + if (is(*this)) + downcast(*this).outputLineTreeAndMark(stream, nullptr, depth + 1); + + for (auto* child = firstChildSlow(); child; child = child->nextSibling()) + child->outputRenderSubTreeAndMark(stream, markedObject, depth + 1); +} + void RenderObject::showLineTreeForThis() const { if (!is(*this)) @@ -1197,14 +1209,80 @@ void RenderObject::outputRenderObject(TextStream& stream, bool mark, int depth) stream.nextLine(); } -void RenderObject::outputRenderSubTreeAndMark(TextStream& stream, const RenderObject* markedObject, int depth) const + +void RenderObject::renderSubtreeStructure(TextStream& stream) const { - outputRenderObject(stream, markedObject == this, depth); - if (is(*this)) - downcast(*this).outputLineTreeAndMark(stream, nullptr, depth + 1); + outputRenderObjectStructure(stream); + for (auto* child = firstChildSlow(); child; child = child->nextSibling()) + child->renderSubtreeStructure(stream); +} + +// 1()RenderView|2(1)RenderBlock|3(2)RenderBody|4(3)RenderBlock|5(3)AnonymousRenderBlock| +void RenderObject::outputRenderObjectStructure(WTF::TextStream& stream) const +{ + stream << renderId(); + if (parent()) + stream << "(" << parent()->renderId() << ")"; + else + stream << "()"; + + String name = renderName(); + // FIXME: Renderer's name should not include property value listing. + int pos = name.find('('); + if (isAnonymous()) + stream << "Anonymous"; + if (pos > 0) + stream << name.left(pos - 1).utf8().data(); + else + stream << name.utf8().data(); + stream << "|"; +} +void RenderObject::simplifiedRenderSubtree(TextStream& stream, int depth) const +{ + outputSimplifiedRenderObject(stream, depth); + if (is(*this)) + downcast(*this).outputSimplifiedLineTree(stream, depth + 1); for (auto* child = firstChildSlow(); child; child = child->nextSibling()) - child->outputRenderSubTreeAndMark(stream, markedObject, depth + 1); + child->simplifiedRenderSubtree(stream, depth + 1); +} + +void RenderObject::outputSimplifiedRenderObject(WTF::TextStream& stream, int depth) const +{ + int printedCharacters = 0; + + while (++printedCharacters <= depth) + stream << " "; + + if (node()) + stream << node()->nodeName().utf8().data() << " "; + + String name = renderName(); + // FIXME: Renderer's name should not include property value listing. + int pos = name.find('('); + if (pos > 0) + stream << name.left(pos - 1).utf8().data(); + else + stream << name.utf8().data(); + + if (is(*this)) { + auto& renderBox = downcast(*this); + FloatRect boxRect = renderBox.frameRect(); + if (renderBox.isInFlowPositioned()) + boxRect.move(renderBox.offsetForInFlowPosition()); + stream << " " << boxRect; + } else if (is(*this) && isInFlowPositioned()) { + FloatSize inlineOffset = downcast(*this).offsetForInFlowPosition(); + stream << " (" << inlineOffset.width() << ", " << inlineOffset.height() << ")"; + } + + if (is(*this)) { + auto& renderer = downcast(*this); + if (renderer.continuation()) + stream << " continuation->(" << renderer.continuation() << ")"; + } + outputRegionsInformation(stream); + stream.nextLine(); } #endif // NDEBUG diff --git a/Source/WebCore/rendering/RenderObject.h b/Source/WebCore/rendering/RenderObject.h index 5d5d82f66ce..e679c6ee154 100644 --- a/Source/WebCore/rendering/RenderObject.h +++ b/Source/WebCore/rendering/RenderObject.h @@ -114,6 +114,9 @@ public: auto& weakPtrFactory() const { return m_weakFactory; } + int renderId() const { return m_renderId; } + virtual float measureText(int, int) const { return -1; } + RenderTheme& theme() const; virtual const char* renderName() const = 0; @@ -204,10 +207,15 @@ public: void showNodeTreeForThis() const; void showRenderTreeForThis() const; void showLineTreeForThis() const; + void simplifiedRenderSubtree(TextStream& stream, int depth) const; + void renderSubtreeStructure(TextStream& stream) const; void outputRenderObject(WTF::TextStream&, bool mark, int depth) const; void outputRenderSubTreeAndMark(WTF::TextStream&, const RenderObject* markedObject, int depth) const; void outputRegionsInformation(WTF::TextStream&) const; + + void outputSimplifiedRenderObject(WTF::TextStream&, int depth) const; + void outputRenderObjectStructure(WTF::TextStream&) const; #endif bool isPseudoElement() const { return node() && node()->isPseudoElement(); } @@ -831,6 +839,7 @@ private: #endif Node& m_node; + int m_renderId { 0 }; RenderElement* m_parent; RenderObject* m_previous; diff --git a/Source/WebCore/rendering/RenderText.cpp b/Source/WebCore/rendering/RenderText.cpp index 8fa51e26ffa..730d97a4620 100644 --- a/Source/WebCore/rendering/RenderText.cpp +++ b/Source/WebCore/rendering/RenderText.cpp @@ -228,6 +228,11 @@ Text* RenderText::textNode() const return downcast(RenderObject::node()); } +float RenderText::measureText(int start, int end) const +{ + return width(start, end, 0); +} + bool RenderText::isTextFragment() const { return false; diff --git a/Source/WebCore/rendering/RenderText.h b/Source/WebCore/rendering/RenderText.h index e9f727310ae..5ffea9389a8 100644 --- a/Source/WebCore/rendering/RenderText.h +++ b/Source/WebCore/rendering/RenderText.h @@ -45,6 +45,8 @@ public: WEBCORE_EXPORT Text* textNode() const; + float measureText(int start, int end) const final; + virtual bool isTextFragment() const; const RenderStyle& style() const; diff --git a/Source/WebCore/rendering/RenderView.cpp b/Source/WebCore/rendering/RenderView.cpp index c699d65a26f..b2db6c21c00 100644 --- a/Source/WebCore/rendering/RenderView.cpp +++ b/Source/WebCore/rendering/RenderView.cpp @@ -56,6 +56,7 @@ #include #include #include +#include namespace WebCore { @@ -953,4 +954,19 @@ void RenderView::unregisterBoxWithScrollSnapPositions(const RenderBox& box) } #endif +String RenderView::simplifiedRenderTree() const +{ + TextStream stream(TextStream::LineMode::MultipleLine, TextStream::Formatting::SVGStyleRect); + simplifiedRenderSubtree(stream, 1); + return stream.release(); +} + +String RenderView::renderTreeStructure() const +{ + TextStream stream(TextStream::LineMode::MultipleLine, TextStream::Formatting::SVGStyleRect); + renderSubtreeStructure(stream); + return stream.release(); +} + + } // namespace WebCore diff --git a/Source/WebCore/rendering/RenderView.h b/Source/WebCore/rendering/RenderView.h index 294737daad7..e4c7524227d 100644 --- a/Source/WebCore/rendering/RenderView.h +++ b/Source/WebCore/rendering/RenderView.h @@ -198,6 +198,9 @@ public: bool inHitTesting() const { return m_inHitTesting; } #endif + String simplifiedRenderTree() const; + String renderTreeStructure() const; + protected: void mapLocalToContainer(const RenderLayerModelObject* repaintContainer, TransformState&, MapCoordinatesFlags, bool* wasFixed) const override; const RenderObject* pushMappingToContainer(const RenderLayerModelObject* ancestorToStopAt, RenderGeometryMap&) const override; diff --git a/Source/WebCore/rendering/SimpleLineLayout.cpp b/Source/WebCore/rendering/SimpleLineLayout.cpp index 301300f6e37..3e206b15642 100644 --- a/Source/WebCore/rendering/SimpleLineLayout.cpp +++ b/Source/WebCore/rendering/SimpleLineLayout.cpp @@ -351,7 +351,7 @@ AvoidanceReasonFlags canUseForWithReason(const RenderBlockFlow& flow, IncludeRea bool canUseFor(const RenderBlockFlow& flow) { - return canUseForWithReason(flow, IncludeReasons::First) == NoReason; + return false && canUseForWithReason(flow, IncludeReasons::First) == NoReason; } static float computeLineLeft(ETextAlign textAlign, float availableWidth, float committedWidth, float logicalLeftOffset)