Use EditingTestBase for StyledMarkupSerializerTest

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>
+#include "core/editing/EditingTestBase.h"
 
 namespace blink {
 
 // This is smoke test of |StyledMarkupSerializer|. Full testing will be done
 // in layout tests.
-class StyledMarkupSerializerTest : public ::testing::Test {
+class StyledMarkupSerializerTest : public EditingTestBase {
 protected:
-    void SetUp() override;
-
-    HTMLDocument& document() const { return *m_document; }
-
     template <typename Tree>
     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(EAnnotateForInterchange shouldAnnotate)
 {
     using PositionType = typename Tree::PositionType;
-    PositionType start = PositionType(m_document->body(), PositionType::PositionIsBeforeChildren);
-    PositionType end = PositionType(m_document->body(), PositionType::PositionIsAfterChildren);
+    PositionType start = PositionType(document().body(), PositionType::PositionIsBeforeChildren);
+    PositionType end = PositionType(document().body(), PositionType::PositionIsAfterChildren);
     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)
-{
-    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>());
 }
 
 TEST_F(StyledMarkupSerializerTest, BlockFormatting)
@@ skipping 137 matching lines @@
     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