Oilpan: Remove most WillBe types from the code base

third_party/WebKit/Source/core/editing/GranularityStrategyTest.cpp

 // Copyright 2014 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 "bindings/core/v8/ExceptionStatePlaceholder.h"
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
 #include "core/dom/Text.h"
 #include "core/editing/FrameSelection.h"
 #include "core/frame/FrameView.h"
@@ skipping 16 matching lines @@
 
 IntPoint visiblePositionToContentsPoint(const VisiblePosition& pos)
 {
     IntPoint result = absoluteCaretBoundsOf(pos).minXMaxYCorner();
     // Need to move the point at least by 1 - caret's minXMaxYCorner is not
     // evaluated to the same line as the text by hit testing.
     result.move(0, -1);
     return result;
 }
 
-using TextNodeVector = WillBeHeapVector<RefPtrWillBeMember<Text>>;
+using TextNodeVector = HeapVector<Member<Text>>;
 
 class GranularityStrategyTest : public ::testing::Test {
 protected:
     void SetUp() override;
 
     DummyPageHolder& dummyPageHolder() const { return *m_dummyPageHolder; }
     HTMLDocument& document() const;
     void setSelection(const VisibleSelection&);
     FrameSelection& selection() const;
-    PassRefPtrWillBeRawPtr<Text> appendTextNode(const String& data);
+    RawPtr<Text> appendTextNode(const String& data);
     int layoutCount() const { return m_dummyPageHolder->frameView().layoutCount(); }
     void setInnerHTML(const char*);
     // Parses the text node, appending the info to m_letterPos and m_wordMiddles.
     void parseText(Text*);
     void parseText(const TextNodeVector&);
 
-    PassRefPtrWillBeRawPtr<Text> setupTranslateZ(String);
-    PassRefPtrWillBeRawPtr<Text> setupTransform(String);
-    PassRefPtrWillBeRawPtr<Text> setupRotate(String);
+    RawPtr<Text> setupTranslateZ(String);
+    RawPtr<Text> setupTransform(String);
+    RawPtr<Text> setupRotate(String);
     void setupTextSpan(String str1, String str2, String str3, size_t selBegin, size_t selEnd);
     void setupVerticalAlign(String str1, String str2, String str3, size_t selBegin, size_t selEnd);
     void setupFontSize(String str1, String str2, String str3, size_t selBegin, size_t selEnd);
 
     void testDirectionExpand();
     void testDirectionShrink();
     void testDirectionSwitchSide();
 
     // Pixel coordinates of the positions for each letter within the text being tested.
     Vector<IntPoint> m_letterPos;
     // Pixel coordinates of the middles of the words in the text being tested.
     // (y coordinate is based on y coordinates of m_letterPos)
     Vector<IntPoint> m_wordMiddles;
 
 private:
     OwnPtr<DummyPageHolder> m_dummyPageHolder;
-    RawPtrWillBePersistent<HTMLDocument> m_document;
+    Persistent<HTMLDocument> m_document;
 };
 
 void GranularityStrategyTest::SetUp()
 {
     m_dummyPageHolder = DummyPageHolder::create(IntSize(800, 600));
     m_document = toHTMLDocument(&m_dummyPageHolder->document());
     ASSERT(m_document);
     dummyPageHolder().frame().settings()->setDefaultFontSize(12);
     dummyPageHolder().frame().settings()->setSelectionStrategy(SelectionStrategy::Direction);
 }
 
 HTMLDocument& GranularityStrategyTest::document() const
 {
     return *m_document;
 }
 
 void GranularityStrategyTest::setSelection(const VisibleSelection& newSelection)
 {
     m_dummyPageHolder->frame().selection().setSelection(newSelection);
 }
 
 FrameSelection& GranularityStrategyTest::selection() const
 {
     return m_dummyPageHolder->frame().selection();
 }
 
-PassRefPtrWillBeRawPtr<Text> GranularityStrategyTest::appendTextNode(const String& data)
+RawPtr<Text> GranularityStrategyTest::appendTextNode(const String& data)
 {
-    RefPtrWillBeRawPtr<Text> text = document().createTextNode(data);
+    RawPtr<Text> text = document().createTextNode(data);
     document().body()->appendChild(text);
     return text.release();
 }
 
 void GranularityStrategyTest::setInnerHTML(const char* htmlContent)
 {
     document().documentElement()->setInnerHTML(String::fromUTF8(htmlContent), ASSERT_NO_EXCEPTION);
     document().view()->updateAllLifecyclePhases();
 }
 
@@ skipping 25 matching lines @@
         }
     }
     if (wordStarted) {
         const auto& lastNode = textNodes.last();
         int xEnd = visiblePositionToContentsPoint(createVisiblePosition(Position(lastNode, lastNode->wholeText().length()))).x();
         IntPoint wordMiddle((m_letterPos[wordStartIndex].x() + xEnd) / 2, m_letterPos[wordStartIndex].y());
         m_wordMiddles.append(wordMiddle);
     }
 }
 
-PassRefPtrWillBeRawPtr<Text> GranularityStrategyTest::setupTranslateZ(String str)
+RawPtr<Text> GranularityStrategyTest::setupTranslateZ(String str)
 {
     setInnerHTML(
         "<html>"
         "<head>"
         "<style>"
             "div {"
                 "transform: translateZ(0);"
             "}"
         "</style>"
         "</head>"
         "<body>"
         "<div id='mytext'></div>"
         "</body>"
         "</html>");
 
-    RefPtrWillBeRawPtr<Text> text = document().createTextNode(str);
+    RawPtr<Text> text = document().createTextNode(str);
     Element* div = document().getElementById("mytext");
     div->appendChild(text);
 
     document().view()->updateAllLifecyclePhases();
 
     parseText(text.get());
     return text.release();
 }
 
-PassRefPtrWillBeRawPtr<Text> GranularityStrategyTest::setupTransform(String str)
+RawPtr<Text> GranularityStrategyTest::setupTransform(String str)
 {
     setInnerHTML(
         "<html>"
         "<head>"
         "<style>"
             "div {"
                 "transform: scale(1,-1) translate(0,-100px);"
             "}"
         "</style>"
         "</head>"
         "<body>"
         "<div id='mytext'></div>"
         "</body>"
         "</html>");
 
-    RefPtrWillBeRawPtr<Text> text = document().createTextNode(str);
+    RawPtr<Text> text = document().createTextNode(str);
     Element* div = document().getElementById("mytext");
     div->appendChild(text);
 
     document().view()->updateAllLifecyclePhases();
 
     parseText(text.get());
     return text.release();
 }
 
-PassRefPtrWillBeRawPtr<Text> GranularityStrategyTest::setupRotate(String str)
+RawPtr<Text> GranularityStrategyTest::setupRotate(String str)
 {
     setInnerHTML(
         "<html>"
         "<head>"
         "<style>"
             "div {"
                 "transform: translate(0px,600px) rotate(90deg);"
             "}"
         "</style>"
         "</head>"
         "<body>"
         "<div id='mytext'></div>"
         "</body>"
         "</html>");
 
-    RefPtrWillBeRawPtr<Text> text = document().createTextNode(str);
+    RawPtr<Text> text = document().createTextNode(str);
     Element* div = document().getElementById("mytext");
     div->appendChild(text);
 
     document().view()->updateAllLifecyclePhases();
 
     parseText(text.get());
     return text.release();
 }
 
 void GranularityStrategyTest::setupTextSpan(String str1, String str2, String str3, size_t selBegin, size_t selEnd)
 {
-    RefPtrWillBeRawPtr<Text> text1 = document().createTextNode(str1);
-    RefPtrWillBeRawPtr<Text> text2 = document().createTextNode(str2);
-    RefPtrWillBeRawPtr<Text> text3 = document().createTextNode(str3);
-    RefPtrWillBeRawPtr<Element> span = HTMLSpanElement::create(document());
+    RawPtr<Text> text1 = document().createTextNode(str1);
+    RawPtr<Text> text2 = document().createTextNode(str2);
+    RawPtr<Text> text3 = document().createTextNode(str3);
+    RawPtr<Element> span = HTMLSpanElement::create(document());
     Element* div = document().getElementById("mytext");
     div->appendChild(text1);
     div->appendChild(span);
     span->appendChild(text2);
     div->appendChild(text3);
 
     document().view()->updateAllLifecyclePhases();
 
     Vector<IntPoint> letterPos;
     Vector<IntPoint> wordMiddlePos;
@@ skipping 231 matching lines @@
     selection().moveRangeSelectionExtent(p);
     EXPECT_EQ_SELECTED_TEXT("efgh ijkl mno");
 }
 
 // Test for the default CharacterGranularityStrategy
 TEST_F(GranularityStrategyTest, Character)
 {
     dummyPageHolder().frame().settings()->setSelectionStrategy(SelectionStrategy::Character);
     dummyPageHolder().frame().settings()->setDefaultFontSize(12);
     // "Foo Bar Baz,"
-    RefPtrWillBeRawPtr<Text> text = appendTextNode("Foo Bar Baz,");
+    RawPtr<Text> text = appendTextNode("Foo Bar Baz,");
     // "Foo B^a|>r Baz," (^ means base, | means extent, , < means start, and > means end).
     selection().setSelection(VisibleSelection(Position(text, 5), Position(text, 6)));
     EXPECT_EQ_SELECTED_TEXT("a");
     // "Foo B^ar B|>az,"
     selection().moveRangeSelectionExtent(visiblePositionToContentsPoint(createVisiblePosition(Position(text, 9))));
     EXPECT_EQ_SELECTED_TEXT("ar B");
     // "F<|oo B^ar Baz,"
     selection().moveRangeSelectionExtent(visiblePositionToContentsPoint(createVisiblePosition(Position(text, 1))));
     EXPECT_EQ_SELECTED_TEXT("oo B");
 }
 
 // DirectionGranularityStrategy strategy on rotated text should revert to the
 // same behavior as CharacterGranularityStrategy
 TEST_F(GranularityStrategyTest, DirectionRotate)
 {
-    RefPtrWillBeRawPtr<Text> text = setupRotate("Foo Bar Baz,");
+    RawPtr<Text> text = setupRotate("Foo Bar Baz,");
     // "Foo B^a|>r Baz," (^ means base, | means extent, , < means start, and > means end).
     selection().setSelection(VisibleSelection(Position(text, 5), Position(text, 6)));
     EXPECT_EQ_SELECTED_TEXT("a");
     IntPoint p = m_letterPos[9];
     // Need to move by one pixel, otherwise this point is not evaluated
     // to the same line as the text by hit testing.
     p.move(1, 0);
     // "Foo B^ar B|>az,"
     selection().moveRangeSelectionExtent(p);
     EXPECT_EQ_SELECTED_TEXT("ar B");
     p = m_letterPos[1];
     p.move(1, 0);
     // "F<|oo B^ar Baz,"
     selection().moveRangeSelectionExtent(p);
     EXPECT_EQ_SELECTED_TEXT("oo B");
 }
 
 TEST_F(GranularityStrategyTest, DirectionExpandTranslateZ)
 {
-    RefPtrWillBeRawPtr<Text> text = setupTranslateZ("abcdef ghij kl mnopqr stuvwi inm mnii,");
+    RawPtr<Text> text = setupTranslateZ("abcdef ghij kl mnopqr stuvwi inm mnii,");
     // "abcdef ghij kl mno^p|>qr stuvwi inm  mnii," (^ means base, | means extent, < means start, and > means end).
     selection().setSelection(VisibleSelection(Position(text, 18), Position(text, 19)));
     EXPECT_EQ_SELECTED_TEXT("p");
     testDirectionExpand();
 }
 
 TEST_F(GranularityStrategyTest, DirectionExpandTransform)
 {
-    RefPtrWillBeRawPtr<Text> text = setupTransform("abcdef ghij kl mnopqr stuvwi inm mnii,");
+    RawPtr<Text> text = setupTransform("abcdef ghij kl mnopqr stuvwi inm mnii,");
     // "abcdef ghij kl mno^p|>qr stuvwi inm  mnii," (^ means base, | means extent, < means start, and > means end).
     selection().setSelection(VisibleSelection(Position(text, 18), Position(text, 19)));
     EXPECT_EQ_SELECTED_TEXT("p");
     testDirectionExpand();
 }
 
 TEST_F(GranularityStrategyTest, DirectionExpandVerticalAlign)
 {
     // "abcdef ghij kl mno^p|>qr stuvwi inm  mnii," (^ means base, | means extent, < means start, and > means end).
     setupVerticalAlign("abcdef ghij kl m", "nopq", "r stuvwi inm mnii,", 18, 19);
     EXPECT_EQ_SELECTED_TEXT("p");
     testDirectionExpand();
 }
 
 TEST_F(GranularityStrategyTest, DirectionExpandFontSizes)
 {
     setupFontSize("abcdef ghij kl mnopqr st", "uv", "wi inm mnii,", 18, 19);
     EXPECT_EQ_SELECTED_TEXT("p");
     testDirectionExpand();
 }
 
 TEST_F(GranularityStrategyTest, DirectionShrinkTranslateZ)
 {
-    RefPtrWillBeRawPtr<Text> text = setupTranslateZ("abcdef ghij kl mnopqr iiinmni, abc");
+    RawPtr<Text> text = setupTranslateZ("abcdef ghij kl mnopqr iiinmni, abc");
     selection().setSelection(VisibleSelection(Position(text, 18), Position(text, 21)));
     EXPECT_EQ_SELECTED_TEXT("pqr");
     testDirectionShrink();
 }
 
 TEST_F(GranularityStrategyTest, DirectionShrinkTransform)
 {
-    RefPtrWillBeRawPtr<Text> text = setupTransform("abcdef ghij kl mnopqr iiinmni, abc");
+    RawPtr<Text> text = setupTransform("abcdef ghij kl mnopqr iiinmni, abc");
     selection().setSelection(VisibleSelection(Position(text, 18), Position(text, 21)));
     EXPECT_EQ_SELECTED_TEXT("pqr");
     testDirectionShrink();
 }
 
 TEST_F(GranularityStrategyTest, DirectionShrinkVerticalAlign)
 {
     setupVerticalAlign("abcdef ghij kl mnopqr ii", "inm", "ni, abc", 18, 21);
     EXPECT_EQ_SELECTED_TEXT("pqr");
     testDirectionShrink();
 }
 
 TEST_F(GranularityStrategyTest, DirectionShrinkFontSizes)
 {
     setupFontSize("abcdef ghij kl mnopqr ii", "inm", "ni, abc", 18, 21);
     EXPECT_EQ_SELECTED_TEXT("pqr");
     testDirectionShrink();
 }
 
 TEST_F(GranularityStrategyTest, DirectionSwitchSideTranslateZ)
 {
-    RefPtrWillBeRawPtr<Text> text = setupTranslateZ("abcd efgh ijkl mnopqr iiinmni, abc");
+    RawPtr<Text> text = setupTranslateZ("abcd efgh ijkl mnopqr iiinmni, abc");
     selection().setSelection(VisibleSelection(Position(text, 18), Position(text, 21)));
     EXPECT_EQ_SELECTED_TEXT("pqr");
     testDirectionSwitchSide();
 }
 
 TEST_F(GranularityStrategyTest, DirectionSwitchSideTransform)
 {
-    RefPtrWillBeRawPtr<Text> text = setupTransform("abcd efgh ijkl mnopqr iiinmni, abc");
+    RawPtr<Text> text = setupTransform("abcd efgh ijkl mnopqr iiinmni, abc");
     selection().setSelection(VisibleSelection(Position(text, 18), Position(text, 21)));
     EXPECT_EQ_SELECTED_TEXT("pqr");
     testDirectionSwitchSide();
 }
 
 TEST_F(GranularityStrategyTest, DirectionSwitchSideVerticalAlign)
 {
     setupVerticalAlign("abcd efgh ijkl", " mnopqr", " iiinmni, abc", 18, 21);
     EXPECT_EQ_SELECTED_TEXT("pqr");
     testDirectionSwitchSide();
 }
 
 TEST_F(GranularityStrategyTest, DirectionSwitchSideFontSizes)
 {
     setupFontSize("abcd efgh i", "jk", "l mnopqr iiinmni, abc", 18, 21);
     EXPECT_EQ_SELECTED_TEXT("pqr");
     testDirectionSwitchSide();
 }
 
 // Tests moving extent over to the other side of the vase and immediately
 // passing the word boundary and going into word granularity.
 TEST_F(GranularityStrategyTest, DirectionSwitchSideWordGranularityThenShrink)
 {
     dummyPageHolder().frame().settings()->setDefaultFontSize(12);
     String str = "ab cd efghijkl mnopqr iiin, abc";
-    RefPtrWillBeRawPtr<Text> text = document().createTextNode(str);
+    RawPtr<Text> text = document().createTextNode(str);
     document().body()->appendChild(text);
     dummyPageHolder().frame().settings()->setSelectionStrategy(SelectionStrategy::Direction);
 
     parseText(text.get());
 
     // "abcd efgh ijkl mno^pqr|> iiin, abc" (^ means base, | means extent, < means start, and > means end).
     selection().setSelection(VisibleSelection(Position(text, 18), Position(text, 21)));
     EXPECT_EQ_SELECTED_TEXT("pqr");
     // Move to the middle of word #4 selecting it - this will set the offset to
     // be half the width of "iiin".
@@ skipping 11 matching lines @@
     selection().moveRangeSelectionExtent(p);
     EXPECT_EQ_SELECTED_TEXT("fghijkl mno");
 }
 
 // Make sure we switch to word granularity right away when starting on a
 // word boundary and extending.
 TEST_F(GranularityStrategyTest, DirectionSwitchStartOnBoundary)
 {
     dummyPageHolder().frame().settings()->setDefaultFontSize(12);
     String str = "ab cd efghijkl mnopqr iiin, abc";
-    RefPtrWillBeRawPtr<Text> text = document().createTextNode(str);
+    RawPtr<Text> text = document().createTextNode(str);
     document().body()->appendChild(text);
     dummyPageHolder().frame().settings()->setSelectionStrategy(SelectionStrategy::Direction);
 
     parseText(text.get());
 
     // "ab cd efghijkl ^mnopqr |>stuvwi inm," (^ means base and | means extent,
     // > means end).
     selection().setSelection(VisibleSelection(Position(text, 15), Position(text, 22)));
     EXPECT_EQ_SELECTED_TEXT("mnopqr ");
     selection().moveRangeSelectionExtent(m_wordMiddles[4]);
     EXPECT_EQ_SELECTED_TEXT("mnopqr iiin");
 }
 
 } // namespace blink