Oilpan: Remove most WillBe types from the code base

third_party/WebKit/Source/core/testing/Internals.cpp

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  * Copyright (C) 2013 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.
@@ skipping 636 matching lines @@
     ASSERT(element);
     String representation = externalRepresentation(element);
     if (representation.isEmpty()) {
         exceptionState.throwDOMException(InvalidAccessError, "The element provided has no external representation.");
         return String();
     }
 
     return representation;
 }
 
-PassRefPtrWillBeRawPtr<CSSStyleDeclaration> Internals::computedStyleIncludingVisitedInfo(Node* node) const
+RawPtr<CSSStyleDeclaration> Internals::computedStyleIncludingVisitedInfo(Node* node) const
 {
     ASSERT(node);
     bool allowVisitedStyle = true;
     return CSSComputedStyleDeclaration::create(node, allowVisitedStyle);
 }
 
-PassRefPtrWillBeRawPtr<ShadowRoot> Internals::createUserAgentShadowRoot(Element* host)
+RawPtr<ShadowRoot> Internals::createUserAgentShadowRoot(Element* host)
 {
     ASSERT(host);
-    return PassRefPtrWillBeRawPtr<ShadowRoot>(host->ensureUserAgentShadowRoot());
+    return RawPtr<ShadowRoot>(host->ensureUserAgentShadowRoot());
 }
 
 ShadowRoot* Internals::shadowRoot(Element* host)
 {
     // FIXME: Internals::shadowRoot() in tests should be converted to youngestShadowRoot() or oldestShadowRoot().
     // https://bugs.webkit.org/show_bug.cgi?id=78465
     return youngestShadowRoot(host);
 }
 
 ShadowRoot* Internals::youngestShadowRoot(Element* host)
@@ skipping 186 matching lines @@
         exceptionState.throwDOMException(SyntaxError, "The marker type provided ('" + markerType + "') is invalid.");
         return 0;
     }
 
     DocumentMarkerVector markers = node->document().markers().markersFor(node, markerTypes);
     if (markers.size() <= index)
         return 0;
     return markers[index];
 }
 
-PassRefPtrWillBeRawPtr<Range> Internals::markerRangeForNode(Node* node, const String& markerType, unsigned index, ExceptionState& exceptionState)
+RawPtr<Range> Internals::markerRangeForNode(Node* node, const String& markerType, unsigned index, ExceptionState& exceptionState)
 {
     ASSERT(node);
     DocumentMarker* marker = markerAt(node, markerType, index, exceptionState);
     if (!marker)
         return nullptr;
     return Range::create(node->document(), node, marker->startOffset(), node, marker->endOffset());
 }
 
 String Internals::markerDescriptionForNode(Node* node, const String& markerType, unsigned index, ExceptionState& exceptionState)
 {
@@ skipping 145 matching lines @@
 void Internals::setAutofilled(Element* element, bool enabled, ExceptionState& exceptionState)
 {
     ASSERT(element);
     if (!element->isFormControlElement()) {
         exceptionState.throwDOMException(InvalidNodeTypeError, "The element provided is not a form control element.");
         return;
     }
     toHTMLFormControlElement(element)->setAutofilled(enabled);
 }
 
-PassRefPtrWillBeRawPtr<Range> Internals::rangeFromLocationAndLength(Element* scope, int rangeLocation, int rangeLength)
+RawPtr<Range> Internals::rangeFromLocationAndLength(Element* scope, int rangeLocation, int rangeLength)
 {
     ASSERT(scope);
 
     // TextIterator depends on Layout information, make sure layout it up to date.
     scope->document().updateLayoutIgnorePendingStylesheets();
 
     return createRange(PlainTextRange(rangeLocation, rangeLocation + rangeLength).createRange(*scope));
 }
 
 unsigned Internals::locationFromRange(Element* scope, const Range* range)
@@ skipping 425 matching lines @@
 
 Vector<AtomicString> Internals::svgTags()
 {
     Vector<AtomicString> tags(SVGNames::SVGTagsCount);
     OwnPtr<const SVGQualifiedName*[]> qualifiedNames = SVGNames::getSVGTags();
     for (size_t i = 0; i < SVGNames::SVGTagsCount; ++i)
         tags[i] = qualifiedNames[i]->localName();
     return tags;
 }
 
-PassRefPtrWillBeRawPtr<StaticNodeList> Internals::nodesFromRect(Document* document, int centerX, int centerY, unsigned topPadding, unsigned rightPadding,
+RawPtr<StaticNodeList> Internals::nodesFromRect(Document* document, int centerX, int centerY, unsigned topPadding, unsigned rightPadding,
     unsigned bottomPadding, unsigned leftPadding, bool ignoreClipping, bool allowChildFrameContent, ExceptionState& exceptionState) const
 {
     ASSERT(document);
     if (!document->frame() || !document->frame()->view()) {
         exceptionState.throwDOMException(InvalidAccessError, "No view can be obtained from the provided document.");
         return nullptr;
     }
 
     LocalFrame* frame = document->frame();
     FrameView* frameView = document->view();
@@ skipping 10 matching lines @@
         hitType |= HitTestRequest::IgnoreClipping;
     if (allowChildFrameContent)
         hitType |= HitTestRequest::AllowChildFrameContent;
 
     HitTestRequest request(hitType);
 
     // When ignoreClipping is false, this method returns null for coordinates outside of the viewport.
     if (!request.ignoreClipping() && !frameView->visibleContentRect().intersects(HitTestLocation::rectForPoint(point, topPadding, rightPadding, bottomPadding, leftPadding)))
         return nullptr;
 
-    WillBeHeapVector<RefPtrWillBeMember<Node>> matches;
+    HeapVector<Member<Node>> matches;
     HitTestResult result(request, point, topPadding, rightPadding, bottomPadding, leftPadding);
     layoutView->hitTest(result);
     copyToVector(result.listBasedTestResult(), matches);
 
     return StaticNodeList::adopt(matches);
 }
 
 bool Internals::hasSpellingMarker(Document* document, int from, int length)
 {
     ASSERT(document);
@@ skipping 895 matching lines @@
 {
     return document->canvasFontCache()->isInCache(fontString);
 }
 
 unsigned Internals::canvasFontCacheMaxFonts()
 {
     return CanvasFontCache::maxFonts();
 }
 
 void Internals::setScrollChain(
-    ScrollState* scrollState, const WillBeHeapVector<RefPtrWillBeMember<Element>>& elements, ExceptionState&)
+    ScrollState* scrollState, const HeapVector<Member<Element>>& elements, ExceptionState&)
 {
     std::deque<int> scrollChain;
     for (size_t i = 0; i < elements.size(); ++i)
         scrollChain.push_back(DOMNodeIds::idForNode(elements[i].get()));
     scrollState->setScrollChain(scrollChain);
 }
 
 void Internals::forceBlinkGCWithoutV8GC()
 {
     ThreadState::current()->setGCState(ThreadState::FullGCScheduled);
@@ skipping 116 matching lines @@
 }
 
 int Internals::getScrollAnimationState(Node* node) const
 {
     if (ScrollableArea* scrollableArea = scrollableAreaForNode(node))
         return static_cast<int>(scrollableArea->scrollAnimator().m_runState);
     return -1;
 }
 
 } // namespace blink