Oilpan: Remove most WillBe types from the code base

third_party/WebKit/Source/core/input/EventHandler.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2012 Digia Plc. and/or its subsidiary(-ies)
  *
  * 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 107 matching lines @@
     // is most significant. The enumeration is ordered with smaller specified
     // numbers first. Examples of merged results are:
     // (HandledApplication, HandledSystem) -> HandledSystem
     // (NotHandled, HandledApplication) -> HandledApplication
     static_assert(static_cast<int>(WebInputEventResult::NotHandled) == 0, "WebInputEventResult not ordered");
     static_assert(static_cast<int>(WebInputEventResult::HandledSuppressed) < static_cast<int>(WebInputEventResult::HandledApplication), "WebInputEventResult not ordered");
     static_assert(static_cast<int>(WebInputEventResult::HandledApplication) < static_cast<int>(WebInputEventResult::HandledSystem), "WebInputEventResult not ordered");
     return static_cast<WebInputEventResult>(max(static_cast<int>(responseA), static_cast<int>(responseB)));
 }
 
-WebInputEventResult eventToEventResult(PassRefPtrWillBeRawPtr<Event> event, bool res)
+WebInputEventResult eventToEventResult(RawPtr<Event> event, bool res)
 {
     if (event->defaultPrevented())
         return WebInputEventResult::HandledApplication;
     if (event->defaultHandled())
         return WebInputEventResult::HandledSystem;
 
     // TODO(dtapuska): There are cases in the code where dispatchEvent
     // returns false (indicated handled) but event is not marked
     // as default handled or default prevented. crbug.com/560355
     if (!res)
@@ skipping 843 matching lines @@
     FrameView* view = frame->view();
     // FIXME: Is it really OK to use the wrong coordinates here when view is 0?
     // Historically the code would just crash; this is clearly no worse than that.
     return view ? view->rootFrameToContents(pointInRootFrame) : pointInRootFrame;
 }
 
 WebInputEventResult EventHandler::handleMousePressEvent(const PlatformMouseEvent& mouseEvent)
 {
     TRACE_EVENT0("blink", "EventHandler::handleMousePressEvent");
 
-    RefPtrWillBeRawPtr<FrameView> protector(m_frame->view());
+    RawPtr<FrameView> protector(m_frame->view());
 
     UserGestureIndicator gestureIndicator(DefinitelyProcessingUserGesture);
     m_frame->localFrameRoot()->eventHandler().m_lastMouseDownUserGestureToken = gestureIndicator.currentToken();
 
     cancelFakeMouseMoveEvent();
     if (m_eventHandlerWillResetCapturingMouseEventsNode)
         m_capturingMouseEventsNode = nullptr;
     m_mousePressed = true;
     m_capturesDragging = true;
     setLastKnownMousePosition(mouseEvent);
@@ skipping 14 matching lines @@
     LayoutPoint documentPoint = contentPointFromRootFrame(m_frame, mouseEvent.position());
     MouseEventWithHitTestResults mev = m_frame->document()->prepareMouseEvent(request, documentPoint, mouseEvent);
 
     if (!mev.innerNode()) {
         invalidateClick();
         return WebInputEventResult::NotHandled;
     }
 
     m_mousePressNode = mev.innerNode();
 
-    RefPtrWillBeRawPtr<LocalFrame> subframe = subframeForHitTestResult(mev);
+    RawPtr<LocalFrame> subframe = subframeForHitTestResult(mev);
     if (subframe) {
         WebInputEventResult result = passMousePressEventToSubframe(mev, subframe.get());
         // Start capturing future events for this frame.  We only do this if we didn't clear
         // the m_mousePressed flag, which may happen if an AppKit widget entered a modal event loop.
         // The capturing should be done only when the result indicates it
         // has been handled. See crbug.com/269917
         m_capturesDragging = subframe->eventHandler().capturesDragging();
         if (m_mousePressed && m_capturesDragging) {
             m_capturingMouseEventsNode = mev.innerNode();
             m_eventHandlerWillResetCapturingMouseEventsNode = true;
@@ skipping 107 matching lines @@
 
     return nullptr;
 }
 
 WebInputEventResult EventHandler::handleMouseMoveEvent(const PlatformMouseEvent& event)
 {
     TRACE_EVENT0("blink", "EventHandler::handleMouseMoveEvent");
 
     conditionallyEnableMouseEventForPointerTypeMouse(event);
 
-    RefPtrWillBeRawPtr<FrameView> protector(m_frame->view());
+    RawPtr<FrameView> protector(m_frame->view());
 
     HitTestResult hoveredNode = HitTestResult();
     WebInputEventResult result = handleMouseMoveOrLeaveEvent(event, &hoveredNode);
 
     Page* page = m_frame->page();
     if (!page)
         return result;
 
     if (PaintLayer* layer = layerForNode(hoveredNode.innerNode())) {
         if (ScrollableArea* layerScrollableArea = associatedScrollableArea(layer))
             layerScrollableArea->mouseMovedInContentArea();
     }
 
     if (FrameView* frameView = m_frame->view())
         frameView->mouseMovedInContentArea();
 
     hoveredNode.setToShadowHostIfInUserAgentShadowRoot();
     page->chromeClient().mouseDidMoveOverElement(hoveredNode);
 
     return result;
 }
 
 void EventHandler::handleMouseLeaveEvent(const PlatformMouseEvent& event)
 {
     TRACE_EVENT0("blink", "EventHandler::handleMouseLeaveEvent");
 
     conditionallyEnableMouseEventForPointerTypeMouse(event);
 
-    RefPtrWillBeRawPtr<FrameView> protector(m_frame->view());
+    RawPtr<FrameView> protector(m_frame->view());
     handleMouseMoveOrLeaveEvent(event, 0, false, true);
 }
 
 WebInputEventResult EventHandler::handleMouseMoveOrLeaveEvent(const PlatformMouseEvent& mouseEvent, HitTestResult* hoveredNode, bool onlyUpdateScrollbars, bool forceLeave)
 {
     ASSERT(m_frame);
     ASSERT(m_frame->view());
 
     setLastKnownMousePosition(mouseEvent);
 
@@ skipping 55 matching lines @@
     } else {
         if (!scrollbar)
             scrollbar = mev.scrollbar();
 
         updateLastScrollbarUnderMouse(scrollbar, !m_mousePressed);
         if (onlyUpdateScrollbars)
             return WebInputEventResult::HandledSuppressed;
     }
 
     WebInputEventResult eventResult = WebInputEventResult::NotHandled;
-    RefPtrWillBeRawPtr<LocalFrame> newSubframe = m_capturingMouseEventsNode.get() ? subframeForTargetNode(m_capturingMouseEventsNode.get()) : subframeForHitTestResult(mev);
+    RawPtr<LocalFrame> newSubframe = m_capturingMouseEventsNode.get() ? subframeForTargetNode(m_capturingMouseEventsNode.get()) : subframeForHitTestResult(mev);
 
     // We want mouseouts to happen first, from the inside out.  First send a move event to the last subframe so that it will fire mouseouts.
     if (m_lastMouseMoveEventSubframe && m_lastMouseMoveEventSubframe->tree().isDescendantOf(m_frame) && m_lastMouseMoveEventSubframe != newSubframe)
         m_lastMouseMoveEventSubframe->eventHandler().handleMouseLeaveEvent(mouseEvent);
 
     if (newSubframe) {
         // Update over/out state before passing the event to the subframe.
         updateMouseEventTargetNode(mev.innerNode(), mouseEvent);
 
         // Event dispatch in updateMouseEventTargetNode may have caused the subframe of the target
@@ skipping 36 matching lines @@
     if (node.isHTMLElement() && toHTMLElement(node).isInteractiveContent())
         return nullptr;
 
     return FlatTreeTraversal::parent(node);
 }
 
 WebInputEventResult EventHandler::handleMouseReleaseEvent(const PlatformMouseEvent& mouseEvent)
 {
     TRACE_EVENT0("blink", "EventHandler::handleMouseReleaseEvent");
 
-    RefPtrWillBeRawPtr<FrameView> protector(m_frame->view());
+    RawPtr<FrameView> protector(m_frame->view());
 
     m_frame->selection().setCaretBlinkingSuspended(false);
 
     OwnPtr<UserGestureIndicator> gestureIndicator;
 
     if (m_frame->localFrameRoot()->eventHandler().m_lastMouseDownUserGestureToken)
         gestureIndicator = adoptPtr(new UserGestureIndicator(m_frame->localFrameRoot()->eventHandler().m_lastMouseDownUserGestureToken.release()));
     else
         gestureIndicator = adoptPtr(new UserGestureIndicator(DefinitelyProcessingUserGesture));
 
@@ skipping 80 matching lines @@
 }
 
 WebInputEventResult EventHandler::dispatchDragEvent(const AtomicString& eventType, Node* dragTarget, const PlatformMouseEvent& event, DataTransfer* dataTransfer)
 {
     FrameView* view = m_frame->view();
 
     // FIXME: We might want to dispatch a dragleave even if the view is gone.
     if (!view)
         return WebInputEventResult::NotHandled;
 
-    RefPtrWillBeRawPtr<DragEvent> me = DragEvent::create(eventType,
+    RawPtr<DragEvent> me = DragEvent::create(eventType,
         true, true, m_frame->document()->domWindow(),
         0, event.globalPosition().x(), event.globalPosition().y(), event.position().x(), event.position().y(),
         event.movementDelta().x(), event.movementDelta().y(),
         event.modifiers(),
         0, MouseEvent::platformModifiersToButtons(event.modifiers()), nullptr, event.timestamp(), dataTransfer, event.syntheticEventType());
 
     bool dispatchResult = dragTarget->dispatchEvent(me.get());
     return eventToEventResult(me, dispatchResult);
 }
 
@@ skipping 53 matching lines @@
 {
     WebInputEventResult eventResult = WebInputEventResult::NotHandled;
 
     if (!m_frame->view())
         return eventResult;
 
     HitTestRequest request(HitTestRequest::ReadOnly);
     MouseEventWithHitTestResults mev = prepareMouseEvent(request, event);
 
     // Drag events should never go to text nodes (following IE, and proper mouseover/out dispatch)
-    RefPtrWillBeRawPtr<Node> newTarget = mev.innerNode();
+    RawPtr<Node> newTarget = mev.innerNode();
     if (newTarget && newTarget->isTextNode())
         newTarget = FlatTreeTraversal::parent(*newTarget);
 
     if (AutoscrollController* controller = autoscrollController())
         controller->updateDragAndDrop(newTarget.get(), event.position(), event.timestamp());
 
     if (m_dragTarget != newTarget) {
         // FIXME: this ordering was explicitly chosen to match WinIE. However,
         // it is sometimes incorrect when dragging within subframes, as seen with
         // LayoutTests/fast/events/drag-in-frames.html.
@@ skipping 77 matching lines @@
 }
 
 void EventHandler::clearDragState()
 {
     stopAutoscroll();
     m_dragTarget = nullptr;
     m_capturingMouseEventsNode = nullptr;
     m_shouldOnlyFireDragOverEvent = false;
 }
 
-void EventHandler::setCapturingMouseEventsNode(PassRefPtrWillBeRawPtr<Node> n)
+void EventHandler::setCapturingMouseEventsNode(RawPtr<Node> n)
 {
     m_capturingMouseEventsNode = n;
     m_eventHandlerWillResetCapturingMouseEventsNode = false;
 }
 
 MouseEventWithHitTestResults EventHandler::prepareMouseEvent(const HitTestRequest& request, const PlatformMouseEvent& mev)
 {
     ASSERT(m_frame);
     ASSERT(m_frame->document());
 
     return m_frame->document()->prepareMouseEvent(request, contentPointFromRootFrame(m_frame, mev.position()), mev);
 }
 
 void EventHandler::updateMouseEventTargetNode(Node* targetNode, const PlatformMouseEvent& mouseEvent)
 {
     Node* result = targetNode;
 
     // If we're capturing, we always go right to that node.
     if (m_capturingMouseEventsNode) {
         result = m_capturingMouseEventsNode.get();
     } else {
         // If the target node is a text node, dispatch on the parent node - rdar://4196646
         if (result && result->isTextNode())
             result = FlatTreeTraversal::parent(*result);
     }
-    RefPtrWillBeMember<Node> lastNodeUnderMouse = m_nodeUnderMouse;
+    Member<Node> lastNodeUnderMouse = m_nodeUnderMouse;
     m_nodeUnderMouse = result;
 
     PaintLayer* layerForLastNode = layerForNode(lastNodeUnderMouse.get());
     PaintLayer* layerForNodeUnderMouse = layerForNode(m_nodeUnderMouse.get());
     Page* page = m_frame->page();
 
     if (lastNodeUnderMouse && (!m_nodeUnderMouse || m_nodeUnderMouse->document() != m_frame->document())) {
         // The mouse has moved between frames.
         if (LocalFrame* frame = lastNodeUnderMouse->document().frame()) {
             if (FrameView* frameView = frame->view())
@@ skipping 19 matching lines @@
 
     if (lastNodeUnderMouse && lastNodeUnderMouse->document() != m_frame->document()) {
         lastNodeUnderMouse = nullptr;
         m_lastScrollbarUnderMouse = nullptr;
     }
 
     if (lastNodeUnderMouse != m_nodeUnderMouse)
         sendNodeTransitionEvents(lastNodeUnderMouse.get(), m_nodeUnderMouse.get(), mouseEvent);
 }
 
-WebInputEventResult EventHandler::dispatchPointerEvent(EventTarget* target, PassRefPtrWillBeRawPtr<PointerEvent> pointerEvent)
+WebInputEventResult EventHandler::dispatchPointerEvent(EventTarget* target, RawPtr<PointerEvent> pointerEvent)
 {
     if (!RuntimeEnabledFeatures::pointerEventEnabled())
         return WebInputEventResult::NotHandled;
 
     bool dispatchResult = target->dispatchEvent(pointerEvent.get());
     return eventToEventResult(pointerEvent, dispatchResult);
 }
 
 void EventHandler::sendNodeTransitionEvents(Node* exitedNode, Node* enteredNode,
     const PlatformMouseEvent& mouseEvent)
@@ skipping 13 matching lines @@
     // mouseleave events in certain contrived eventhandling scenarios, e.g., when:
     // - the mouseleave handler for a node sets the only capturing-mouseleave-listener in its ancestor, or
     // - DOM mods in any mouseenter/mouseleave handler changes the common ancestor of exited & entered nodes, etc.
     // We think the spec specifies a "frozen" state to avoid such corner cases (check the discussion on "candidate event
     // listeners" at http://www.w3.org/TR/uievents), but our code below preserves one such behavior from past only to
     // match Firefox and IE behavior.
     //
     // TODO(mustaq): Confirm spec conformance, double-check with other browsers.
 
     // Create lists of all exited/entered ancestors, locate the common ancestor & capturing listeners.
-    WillBeHeapVector<RefPtrWillBeMember<Node>, 32> exitedAncestors;
-    WillBeHeapVector<RefPtrWillBeMember<Node>, 32> enteredAncestors;
+    HeapVector<Member<Node>, 32> exitedAncestors;
+    HeapVector<Member<Node>, 32> enteredAncestors;
     if (isNodeInDocument(exitedNode)) {
         exitedNode->updateDistribution();
         for (Node* node = exitedNode; node; node = FlatTreeTraversal::parent(*node)) {
             exitedAncestors.append(node);
         }
     }
     if (isNodeInDocument(enteredNode)) {
         enteredNode->updateDistribution();
         for (Node* node = enteredNode; node; node = FlatTreeTraversal::parent(*node)) {
             enteredAncestors.append(node);
@@ skipping 50 matching lines @@
         sendPointerAndMouseTransitionEvents(enteredAncestors[i-1].get(), EventTypeNames::mouseenter, mouseEvent, exitedNode, !enteredNodeHasCapturingAncestor);
     }
 }
 
 WebInputEventResult EventHandler::dispatchMouseEvent(const AtomicString& eventType, Node* targetNode, int clickCount, const PlatformMouseEvent& mouseEvent)
 {
     updateMouseEventTargetNode(targetNode, mouseEvent);
     if (!m_nodeUnderMouse)
         return WebInputEventResult::NotHandled;
 
-    RefPtrWillBeRawPtr<MouseEvent> event = MouseEvent::create(eventType, m_nodeUnderMouse->document().domWindow(), mouseEvent, clickCount, nullptr);
+    RawPtr<MouseEvent> event = MouseEvent::create(eventType, m_nodeUnderMouse->document().domWindow(), mouseEvent, clickCount, nullptr);
     bool dispatchResult = m_nodeUnderMouse->dispatchEvent(event);
     return eventToEventResult(event, dispatchResult);
 }
 
 EventTarget* EventHandler::getEffectiveTargetForPointerEvent(
-    EventTarget* target, PassRefPtrWillBeRawPtr<PointerEvent> pointerEvent)
+    EventTarget* target, RawPtr<PointerEvent> pointerEvent)
 {
     EventTarget* capturingNode = m_pointerEventManager.getCapturingNode(pointerEvent.get());
     if (capturingNode)
         target = capturingNode;
     return target;
 }
 
 void EventHandler::sendPointerAndMouseTransitionEvents(Node* target, const AtomicString& mouseEventType,
     const PlatformMouseEvent& mouseEvent, Node* relatedTarget, bool checkForListener)
 {
     ASSERT(mouseEventType == EventTypeNames::mouseenter
         || mouseEventType == EventTypeNames::mouseleave
         || mouseEventType == EventTypeNames::mouseover
         || mouseEventType == EventTypeNames::mouseout);
 
     AtomicString pointerEventType = pointerEventNameForMouseEventName(mouseEventType);
-    RefPtrWillBeRawPtr<PointerEvent> pointerEvent = m_pointerEventManager.create(pointerEventType,
+    RawPtr<PointerEvent> pointerEvent = m_pointerEventManager.create(pointerEventType,
         mouseEvent, relatedTarget, m_frame->document()->domWindow());
 
     // Suppress these events if the target is not the capturing element
     if (target != getEffectiveTargetForPointerEvent(target, pointerEvent))
         return;
 
     if (!checkForListener || target->hasEventListeners(pointerEventType))
         dispatchPointerEvent(target, pointerEvent);
 
     if (!checkForListener || target->hasEventListeners(mouseEventType))
@@ skipping 12 matching lines @@
         return WebInputEventResult::NotHandled;
 
     AtomicString pointerEventType = pointerEventNameForMouseEventName(mouseEventType);
     unsigned short pointerButtonsPressed = MouseEvent::platformModifiersToButtons(mouseEvent.modifiers());
 
     // Make sure chorded buttons fire pointermove instead of pointerup/pointerdown.
     if ((pointerEventType == EventTypeNames::pointerdown && (pointerButtonsPressed & ~MouseEvent::buttonToButtons(mouseEvent.button())) != 0)
         || (pointerEventType == EventTypeNames::pointerup && pointerButtonsPressed != 0))
         pointerEventType = EventTypeNames::pointermove;
 
-    RefPtrWillBeRawPtr<PointerEvent> pointerEvent = m_pointerEventManager.create(pointerEventType,
+    RawPtr<PointerEvent> pointerEvent = m_pointerEventManager.create(pointerEventType,
         mouseEvent, nullptr, m_frame->document()->domWindow());
 
     EventTarget* target = getEffectiveTargetForPointerEvent(m_nodeUnderMouse.get(), pointerEvent);
     WebInputEventResult result = dispatchPointerEvent(target, pointerEvent);
 
     if (result != WebInputEventResult::NotHandled && pointerEventType == EventTypeNames::pointerdown)
         m_preventMouseEventForPointerTypeMouse = true;
 
     if (!m_preventMouseEventForPointerTypeMouse) {
-        RefPtrWillBeRawPtr<MouseEvent> event = MouseEvent::create(mouseEventType, m_nodeUnderMouse->document().domWindow(), mouseEvent, clickCount, nullptr);
+        RawPtr<MouseEvent> event = MouseEvent::create(mouseEventType, m_nodeUnderMouse->document().domWindow(), mouseEvent, clickCount, nullptr);
         bool dispatchResult = target->dispatchEvent(event);
         result = mergeEventResult(result, eventToEventResult(event, dispatchResult));
     }
 
     return result;
 }
 
 WebInputEventResult EventHandler::handleMouseFocus(const MouseEventWithHitTestResults& targetedEvent, InputDeviceCapabilities* sourceCapabilities)
 {
     // If clicking on a frame scrollbar, do not mess up with content focus.
@@ skipping 115 matching lines @@
 
 } // namespace
 
 WebInputEventResult EventHandler::handleWheelEvent(const PlatformWheelEvent& event)
 {
     Document* doc = m_frame->document();
 
     if (!doc->layoutView())
         return WebInputEventResult::NotHandled;
 
-    RefPtrWillBeRawPtr<FrameView> protector(m_frame->view());
+    RawPtr<FrameView> protector(m_frame->view());
 
     FrameView* view = m_frame->view();
     if (!view)
         return WebInputEventResult::NotHandled;
 
     LayoutPoint vPoint = view->rootFrameToContents(event.position());
 
     HitTestRequest request(HitTestRequest::ReadOnly);
     HitTestResult result(request, vPoint);
     doc->layoutView()->hitTest(result);
@@ skipping 15 matching lines @@
         if (isOverWidget && target && target->isLayoutPart()) {
             if (Widget* widget = toLayoutPart(target)->widget()) {
                 WebInputEventResult result = passWheelEventToWidget(event, *widget);
                 if (result != WebInputEventResult::NotHandled) {
                     setFrameWasScrolledByUser();
                     return result;
                 }
             }
         }
 
-        RefPtrWillBeRawPtr<Event> domEvent = WheelEvent::create(event, node->document().domWindow());
+        RawPtr<Event> domEvent = WheelEvent::create(event, node->document().domWindow());
         if (!node->dispatchEvent(domEvent)) {
             setFrameWasScrolledByUser();
             return eventToEventResult(domEvent, false);
         }
     }
 
     // We do another check on the frame view because the event handler can run
     // JS which results in the frame getting destroyed.
     view = m_frame->view();
     if (!view)
@@ skipping 99 matching lines @@
         return innerFrame->eventHandler().handleGestureEventInFrame(targetedEvent);
 
     // No hit test result, handle in root instance. Perhaps we should just return false instead?
     return handleGestureEventInFrame(targetedEvent);
 }
 
 WebInputEventResult EventHandler::handleGestureEventInFrame(const GestureEventWithHitTestResults& targetedEvent)
 {
     ASSERT(!targetedEvent.event().isScrollEvent());
 
-    RefPtrWillBeRawPtr<Node> eventTarget = targetedEvent.hitTestResult().innerNode();
-    RefPtrWillBeRawPtr<Scrollbar> scrollbar = targetedEvent.hitTestResult().scrollbar();
+    RawPtr<Node> eventTarget = targetedEvent.hitTestResult().innerNode();
+    RawPtr<Scrollbar> scrollbar = targetedEvent.hitTestResult().scrollbar();
     const PlatformGestureEvent& gestureEvent = targetedEvent.event();
 
     if (scrollbar) {
         bool eventSwallowed = scrollbar->gestureEvent(gestureEvent);
         if (gestureEvent.type() == PlatformEvent::GestureTapDown && eventSwallowed)
             m_scrollbarHandlingScrollGesture = scrollbar;
         if (eventSwallowed)
             return WebInputEventResult::HandledSuppressed;
     }
 
     if (eventTarget) {
-        RefPtrWillBeRawPtr<GestureEvent> gestureDomEvent = GestureEvent::create(eventTarget->document().domWindow(), gestureEvent);
+        RawPtr<GestureEvent> gestureDomEvent = GestureEvent::create(eventTarget->document().domWindow(), gestureEvent);
         // TODO(dtapuska): dispatchEvent is inverted for Gesture Events
         // crbug.com/560357
         if (gestureDomEvent.get() && eventTarget->dispatchEvent(gestureDomEvent))
             return eventToEventResult(gestureDomEvent, false);
     }
 
     switch (gestureEvent.type()) {
     case PlatformEvent::GestureTap:
         return handleGestureTap(targetedEvent);
     case PlatformEvent::GestureShowPress:
@@ skipping 15 matching lines @@
         ASSERT_NOT_REACHED();
     }
 
     return WebInputEventResult::NotHandled;
 }
 
 WebInputEventResult EventHandler::handleGestureScrollEvent(const PlatformGestureEvent& gestureEvent)
 {
     TRACE_EVENT0("input", "EventHandler::handleGestureScrollEvent");
 
-    RefPtrWillBeRawPtr<Node> eventTarget = nullptr;
-    RefPtrWillBeRawPtr<Scrollbar> scrollbar = nullptr;
+    RawPtr<Node> eventTarget = nullptr;
+    RawPtr<Scrollbar> scrollbar = nullptr;
     if (gestureEvent.type() != PlatformEvent::GestureScrollBegin) {
         scrollbar = m_scrollbarHandlingScrollGesture.get();
         eventTarget = m_scrollGestureHandlingNode.get();
     }
 
     if (!eventTarget) {
         Document* document = m_frame->document();
         if (!document->layoutView())
             return WebInputEventResult::NotHandled;
 
@@ skipping 21 matching lines @@
             m_scrollbarHandlingScrollGesture = nullptr;
         }
         if (eventSwallowed)
             return WebInputEventResult::HandledSuppressed;
     }
 
     if (eventTarget) {
         if (handleScrollGestureOnResizer(eventTarget.get(), gestureEvent))
             return WebInputEventResult::HandledSuppressed;
 
-        RefPtrWillBeRawPtr<GestureEvent> gestureDomEvent = GestureEvent::create(eventTarget->document().domWindow(), gestureEvent);
+        RawPtr<GestureEvent> gestureDomEvent = GestureEvent::create(eventTarget->document().domWindow(), gestureEvent);
         // TODO(dtapuska): dispatchEvent is inverted for Gesture Events
         // crbug.com/560357
         if (gestureDomEvent.get() && eventTarget->dispatchEvent(gestureDomEvent))
             return eventToEventResult(gestureDomEvent, false);
     }
 
     switch (gestureEvent.type()) {
     case PlatformEvent::GestureScrollBegin:
         return handleGestureScrollBegin(gestureEvent);
     case PlatformEvent::GestureScrollUpdate:
         return handleGestureScrollUpdate(gestureEvent);
     case PlatformEvent::GestureScrollEnd:
         return handleGestureScrollEnd(gestureEvent);
     case PlatformEvent::GestureFlingStart:
     case PlatformEvent::GesturePinchBegin:
     case PlatformEvent::GesturePinchEnd:
     case PlatformEvent::GesturePinchUpdate:
         return WebInputEventResult::NotHandled;
     default:
         ASSERT_NOT_REACHED();
         return WebInputEventResult::NotHandled;
     }
 }
 
 WebInputEventResult EventHandler::handleGestureTap(const GestureEventWithHitTestResults& targetedEvent)
 {
-    RefPtrWillBeRawPtr<FrameView> frameView(m_frame->view());
+    RawPtr<FrameView> frameView(m_frame->view());
     const PlatformGestureEvent& gestureEvent = targetedEvent.event();
     HitTestRequest::HitTestRequestType hitType = getHitTypeForGestureType(gestureEvent.type());
     uint64_t preDispatchDomTreeVersion = m_frame->document()->domTreeVersion();
     uint64_t preDispatchStyleVersion = m_frame->document()->styleVersion();
 
     UserGestureIndicator gestureIndicator(DefinitelyProcessingUserGesture);
 
     HitTestResult currentHitTest = targetedEvent.hitTestResult();
 
     // We use the adjusted position so the application isn't surprised to see a event with
@@ skipping 17 matching lines @@
     if (currentHitTest.innerNode()) {
         LocalFrame* mainFrame = m_frame->localFrameRoot();
         if (mainFrame && mainFrame->view())
             mainFrame->view()->updateAllLifecyclePhases();
         adjustedPoint = frameView->rootFrameToContents(gestureEvent.position());
         currentHitTest = hitTestResultInFrame(m_frame, adjustedPoint, hitType);
     }
     m_clickNode = currentHitTest.innerNode();
 
     // Capture data for showUnhandledTapUIIfNeeded.
-    RefPtrWillBeRawPtr<Node> tappedNode = m_clickNode;
+    RawPtr<Node> tappedNode = m_clickNode;
     IntPoint tappedPosition = gestureEvent.position();
 
     if (m_clickNode && m_clickNode->isTextNode())
         m_clickNode = FlatTreeTraversal::parent(*m_clickNode);
 
     PlatformMouseEvent fakeMouseDown(gestureEvent.position(), gestureEvent.globalPosition(),
         LeftButton, PlatformEvent::MousePressed, gestureEvent.tapCount(),
         static_cast<PlatformEvent::Modifiers>(modifiers | PlatformEvent::LeftButtonDown),
         PlatformMouseEvent::FromTouch,  gestureEvent.timestamp(), WebPointerProperties::PointerType::Mouse);
     WebInputEventResult mouseDownEventResult = dispatchMouseEvent(EventTypeNames::mousedown, currentHitTest.innerNode(), gestureEvent.tapCount(), fakeMouseDown);
@@ skipping 72 matching lines @@
         m_mouseDown = mouseDownEvent;
 
         PlatformMouseEvent mouseDragEvent(adjustedPoint, gestureEvent.globalPosition(), LeftButton, PlatformEvent::MouseMoved, 1,
             static_cast<PlatformEvent::Modifiers>(modifiers | PlatformEvent::LeftButtonDown),
             PlatformMouseEvent::FromTouch, WTF::monotonicallyIncreasingTime(), WebPointerProperties::PointerType::Mouse);
         HitTestRequest request(HitTestRequest::ReadOnly);
         MouseEventWithHitTestResults mev = prepareMouseEvent(request, mouseDragEvent);
         m_mouseDownMayStartDrag = true;
         dragState().m_dragSrc = nullptr;
         m_mouseDownPos = m_frame->view()->rootFrameToContents(mouseDragEvent.position());
-        RefPtrWillBeRawPtr<FrameView> protector(m_frame->view());
+        RawPtr<FrameView> protector(m_frame->view());
         if (handleDrag(mev, DragInitiator::Touch)) {
             m_longTapShouldInvokeContextMenu = true;
             return WebInputEventResult::HandledSystem;
         }
     }
 
     IntPoint hitTestPoint = m_frame->view()->rootFrameToContents(gestureEvent.position());
     HitTestResult result = hitTestResultAtPoint(hitTestPoint);
-    RefPtrWillBeRawPtr<FrameView> protector(m_frame->view());
+    RawPtr<FrameView> protector(m_frame->view());
     if (selectionController().handleGestureLongPress(gestureEvent, result)) {
         focusDocumentView();
         return WebInputEventResult::HandledSystem;
     }
 
     return sendContextMenuEventForGesture(targetedEvent);
 }
 
 WebInputEventResult EventHandler::handleGestureLongTap(const GestureEventWithHitTestResults& targetedEvent)
 {
@@ skipping 43 matching lines @@
     Widget* widget = toLayoutPart(layoutObject)->widget();
 
     if (!widget || !widget->isFrameView())
         return WebInputEventResult::NotHandled;
 
     return toFrameView(widget)->frame().eventHandler().handleGestureScrollEvent(gestureEvent);
 }
 
 WebInputEventResult EventHandler::handleGestureScrollEnd(const PlatformGestureEvent& gestureEvent)
 {
-    RefPtrWillBeRawPtr<Node> node = m_scrollGestureHandlingNode;
+    RawPtr<Node> node = m_scrollGestureHandlingNode;
 
     if (node) {
         passScrollGestureEventToWidget(gestureEvent, node->layoutObject());
         if (RuntimeEnabledFeatures::scrollCustomizationEnabled()) {
-            RefPtrWillBeRawPtr<ScrollState> scrollState = ScrollState::create(
+            RawPtr<ScrollState> scrollState = ScrollState::create(
                 0, 0, 0, 0, 0, gestureEvent.inertial(), /* isBeginning */
                 false, /* isEnding */ true, /* fromUserInput */ true);
             customizedScroll(*node.get(), *scrollState);
         }
     }
 
     clearGestureScrollState();
     return WebInputEventResult::NotHandled;
 }
 
@@ skipping 16 matching lines @@
         if (RuntimeEnabledFeatures::scrollCustomizationEnabled())
             m_scrollGestureHandlingNode = m_frame->document()->documentElement();
         else
             return WebInputEventResult::NotHandled;
     }
     ASSERT(m_scrollGestureHandlingNode);
 
     passScrollGestureEventToWidget(gestureEvent, m_scrollGestureHandlingNode->layoutObject());
     if (RuntimeEnabledFeatures::scrollCustomizationEnabled()) {
         m_currentScrollChain.clear();
-        RefPtrWillBeRawPtr<ScrollState> scrollState = ScrollState::create(
+        RawPtr<ScrollState> scrollState = ScrollState::create(
             0, 0, 0, 0, 0, /* inInertialPhase */ false, /* isBeginning */
             true, /* isEnding */ false, /* fromUserInput */ true);
         customizedScroll(*m_scrollGestureHandlingNode.get(), *scrollState);
     } else {
         if (m_frame->isMainFrame())
             m_frame->host()->topControls().scrollBegin();
     }
     return WebInputEventResult::HandledSystem;
 }
 
@@ skipping 37 matching lines @@
     ScrollGranularity granularity = gestureEvent.deltaUnits();
     Node* node = m_scrollGestureHandlingNode.get();
 
     // Scroll customization is only available for touch.
     bool handleScrollCustomization = RuntimeEnabledFeatures::scrollCustomizationEnabled() && gestureEvent.source() == PlatformGestureSourceTouchscreen;
     if (node) {
         LayoutObject* layoutObject = node->layoutObject();
         if (!layoutObject)
             return WebInputEventResult::NotHandled;
 
-        RefPtrWillBeRawPtr<FrameView> protector(m_frame->view());
+        RawPtr<FrameView> protector(m_frame->view());
 
         Node* stopNode = nullptr;
 
         // Try to send the event to the correct view.
         WebInputEventResult result = passScrollGestureEventToWidget(gestureEvent, layoutObject);
         if (result != WebInputEventResult::NotHandled) {
             if (gestureEvent.preventPropagation()
                 && !RuntimeEnabledFeatures::scrollCustomizationEnabled()) {
                 // This is an optimization which doesn't apply with
                 // scroll customization enabled.
                 m_previousGestureScrolledNode = m_scrollGestureHandlingNode;
             }
             // FIXME: we should allow simultaneous scrolling of nested
             // iframes along perpendicular axes. See crbug.com/466991.
             m_deltaConsumedForScrollSequence = true;
             return result;
         }
 
         bool scrolled = false;
         if (handleScrollCustomization) {
-            RefPtrWillBeRawPtr<ScrollState> scrollState = ScrollState::create(
+            RawPtr<ScrollState> scrollState = ScrollState::create(
                 gestureEvent.deltaX(), gestureEvent.deltaY(),
                 0, gestureEvent.velocityX(), gestureEvent.velocityY(),
                 gestureEvent.inertial(), /* isBeginning */
                 false, /* isEnding */ false, /* fromUserInput */ true,
                 !gestureEvent.preventPropagation(), m_deltaConsumedForScrollSequence);
             if (m_previousGestureScrolledNode) {
                 // The ScrollState needs to know what the current
                 // native scrolling element is, so that for an
                 // inertial scroll that shouldn't propagate, only the
                 // currently scrolling element responds.
@@ skipping 77 matching lines @@
     // DOM nodes so a touch over a scrollbar will be adjusted towards nearby nodes. This leads to things like textarea
     // scrollbars being untouchable.
     if (result.scrollbar()) {
         targetNode = 0;
         return false;
     }
 
     IntPoint touchCenter = m_frame->view()->contentsToRootFrame(result.roundedPointInMainFrame());
     IntRect touchRect = m_frame->view()->contentsToRootFrame(result.hitTestLocation().boundingBox());
 
-    WillBeHeapVector<RefPtrWillBeMember<Node>, 11> nodes;
+    HeapVector<Member<Node>, 11> nodes;
     copyToVector(result.listBasedTestResult(), nodes);
 
     // FIXME: the explicit Vector conversion copies into a temporary and is wasteful.
-    return findBestClickableCandidate(targetNode, targetPoint, touchCenter, touchRect, WillBeHeapVector<RefPtrWillBeMember<Node>> (nodes));
+    return findBestClickableCandidate(targetNode, targetPoint, touchCenter, touchRect, HeapVector<Member<Node>> (nodes));
 }
 
 bool EventHandler::bestContextMenuNodeForHitTestResult(const HitTestResult& result, IntPoint& targetPoint, Node*& targetNode)
 {
     ASSERT(result.isRectBasedTest());
     IntPoint touchCenter = m_frame->view()->contentsToRootFrame(result.roundedPointInMainFrame());
     IntRect touchRect = m_frame->view()->contentsToRootFrame(result.hitTestLocation().boundingBox());
-    WillBeHeapVector<RefPtrWillBeMember<Node>, 11> nodes;
+    HeapVector<Member<Node>, 11> nodes;
     copyToVector(result.listBasedTestResult(), nodes);
 
     // FIXME: the explicit Vector conversion copies into a temporary and is wasteful.
-    return findBestContextMenuCandidate(targetNode, targetPoint, touchCenter, touchRect, WillBeHeapVector<RefPtrWillBeMember<Node>>(nodes));
+    return findBestContextMenuCandidate(targetNode, targetPoint, touchCenter, touchRect, HeapVector<Member<Node>>(nodes));
 }
 
 bool EventHandler::bestZoomableAreaForTouchPoint(const IntPoint& touchCenter, const IntSize& touchRadius, IntRect& targetArea, Node*& targetNode)
 {
     if (touchRadius.isEmpty())
         return false;
 
     IntPoint hitTestPoint = m_frame->view()->rootFrameToContents(touchCenter);
 
     HitTestRequest::HitTestRequestType hitType = HitTestRequest::ReadOnly | HitTestRequest::Active | HitTestRequest::ListBased;
     HitTestResult result = hitTestResultAtPoint(hitTestPoint, hitType, LayoutSize(touchRadius));
 
     IntRect touchRect(touchCenter - touchRadius, touchRadius + touchRadius);
-    WillBeHeapVector<RefPtrWillBeMember<Node>, 11> nodes;
+    HeapVector<Member<Node>, 11> nodes;
     copyToVector(result.listBasedTestResult(), nodes);
 
     // FIXME: the explicit Vector conversion copies into a temporary and is wasteful.
-    return findBestZoomableArea(targetNode, targetArea, touchCenter, touchRect, WillBeHeapVector<RefPtrWillBeMember<Node>>(nodes));
+    return findBestZoomableArea(targetNode, targetArea, touchCenter, touchRect, HeapVector<Member<Node>>(nodes));
 }
 
 // Update the hover and active state across all frames for this gesture.
 // This logic is different than the mouse case because mice send MouseLeave events to frames as they're exited.
 // With gestures, a single event conceptually both 'leaves' whatever frame currently had hover and enters a new frame
 void EventHandler::updateGestureHoverActiveState(const HitTestRequest& request, Element* innerElement)
 {
     ASSERT(m_frame == m_frame->localFrameRoot());
 
-    WillBeHeapVector<RawPtrWillBeMember<LocalFrame>> newHoverFrameChain;
+    HeapVector<Member<LocalFrame>> newHoverFrameChain;
     LocalFrame* newHoverFrameInDocument = innerElement ? innerElement->document().frame() : nullptr;
     // Insert the ancestors of the frame having the new hovered node to the frame chain
     // The frame chain doesn't include the main frame to avoid the redundant work that cleans the hover state.
     // Because the hover state for the main frame is updated by calling Document::updateHoverActiveState
     while (newHoverFrameInDocument && newHoverFrameInDocument != m_frame) {
         newHoverFrameChain.append(newHoverFrameInDocument);
         Frame* parentFrame = newHoverFrameInDocument->tree().parent();
         newHoverFrameInDocument = parentFrame && parentFrame->isLocalFrame() ? toLocalFrame(parentFrame) : nullptr;
     }
 
-    RefPtrWillBeRawPtr<Node> oldHoverNodeInCurDoc = m_frame->document()->hoverNode();
-    RefPtrWillBeRawPtr<Node> newInnermostHoverNode = innerElement;
+    RawPtr<Node> oldHoverNodeInCurDoc = m_frame->document()->hoverNode();
+    RawPtr<Node> newInnermostHoverNode = innerElement;
 
     if (newInnermostHoverNode != oldHoverNodeInCurDoc) {
         size_t indexFrameChain = newHoverFrameChain.size();
 
         // Clear the hover state on any frames which are no longer in the frame chain of the hovered elemen
         while (oldHoverNodeInCurDoc && oldHoverNodeInCurDoc->isFrameOwnerElement()) {
             LocalFrame* newHoverFrame = nullptr;
             // If we can't get the frame from the new hover frame chain,
             // the newHoverFrame will be null and the old hover state will be cleared.
             if (indexFrameChain > 0)
@@ skipping 27 matching lines @@
     ASSERT(m_frame == m_frame->localFrameRoot());
 
     // Behaviour of this function is as follows:
     // - Create the chain of all entered frames.
     // - Compare the last frame chain under the gesture to newly entered frame chain from the main frame one by one.
     // - If the last frame doesn't match with the entered frame, then create the chain of exited frames from the last frame chain.
     // - Dispatch mouseout/mouseleave events of the exited frames from the inside out.
     // - Dispatch mouseover/mouseenter events of the entered frames into the inside.
 
     // Insert the ancestors of the frame having the new target node to the entered frame chain
-    WillBeHeapVector<RawPtrWillBeMember<LocalFrame>> enteredFrameChain;
+    HeapVector<Member<LocalFrame>> enteredFrameChain;
     LocalFrame* enteredFrameInDocument = targetedEvent.hitTestResult().innerNodeFrame();
     while (enteredFrameInDocument) {
         enteredFrameChain.append(enteredFrameInDocument);
         Frame* parentFrame = enteredFrameInDocument->tree().parent();
         enteredFrameInDocument = parentFrame && parentFrame->isLocalFrame() ? toLocalFrame(parentFrame) : nullptr;
     }
 
     size_t indexEnteredFrameChain = enteredFrameChain.size();
     LocalFrame* exitedFrameInDocument = m_frame;
-    WillBeHeapVector<RawPtrWillBeMember<LocalFrame>> exitedFrameChain;
+    HeapVector<Member<LocalFrame>> exitedFrameChain;
     // Insert the frame from the disagreement between last frames and entered frames
     while (exitedFrameInDocument) {
         Node* lastNodeUnderTap = exitedFrameInDocument->eventHandler().m_nodeUnderMouse.get();
         if (!lastNodeUnderTap)
             break;
 
         LocalFrame* nextExitedFrameInDocument = nullptr;
         if (lastNodeUnderTap->isFrameOwnerElement()) {
             HTMLFrameOwnerElement* owner = toHTMLFrameOwnerElement(lastNodeUnderTap);
             if (owner->contentFrame() && owner->contentFrame()->isLocalFrame())
@@ skipping 441 matching lines @@
     String key = evt.unmodifiedText();
     Element* elem = m_frame->document()->getElementByAccessKey(key.lower());
     if (!elem)
         return false;
     elem->accessKeyAction(false);
     return true;
 }
 
 WebInputEventResult EventHandler::keyEvent(const PlatformKeyboardEvent& initialKeyEvent)
 {
-    RefPtrWillBeRawPtr<FrameView> protector(m_frame->view());
+    RawPtr<FrameView> protector(m_frame->view());
     m_frame->chromeClient().clearToolTip();
 
     if (initialKeyEvent.windowsVirtualKeyCode() == VK_CAPITAL)
         capsLockStateMayHaveChanged();
 
 #if OS(WIN)
     if (panScrollInProgress()) {
         // If a key is pressed while the panScroll is in progress then we want to stop
         if (initialKeyEvent.type() == PlatformEvent::KeyDown || initialKeyEvent.type() == PlatformEvent::RawKeyDown)
             stopAutoscroll();
 
         // If we were in panscroll mode, we swallow the key event
         return WebInputEventResult::HandledSuppressed;
     }
 #endif
 
     // Check for cases where we are too early for events -- possible unmatched key up
     // from pressing return in the location bar.
-    RefPtrWillBeRawPtr<Node> node = eventTargetNodeForDocument(m_frame->document());
+    RawPtr<Node> node = eventTargetNodeForDocument(m_frame->document());
     if (!node)
         return WebInputEventResult::NotHandled;
 
     UserGestureIndicator gestureIndicator(DefinitelyProcessingUserGesture);
 
     // In IE, access keys are special, they are handled after default keydown processing, but cannot be canceled - this is hard to match.
     // On Mac OS X, we process them before dispatching keydown, as the default keydown handler implements Emacs key bindings, which may conflict
     // with access keys. Then we dispatch keydown, but suppress its default handling.
     // On Windows, WebKit explicitly calls handleAccessKey() instead of dispatching a keypress event for WM_SYSCHAR messages.
     // Other platforms currently match either Mac or Windows behavior, depending on whether they send combined KeyDown events.
     bool matchedAnAccessKey = false;
     if (initialKeyEvent.type() == PlatformEvent::KeyDown)
         matchedAnAccessKey = handleAccessKey(initialKeyEvent);
 
     // FIXME: it would be fair to let an input method handle KeyUp events before DOM dispatch.
     if (initialKeyEvent.type() == PlatformEvent::KeyUp || initialKeyEvent.type() == PlatformEvent::Char) {
-        RefPtrWillBeRawPtr<KeyboardEvent> domEvent = KeyboardEvent::create(initialKeyEvent, m_frame->document()->domWindow());
+        RawPtr<KeyboardEvent> domEvent = KeyboardEvent::create(initialKeyEvent, m_frame->document()->domWindow());
 
         bool dispatchResult = node->dispatchEvent(domEvent);
         return eventToEventResult(domEvent, dispatchResult);
     }
 
     PlatformKeyboardEvent keyDownEvent = initialKeyEvent;
     if (keyDownEvent.type() != PlatformEvent::RawKeyDown)
         keyDownEvent.disambiguateKeyDownEvent(PlatformEvent::RawKeyDown);
-    RefPtrWillBeRawPtr<KeyboardEvent> keydown = KeyboardEvent::create(keyDownEvent, m_frame->document()->domWindow());
+    RawPtr<KeyboardEvent> keydown = KeyboardEvent::create(keyDownEvent, m_frame->document()->domWindow());
     if (matchedAnAccessKey)
         keydown->setDefaultPrevented(true);
     keydown->setTarget(node);
 
     if (initialKeyEvent.type() == PlatformEvent::RawKeyDown) {
         if (!node->dispatchEvent(keydown))
             return eventToEventResult(keydown, false);
         // If frame changed as a result of keydown dispatch, then return true to avoid sending a subsequent keypress message to the new frame.
         bool changedFocusedFrame = m_frame->page() && m_frame != m_frame->page()->focusController().focusedOrMainFrame();
         if (changedFocusedFrame)
@@ skipping 11 matching lines @@
     // Focus may have changed during keydown handling, so refetch node.
     // But if we are dispatching a fake backward compatibility keypress, then we pretend that the keypress happened on the original node.
     node = eventTargetNodeForDocument(m_frame->document());
     if (!node)
         return WebInputEventResult::NotHandled;
 
     PlatformKeyboardEvent keyPressEvent = initialKeyEvent;
     keyPressEvent.disambiguateKeyDownEvent(PlatformEvent::Char);
     if (keyPressEvent.text().isEmpty())
         return WebInputEventResult::NotHandled;
-    RefPtrWillBeRawPtr<KeyboardEvent> keypress = KeyboardEvent::create(keyPressEvent, m_frame->document()->domWindow());
+    RawPtr<KeyboardEvent> keypress = KeyboardEvent::create(keyPressEvent, m_frame->document()->domWindow());
     keypress->setTarget(node);
     bool dispatchResult = node->dispatchEvent(keypress);
     return eventToEventResult(keypress, dispatchResult);
 }
 
 static WebFocusType focusDirectionForKey(const AtomicString& keyIdentifier)
 {
     DEFINE_STATIC_LOCAL(AtomicString, Down, ("Down", AtomicString::ConstructFromLiteral));
     DEFINE_STATIC_LOCAL(AtomicString, Up, ("Up", AtomicString::ConstructFromLiteral));
     DEFINE_STATIC_LOCAL(AtomicString, Left, ("Left", AtomicString::ConstructFromLiteral));
@@ skipping 224 matching lines @@
         return false;
 
     EventTarget* target;
     if (underlyingEvent)
         target = underlyingEvent->target();
     else
         target = eventTargetNodeForDocument(m_frame->document());
     if (!target)
         return false;
 
-    RefPtrWillBeRawPtr<TextEvent> event = TextEvent::create(m_frame->domWindow(), text, inputType);
+    RawPtr<TextEvent> event = TextEvent::create(m_frame->domWindow(), text, inputType);
     event->setUnderlyingEvent(underlyingEvent);
 
     target->dispatchEvent(event);
     return event->defaultHandled();
 }
 
 void EventHandler::defaultTextInputEventHandler(TextEvent* event)
 {
     if (m_frame->editor().handleTextEvent(event))
         event->setDefaultHandled();
@@ skipping 156 matching lines @@
     if (frame->view()) {
         IntRect rect = frame->view()->visibleContentRect(IncludeScrollbars);
         if (!rect.contains(roundedIntPoint(point)))
             return result;
     }
     frame->contentLayoutObject()->hitTest(result);
     return result;
 }
 
 void EventHandler::dispatchPointerEvents(const PlatformTouchEvent& event,
-    WillBeHeapVector<TouchInfo>& touchInfos)
+    HeapVector<TouchInfo>& touchInfos)
 {
     if (!RuntimeEnabledFeatures::pointerEventEnabled())
         return;
 
     // Iterate through the touch points, sending PointerEvents to the targets as required.
     for (unsigned i = 0; i < touchInfos.size(); ++i) {
         TouchInfo& touchInfo = touchInfos[i];
         const PlatformTouchPoint& touchPoint = touchInfo.point;
         const PlatformTouchPoint::State pointState = touchPoint.state();
 
 
         if (pointState == PlatformTouchPoint::TouchStationary || !touchInfo.knownTarget)
             continue;
 
         bool pointerReleasedOrCancelled = pointState == PlatformTouchPoint::TouchReleased
             || pointState == PlatformTouchPoint::TouchCancelled;
 
-        RefPtrWillBeRawPtr<PointerEvent> pointerEvent = m_pointerEventManager.create(
+        RawPtr<PointerEvent> pointerEvent = m_pointerEventManager.create(
             pointerEventNameForTouchPointState(pointState),
             touchPoint, event.modifiers(),
             touchInfo.adjustedRadius.width(), touchInfo.adjustedRadius.height(),
             touchInfo.adjustedPagePoint.x(), touchInfo.adjustedPagePoint.y());
 
         // TODO(nzolghadr): crbug.com/579553 dealing with implicit touch capturing vs pointer event capturing
         touchInfo.touchTarget->dispatchEvent(pointerEvent.get());
 
         touchInfo.consumed = pointerEvent->defaultPrevented() || pointerEvent->defaultHandled();
 
         // Remove the released/cancelled id at the end to correctly determine primary id above.
         if (pointerReleasedOrCancelled)
             m_pointerEventManager.remove(pointerEvent);
     }
 }
 
-void EventHandler::sendPointerCancels(WillBeHeapVector<TouchInfo>& touchInfos)
+void EventHandler::sendPointerCancels(HeapVector<TouchInfo>& touchInfos)
 {
     if (!RuntimeEnabledFeatures::pointerEventEnabled())
         return;
 
     for (unsigned i = 0; i < touchInfos.size(); ++i) {
         TouchInfo& touchInfo = touchInfos[i];
         const PlatformTouchPoint& point = touchInfo.point;
         const PlatformTouchPoint::State pointState = point.state();
 
         if (pointState == PlatformTouchPoint::TouchReleased
             || pointState == PlatformTouchPoint::TouchCancelled)
             continue;
 
-        RefPtrWillBeRawPtr<PointerEvent> pointerEvent = m_pointerEventManager.createPointerCancel(point);
+        RawPtr<PointerEvent> pointerEvent = m_pointerEventManager.createPointerCancel(point);
 
         // TODO(nzolghadr): crbug.com/579553 dealing with implicit touch capturing vs pointer event capturing
         touchInfo.touchTarget->dispatchEvent(pointerEvent.get());
 
         m_pointerEventManager.remove(pointerEvent);
     }
 }
 
 namespace {
 
 // Defining this class type local to dispatchTouchEvents() and annotating
 // it with STACK_ALLOCATED(), runs into MSVC(VS 2013)'s C4822 warning
 // that the local class doesn't provide a local definition for 'operator new'.
 // Which it intentionally doesn't and shouldn't.
 //
 // Work around such toolchain bugginess by lifting out the type, thereby
 // taking it out of C4822's reach.
 class ChangedTouches final {
     STACK_ALLOCATED();
 public:
     // The touches corresponding to the particular change state this struct
     // instance represents.
-    RefPtrWillBeMember<TouchList> m_touches;
+    Member<TouchList> m_touches;
 
-    using EventTargetSet = WillBeHeapHashSet<RefPtrWillBeMember<EventTarget>>;
+    using EventTargetSet = HeapHashSet<Member<EventTarget>>;
     // Set of targets involved in m_touches.
     EventTargetSet m_targets;
 };
 
 } // namespace
 
 WebInputEventResult EventHandler::dispatchTouchEvents(const PlatformTouchEvent& event,
-    WillBeHeapVector<TouchInfo>& touchInfos, bool freshTouchEvents, bool allTouchReleased)
+    HeapVector<TouchInfo>& touchInfos, bool freshTouchEvents, bool allTouchReleased)
 {
     // Build up the lists to use for the 'touches', 'targetTouches' and
     // 'changedTouches' attributes in the JS event. See
     // http://www.w3.org/TR/touch-events/#touchevent-interface for how these
     // lists fit together.
 
     // Holds the complete set of touches on the screen.
-    RefPtrWillBeRawPtr<TouchList> touches = TouchList::create();
+    RawPtr<TouchList> touches = TouchList::create();
 
     // A different view on the 'touches' list above, filtered and grouped by
     // event target. Used for the 'targetTouches' list in the JS event.
-    using TargetTouchesHeapMap = WillBeHeapHashMap<EventTarget*, RefPtrWillBeMember<TouchList>>;
+    using TargetTouchesHeapMap = HeapHashMap<EventTarget*, Member<TouchList>>;
     TargetTouchesHeapMap touchesByTarget;
 
     // Array of touches per state, used to assemble the 'changedTouches' list.
     ChangedTouches changedTouches[PlatformTouchPoint::TouchStateEnd];
 
     for (unsigned i = 0; i < touchInfos.size(); ++i) {
         const TouchInfo& touchInfo = touchInfos[i];
         const PlatformTouchPoint& point = touchInfo.point;
         PlatformTouchPoint::State pointState = point.state();
 
         if (touchInfo.consumed)
             continue;
 
-        RefPtrWillBeRawPtr<Touch> touch = Touch::create(
+        RawPtr<Touch> touch = Touch::create(
             touchInfo.targetFrame.get(),
             touchInfo.touchTarget.get(),
             point.id(),
             point.screenPos(),
             touchInfo.adjustedPagePoint,
             touchInfo.adjustedRadius,
             point.rotationAngle(),
             point.force());
 
         // Ensure this target's touch list exists, even if it ends up empty, so
@@ skipping 35 matching lines @@
 
     // Now iterate through the changedTouches list and m_targets within it, sending
     // TouchEvents to the targets as required.
     for (unsigned state = 0; state != PlatformTouchPoint::TouchStateEnd; ++state) {
         if (!changedTouches[state].m_touches)
             continue;
 
         const AtomicString& eventName(touchEventNameForTouchPointState(static_cast<PlatformTouchPoint::State>(state)));
         for (const auto& eventTarget : changedTouches[state].m_targets) {
             EventTarget* touchEventTarget = eventTarget.get();
-            RefPtrWillBeRawPtr<TouchEvent> touchEvent = TouchEvent::create(
+            RawPtr<TouchEvent> touchEvent = TouchEvent::create(
                 touches.get(), touchesByTarget.get(touchEventTarget), changedTouches[state].m_touches.get(),
                 eventName, touchEventTarget->toNode()->document().domWindow(),
                 event.modifiers(), event.cancelable(), event.causesScrollingIfUncanceled(), event.timestamp());
 
             bool dispatchResult = touchEventTarget->dispatchEvent(touchEvent.get());
             eventResult = mergeEventResult(eventResult, eventToEventResult(touchEvent, dispatchResult));
         }
     }
 
     return eventResult;
@@ skipping 98 matching lines @@
     // this work.
     if (!m_touchSequenceDocument || !m_touchSequenceDocument->frameHost() || !hasTouchHandlers(m_touchSequenceDocument->frameHost()->eventHandlerRegistry()) || !m_touchSequenceDocument->frame()) {
         if (allTouchReleased) {
             m_touchSequenceDocument.clear();
             m_touchSequenceUserGestureToken.clear();
         }
         return WebInputEventResult::NotHandled;
     }
 
     // Compute and store the common info used by both PointerEvent and TouchEvent.
-    WillBeHeapVector<TouchInfo> touchInfos(points.size());
+    HeapVector<TouchInfo> touchInfos(points.size());
 
     for (unsigned i = 0; i < points.size(); ++i) {
         const PlatformTouchPoint& point = points[i];
         PlatformTouchPoint::State pointState = point.state();
-        RefPtrWillBeRawPtr<EventTarget> touchTarget = nullptr;
+        RawPtr<EventTarget> touchTarget = nullptr;
 
         if (pointState == PlatformTouchPoint::TouchReleased || pointState == PlatformTouchPoint::TouchCancelled) {
             // The target should be the original target for this touch, so get
             // it from the hashmap. As it's a release or cancel we also remove
             // it from the map.
             touchTarget = m_targetForTouchID.take(point.id());
         } else {
             // No hittest is performed on move or stationary, since the target
             // is not allowed to change anyway.
             touchTarget = m_targetForTouchID.get(point.id());
@@ skipping 139 matching lines @@
 PlatformEvent::Modifiers EventHandler::accessKeyModifiers()
 {
 #if OS(MACOSX)
     return static_cast<PlatformEvent::Modifiers>(PlatformEvent::CtrlKey | PlatformEvent::AltKey);
 #else
     return PlatformEvent::AltKey;
 #endif
 }
 
 } // namespace blink