Oilpan: Remove WillBe types (part 13)

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 966 matching lines @@
 WebInputEventResult EventHandler::handleMousePressEvent(const PlatformMouseEvent& mouseEvent)
 {
     TRACE_EVENT0("blink", "EventHandler::handleMousePressEvent");
 
     // For 4th/5th button in the mouse since Chrome does not yet send
     // button value to Blink but in some cases it does send the event.
     // This check is needed to suppress such an event (crbug.com/574959)
     if (mouseEvent.button() == NoButton)
         return WebInputEventResult::HandledSuppressed;
 
-    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 15 matching lines @@
     MouseEventWithHitTestResults mev = m_frame->document()->prepareMouseEvent(request, documentPoint, mouseEvent);
 
     if (!mev.innerNode()) {
         invalidateClick();
         return WebInputEventResult::NotHandled;
     }
 
     m_mousePressNode = mev.innerNode();
     m_frame->document()->setSequentialFocusNavigationStartingPoint(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 105 matching lines @@
             return scrollableArea;
     }
 
     return nullptr;
 }
 
 WebInputEventResult EventHandler::handleMouseMoveEvent(const PlatformMouseEvent& event)
 {
     TRACE_EVENT0("blink", "EventHandler::handleMouseMoveEvent");
 
-    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");
 
-    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(mev.event());
 
     if (newSubframe) {
         // Update over/out state before passing the event to the subframe.
         updateMouseEventTargetNodeAndSendEvents(mev.innerNode(), mev.event(), true);
 
         // Event dispatch in updateMouseEventTargetNodeAndSendEvents may have caused the subframe of the target
@@ skipping 42 matching lines @@
 WebInputEventResult EventHandler::handleMouseReleaseEvent(const PlatformMouseEvent& mouseEvent)
 {
     TRACE_EVENT0("blink", "EventHandler::handleMouseReleaseEvent");
 
     // For 4th/5th button in the mouse since Chrome does not yet send
     // button value to Blink but in some cases it does send the event.
     // This check is needed to suppress such an event (crbug.com/574959)
     if (mouseEvent.button() == NoButton)
         return WebInputEventResult::HandledSuppressed;
 
-    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.getModifiers(),
         0, MouseEvent::platformModifiersToButtons(event.getModifiers()), nullptr, event.timestamp(), dataTransfer, event.getSyntheticEventType());
 
     return toWebInputEventResult(dragTarget->dispatchEvent(me.get()));
 }
 
 static bool targetIsFrame(Node* target, LocalFrame*& frame)
@@ skipping 52 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);
 }
 
-PassRefPtrWillBeRawPtr<Node> EventHandler::updateMouseEventTargetNode(Node* targetNode,
+RawPtr<Node> 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 21 matching lines @@
         lastNodeUnderMouse = nullptr;
         m_lastScrollbarUnderMouse = nullptr;
     }
 
     return lastNodeUnderMouse;
 }
 
 void EventHandler::updateMouseEventTargetNodeAndSendEvents(Node* targetNode,
     const PlatformMouseEvent& mouseEvent, bool isFrameBoundaryTransition)
 {
-    RefPtrWillBeRawPtr<Node> lastNodeUnderMouse = updateMouseEventTargetNode(targetNode, mouseEvent);
+    RawPtr<Node> lastNodeUnderMouse = updateMouseEventTargetNode(targetNode, mouseEvent);
     m_pointerEventManager.sendMouseAndPossiblyPointerNodeTransitionEvents(
         lastNodeUnderMouse, m_nodeUnderMouse, mouseEvent,
         m_frame->document()->domWindow(), isFrameBoundaryTransition);
 }
 
 WebInputEventResult EventHandler::dispatchMouseEvent(const AtomicString& eventType, Node* targetNode, int clickCount, const PlatformMouseEvent& mouseEvent)
 {
     updateMouseEventTargetNodeAndSendEvents(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);
     return toWebInputEventResult(m_nodeUnderMouse->dispatchEvent(event));
 }
 
 bool EventHandler::isPointerEventActive(int pointerId)
 {
     return m_pointerEventManager.isActive(pointerId);
 }
 
 void EventHandler::setPointerCapture(int pointerId, EventTarget* target)
 {
@@ skipping 11 matching lines @@
     m_pointerEventManager.elementRemoved(target);
 }
 
 // TODO(mustaq): Make PE drive ME dispatch & bookkeeping in EventHandler.
 WebInputEventResult EventHandler::updatePointerTargetAndDispatchEvents(const AtomicString& mouseEventType, Node* targetNode, int clickCount, const PlatformMouseEvent& mouseEvent)
 {
     ASSERT(mouseEventType == EventTypeNames::mousedown
         || mouseEventType == EventTypeNames::mousemove
         || mouseEventType == EventTypeNames::mouseup);
 
-    RefPtrWillBeRawPtr<Node> lastNodeUnderMouse = updateMouseEventTargetNode(targetNode, mouseEvent);
+    RawPtr<Node> lastNodeUnderMouse = updateMouseEventTargetNode(targetNode, mouseEvent);
 
     return m_pointerEventManager.sendMousePointerEvent(
         m_nodeUnderMouse, mouseEventType, clickCount, mouseEvent, nullptr,
         m_frame->document()->domWindow(), lastNodeUnderMouse);
 }
 
 WebInputEventResult EventHandler::handleMouseFocus(const MouseEventWithHitTestResults& targetedEvent, InputDeviceCapabilities* sourceCapabilities)
 {
     // If clicking on a frame scrollbar, do not mess up with content focus.
     if (targetedEvent.hitTestResult().scrollbar() && !m_frame->contentLayoutItem().isNull()) {
@@ skipping 78 matching lines @@
     return false;
 }
 
 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 17 matching lines @@
         }
         // TODO(dtapuska): Remove this once wheel gesture scroll has
         // been enabled everywhere; as we can just return early.
         // http://crbug.com/568183
         // Don't propagate the DOM event into the parent iframe
         // but do dispatch the scroll event.
         sendDOMEvent = false;
     }
 
     if (node) {
-        RefPtrWillBeRawPtr<WheelEvent> domEvent = WheelEvent::create(event, node->document().domWindow());
+        RawPtr<WheelEvent> domEvent = WheelEvent::create(event, node->document().domWindow());
         if (sendDOMEvent) {
             DispatchEventResult domEventResult = node->dispatchEvent(domEvent);
             if (domEventResult != DispatchEventResult::NotCanceled)
                 return toWebInputEventResult(domEventResult);
         } else {
             defaultWheelEventHandler(node, domEvent.get());
             if (domEvent->defaultHandled())
                 return WebInputEventResult::HandledSystem;
         }
     }
@@ skipping 105 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 shouldUpdateCapture = false;
         if (scrollbar->gestureEvent(gestureEvent, &shouldUpdateCapture)) {
             if (shouldUpdateCapture)
                 m_scrollbarHandlingScrollGesture = scrollbar;
             return WebInputEventResult::HandledSuppressed;
         }
     }
 
     if (eventTarget) {
-        RefPtrWillBeRawPtr<GestureEvent> gestureDomEvent = GestureEvent::create(eventTarget->document().domWindow(), gestureEvent);
+        RawPtr<GestureEvent> gestureDomEvent = GestureEvent::create(eventTarget->document().domWindow(), gestureEvent);
         if (gestureDomEvent.get()) {
             DispatchEventResult gestureDomEventResult = eventTarget->dispatchEvent(gestureDomEvent);
             if (gestureDomEventResult != DispatchEventResult::NotCanceled) {
                 ASSERT(gestureDomEventResult != DispatchEventResult::CanceledByEventHandler);
                 return toWebInputEventResult(gestureDomEventResult);
             }
         }
     }
 
     switch (gestureEvent.type()) {
@@ skipping 18 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 20 matching lines @@
                 m_scrollbarHandlingScrollGesture = scrollbar;
             return WebInputEventResult::HandledSuppressed;
         }
         m_scrollbarHandlingScrollGesture = nullptr;
     }
 
     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);
         if (gestureDomEvent.get()) {
             DispatchEventResult gestureDomEventResult = eventTarget->dispatchEvent(gestureDomEvent);
             if (gestureDomEventResult != DispatchEventResult::NotCanceled) {
                 ASSERT(gestureDomEventResult != DispatchEventResult::CanceledByEventHandler);
                 return toWebInputEventResult(gestureDomEventResult);
             }
         }
     }
 
     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()) {
             OwnPtr<ScrollStateData> scrollStateData = adoptPtr(new ScrollStateData());
             scrollStateData->is_ending = true;
             scrollStateData->is_in_inertial_phase = gestureEvent.inertial();
             scrollStateData->from_user_input = true;
             scrollStateData->is_direct_manipulation = true;
             scrollStateData->delta_consumed_for_scroll_sequence = m_deltaConsumedForScrollSequence;
-            RefPtrWillBeRawPtr<ScrollState> scrollState = ScrollState::create(scrollStateData.release());
+            RawPtr<ScrollState> scrollState = ScrollState::create(scrollStateData.release());
             customizedScroll(*node.get(), *scrollState);
         }
     }
 
     clearGestureScrollState();
     return WebInputEventResult::NotHandled;
 }
 
 WebInputEventResult EventHandler::handleGestureScrollBegin(const PlatformGestureEvent& gestureEvent)
 {
@@ skipping 20 matching lines @@
 
     passScrollGestureEventToWidget(gestureEvent, m_scrollGestureHandlingNode->layoutObject());
     if (RuntimeEnabledFeatures::scrollCustomizationEnabled()) {
         m_currentScrollChain.clear();
         OwnPtr<ScrollStateData> scrollStateData = adoptPtr(new ScrollStateData());
         scrollStateData->start_position_x = gestureEvent.position().x();
         scrollStateData->start_position_y = gestureEvent.position().y();
         scrollStateData->is_beginning = true;
         scrollStateData->from_user_input = true;
         scrollStateData->delta_consumed_for_scroll_sequence = m_deltaConsumedForScrollSequence;
-        RefPtrWillBeRawPtr<ScrollState> scrollState = ScrollState::create(scrollStateData.release());
+        RawPtr<ScrollState> scrollState = ScrollState::create(scrollStateData.release());
         customizedScroll(*m_scrollGestureHandlingNode.get(), *scrollState);
     } else {
         if (m_frame->isMainFrame())
             m_frame->host()->topControls().scrollBegin();
     }
     return WebInputEventResult::HandledSystem;
 }
 
 void EventHandler::resetOverscroll(bool didScrollX, bool didScrollY)
 {
@@ skipping 42 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());
 
         // 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;
         }
 
         if (handleScrollCustomization) {
             OwnPtr<ScrollStateData> scrollStateData = adoptPtr(new ScrollStateData());
             scrollStateData->delta_x = delta.width();
             scrollStateData->delta_y = delta.height();
             scrollStateData->velocity_x = velocity.width();
             scrollStateData->velocity_y = velocity.height();
             scrollStateData->should_propagate = !gestureEvent.preventPropagation();
             scrollStateData->is_in_inertial_phase = gestureEvent.inertial();
             scrollStateData->from_user_input = true;
             scrollStateData->delta_consumed_for_scroll_sequence = m_deltaConsumedForScrollSequence;
-            RefPtrWillBeRawPtr<ScrollState> scrollState = ScrollState::create(scrollStateData.release());
+            RawPtr<ScrollState> scrollState = ScrollState::create(scrollStateData.release());
             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.
                 ASSERT(m_previousGestureScrolledNode->isElementNode());
                 scrollState->setCurrentNativeScrollingElement(toElement(m_previousGestureScrolledNode.get()));
             }
             customizedScroll(*node, *scrollState);
             m_previousGestureScrolledNode = scrollState->currentNativeScrollingElement();
@@ skipping 61 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());
 
         return toWebInputEventResult(node->dispatchEvent(domEvent));
     }
 
     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);
 
     DispatchEventResult dispatchResult = node->dispatchEvent(keydown);
     if (dispatchResult != DispatchEventResult::NotCanceled)
         return toWebInputEventResult(dispatchResult);
     // If frame changed as a result of keydown dispatch, then return early 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)
         return WebInputEventResult::HandledSystem;
 
     if (initialKeyEvent.type() == PlatformEvent::RawKeyDown)
         return WebInputEventResult::NotHandled;
 
     // 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);
     return toWebInputEventResult(node->dispatchEvent(keypress));
 }
 
 static WebFocusType focusDirectionForKey(const AtomicString& keyIdentifier)
 {
     DEFINE_STATIC_LOCAL(AtomicString, Down, ("Down"));
     DEFINE_STATIC_LOCAL(AtomicString, Up, ("Up"));
     DEFINE_STATIC_LOCAL(AtomicString, Left, ("Left"));
     DEFINE_STATIC_LOCAL(AtomicString, Right, ("Right"));
@@ skipping 223 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() || event->defaultPrevented();
 }
 
 void EventHandler::defaultTextInputEventHandler(TextEvent* event)
 {
     if (m_frame->editor().handleTextEvent(event))
         event->setDefaultHandled();
@@ skipping 146 matching lines @@
     if (frame->view()) {
         IntRect rect = frame->view()->visibleContentRect(IncludeScrollbars);
         if (!rect.contains(roundedIntPoint(point)))
             return result;
     }
     frame->contentLayoutItem().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;
 
 
         if (touchPoint.state() == PlatformTouchPoint::TouchStationary
             || !touchInfo.knownTarget)
             continue;
 
         WebInputEventResult result =
             m_pointerEventManager.sendTouchPointerEvent(
             touchInfo.touchTarget, touchPoint, event.getModifiers(),
             touchInfo.adjustedRadius.width(), touchInfo.adjustedRadius.height(),
             touchInfo.adjustedPagePoint.x(), touchInfo.adjustedPagePoint.y());
         touchInfo.consumed = result != WebInputEventResult::NotHandled;
     }
 }
 
-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::TouchState pointState = point.state();
 
         if (pointState == PlatformTouchPoint::TouchReleased
@@ skipping 13 matching lines @@
 // 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::TouchState 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(),
             touchInfo.region);
 
@@ skipping 36 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::TouchState>(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.getModifiers(), event.cancelable(), event.causesScrollingIfUncanceled(), event.timestamp());
 
             eventResult = mergeEventResult(eventResult, toWebInputEventResult(touchEventTarget->dispatchEvent(touchEvent.get())));
         }
     }
 
     return eventResult;
 }
@@ skipping 104 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::TouchState pointState = point.state();
-        RefPtrWillBeRawPtr<EventTarget> touchTarget = nullptr;
+        RawPtr<EventTarget> touchTarget = nullptr;
         String regionID;
 
         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());
             regionID = m_regionForTouchID.take(point.id());
         } else {
             // No hittest is performed on move or stationary, since the target
@@ skipping 127 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