Add StyledMarkupSerializerTest.ShadowTreeStyle

Source/core/editing/StyledMarkupSerializerTest.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "core/editing/StyledMarkupSerializer.h"
 
 #include "bindings/core/v8/ExceptionStatePlaceholder.h"
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
 #include "core/dom/Node.h"
 #include "core/dom/Range.h"
+#include "core/dom/Text.h"
 #include "core/dom/shadow/ShadowRoot.h"
 #include "core/editing/markup.h"
 #include "core/frame/FrameView.h"
 #include "core/html/HTMLDocument.h"
 #include "core/html/HTMLElement.h"
 #include "core/testing/DummyPageHolder.h"
 #include "platform/geometry/IntSize.h"
 #include "wtf/Compiler.h"
 #include "wtf/OwnPtr.h"
 #include "wtf/PassRefPtr.h"
 #include "wtf/RefPtr.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/testing/WTFTestHelpers.h"
 #include <gtest/gtest.h>
 #include <string>
 
 namespace blink {
 
 // This is smoke test of |StyledMarkupSerializer|. Full testing will be done
 // in layout tests.
 class StyledMarkupSerializerTest : public ::testing::Test {
 protected:
     void SetUp() override;
 
     HTMLDocument& document() const { return *m_document; }
 
     template <typename Tree>
-    std::string serialize();
+    std::string serialize(EAnnotateForInterchange = DoNotAnnotateForInterchange);
+
+    template <typename Tree>
+    std::string serializePart(const typename Tree::PositionType& start, const typename Tree::PositionType& end, EAnnotateForInterchange = DoNotAnnotateForInterchange);
 
     void setBodyContent(const char*);
     PassRefPtrWillBeRawPtr<ShadowRoot> setShadowContent(const char*);
 
 private:
     OwnPtr<DummyPageHolder> m_dummyPageHolder;
     HTMLDocument* m_document;
 };
 
 void StyledMarkupSerializerTest::SetUp()
 {
     m_dummyPageHolder = DummyPageHolder::create(IntSize(800, 600));
     m_document = toHTMLDocument(&m_dummyPageHolder->document());
     ASSERT(m_document);
 }
 
 template <typename Tree>
-std::string StyledMarkupSerializerTest::serialize()
+std::string StyledMarkupSerializerTest::serialize(EAnnotateForInterchange shouldAnnotate)
 {
     using PositionType = typename Tree::PositionType;
     PositionType start = PositionType(m_document->body(), PositionType::PositionIsBeforeChildren);
     PositionType end = PositionType(m_document->body(), PositionType::PositionIsAfterChildren);
-    return createMarkup(start, end).utf8().data();
+    return createMarkup(start, end, shouldAnnotate).utf8().data();
+}
+
+template <typename Tree>
+std::string StyledMarkupSerializerTest::serializePart(const typename Tree::PositionType& start, const typename Tree::PositionType& end, EAnnotateForInterchange shouldAnnotate)
+{
+    return createMarkup(start, end, shouldAnnotate).utf8().data();
 }
 
 static PassRefPtrWillBeRawPtr<ShadowRoot> createShadowRootForElementWithIDAndSetInnerHTML(TreeScope& scope, const char* hostElementID, const char* shadowRootContent)
 {
     RefPtrWillBeRawPtr<ShadowRoot> shadowRoot = scope.getElementById(AtomicString::fromUTF8(hostElementID))->createShadowRoot(ASSERT_NO_EXCEPTION);
     shadowRoot->setInnerHTML(String::fromUTF8(shadowRootContent), ASSERT_NO_EXCEPTION);
     return shadowRoot.release();
 }
 
 void StyledMarkupSerializerTest::setBodyContent(const char* bodyContent)
 {
     document().body()->setInnerHTML(String::fromUTF8(bodyContent), ASSERT_NO_EXCEPTION);
 }
 
 PassRefPtrWillBeRawPtr<ShadowRoot> StyledMarkupSerializerTest::setShadowContent(const char* shadowContent)
 {
-    return createShadowRootForElementWithIDAndSetInnerHTML(document(), "host", shadowContent);
+    RefPtrWillBeRawPtr<ShadowRoot> shadowRoot = createShadowRootForElementWithIDAndSetInnerHTML(document(), "host", shadowContent);
+    document().recalcDistribution();
+    return shadowRoot;
 }
 
 TEST_F(StyledMarkupSerializerTest, TextOnly)
 {
     const char* bodyContent = "Hello world!";
     setBodyContent(bodyContent);
     const char* expectedResult = "<span style=\"display: inline !important; float: none;\">Hello world!</span>";
     EXPECT_EQ(expectedResult, serialize<EditingStrategy>());
     EXPECT_EQ(expectedResult, serialize<EditingInComposedTreeStrategy>());
 }
@@ skipping 115 matching lines @@
 }
 
 TEST_F(StyledMarkupSerializerTest, StyleDisplayNoneAndNewLines)
 {
     const char* bodyContent = "<div style='display:none'>11</div>\n\n";
     setBodyContent(bodyContent);
     EXPECT_EQ("", serialize<EditingStrategy>());
     EXPECT_EQ("", serialize<EditingInComposedTreeStrategy>());
 }
 
+TEST_F(StyledMarkupSerializerTest, ShadowTreeStyle)
+{
+    const char* bodyContent = "<p id='host' style='color: red'><span style='font-weight: bold;'><span id='one'>11</span></span></p>\n";
+    setBodyContent(bodyContent);
+    RefPtrWillBeRawPtr<Element> one = document().getElementById("one");
+    RefPtrWillBeRawPtr<Text> text = toText(one->firstChild());
+    Position startDOM(text, 0);
+    Position endDOM(text, 2);
+    const std::string& serializedDOM = serializePart<EditingStrategy>(startDOM, endDOM, AnnotateForInterchange);
+
+    bodyContent = "<p id='host' style='color: red'>00<span id='one'>11</span>22</p>\n";
+    const char* shadowContent = "<span style='font-weight: bold'><content select=#one></content></span>";
+    setBodyContent(bodyContent);
+    setShadowContent(shadowContent);
+    one = document().getElementById("one");
+    text = toText(one->firstChild());
+    PositionInComposedTree startICT(text, 0);
+    PositionInComposedTree endICT(text, 2);
+    const std::string& serializedICT = serializePart<EditingInComposedTreeStrategy>(startICT, endICT, AnnotateForInterchange);
+
+    EXPECT_EQ(serializedDOM, serializedICT);
+}
+
 } // namespace blink