Move rendering/RenderObject to layout/LayoutObject.

Source/core/page/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 656 matching lines @@
     if (!m_mousePressed)
         return false;
 
     if (handleDrag(event, DragInitiator::Mouse))
         return true;
 
     Node* targetNode = event.innerNode();
     if (!targetNode)
         return false;
 
-    RenderObject* renderer = targetNode->renderer();
+    LayoutObject* renderer = targetNode->renderer();
     if (!renderer) {
         Node* parent = NodeRenderingTraversal::parent(*targetNode);
         if (!parent)
             return false;
 
         renderer = parent->renderer();
         if (!renderer || !renderer->isListBox())
             return false;
     }
 
@@ skipping 46 matching lines @@
     if (targetPosition.isNull())
         return;
 
     // Restart the selection if this is the first mouse move. This work is usually
     // done in handleMousePressEvent, but not if the mouse press was on an existing selection.
     VisibleSelection newSelection = m_frame->selection().selection();
 
     // Special case to limit selection to the containing block for SVG text.
     // FIXME: Isn't there a better non-SVG-specific way to do this?
     if (Node* selectionBaseNode = newSelection.base().deprecatedNode())
-        if (RenderObject* selectionBaseRenderer = selectionBaseNode->renderer())
+        if (LayoutObject* selectionBaseRenderer = selectionBaseNode->renderer())
             if (selectionBaseRenderer->isSVGText())
                 if (target->renderer()->containingBlock() != selectionBaseRenderer->containingBlock())
                     return;
 
     if (m_selectionInitiationState == HaveNotStartedSelection && !dispatchSelectStart(target))
         return;
 
     if (m_selectionInitiationState != ExtendedSelection) {
         // Always extend selection here because it's caused by a mouse drag
         m_selectionInitiationState = ExtendedSelection;
@@ skipping 73 matching lines @@
     if (event.event().button() == MiddleButton && !event.isOverLink()) {
         // Ignore handled, since we want to paste to where the caret was placed anyway.
         handled = handlePasteGlobalSelection(event.event()) || handled;
     }
 
     return handled;
 }
 
 #if OS(WIN)
 
-void EventHandler::startPanScrolling(RenderObject* renderer)
+void EventHandler::startPanScrolling(LayoutObject* renderer)
 {
     if (!renderer->isBox())
         return;
     AutoscrollController* controller = autoscrollController();
     if (!controller)
         return;
     controller->startPanScrolling(toRenderBox(renderer), lastKnownMousePosition());
     invalidateClick();
 }
 
@@ skipping 121 matching lines @@
 IntPoint EventHandler::lastKnownMousePosition() const
 {
     return m_lastKnownMousePosition;
 }
 
 static LocalFrame* subframeForTargetNode(Node* node)
 {
     if (!node)
         return nullptr;
 
-    RenderObject* renderer = node->renderer();
+    LayoutObject* renderer = node->renderer();
     if (!renderer || !renderer->isRenderPart())
         return nullptr;
 
     // FIXME: This explicit check is needed only until RemoteFrames have RemoteFrameViews.
     if (isHTMLFrameElementBase(node) && toHTMLFrameElementBase(node)->contentFrame() && toHTMLFrameElementBase(node)->contentFrame()->isRemoteFrameTemporary())
         return nullptr;
 
     Widget* widget = toRenderPart(renderer)->widget();
     if (!widget || !widget->isFrameView())
         return nullptr;
@@ skipping 65 matching lines @@
         return NoCursorChange;
 #if OS(WIN)
     if (panScrollInProgress())
         return NoCursorChange;
 #endif
 
     Node* node = result.innerPossiblyPseudoNode();
     if (!node)
         return selectAutoCursor(result, node, iBeamCursor());
 
-    RenderObject* renderer = node->renderer();
+    LayoutObject* renderer = node->renderer();
     RenderStyle* style = renderer ? renderer->style() : nullptr;
 
     if (renderer) {
         Cursor overrideCursor;
         switch (renderer->getCursor(roundedIntPoint(result.localPoint()), overrideCursor)) {
         case SetCursorBasedOnStyle:
             break;
         case SetCursor:
             return overrideCursor;
         case DoNotSetCursor:
@@ skipping 113 matching lines @@
 }
 
 OptionalCursor EventHandler::selectAutoCursor(const HitTestResult& result, Node* node, const Cursor& iBeam)
 {
     bool editable = (node && node->hasEditableStyle());
 
     if (useHandCursor(node, result.isOverLink()))
         return handCursor();
 
     bool inResizer = false;
-    RenderObject* renderer = node ? node->renderer() : nullptr;
+    LayoutObject* renderer = node ? node->renderer() : nullptr;
     if (renderer && m_frame->view()) {
         Layer* layer = renderer->enclosingLayer();
         inResizer = layer->scrollableArea() && layer->scrollableArea()->isPointInResizeControl(result.roundedPointInMainFrame(), ResizerForPointer);
     }
 
     // During selection, use an I-beam no matter what we're over.
     // If a drag may be starting or we're capturing mouse events for a particular node, don't treat this as a selection.
     if (m_mousePressed && m_mouseDownMayStartSelect
         && !m_mouseDownMayStartDrag
         && m_frame->selection().isCaretOrRange()
@@ skipping 131 matching lines @@
     }
 
     return swallowEvent;
 }
 
 static Layer* layerForNode(Node* node)
 {
     if (!node)
         return nullptr;
 
-    RenderObject* renderer = node->renderer();
+    LayoutObject* renderer = node->renderer();
     if (!renderer)
         return nullptr;
 
     Layer* layer = renderer->enclosingLayer();
     if (!layer)
         return nullptr;
 
     return layer;
 }
 
@@ skipping 656 matching lines @@
         if (m_latchedWheelEventNode)
             m_latchedWheelEventNode = nullptr;
         if (m_previousWheelScrolledNode)
             m_previousWheelScrolledNode = nullptr;
 
         isOverWidget = result.isOverWidget();
     }
 
     if (node) {
         // Figure out which view to send the event to.
-        RenderObject* target = node->renderer();
+        LayoutObject* target = node->renderer();
 
         if (isOverWidget && target && target->isRenderPart()) {
             Widget* widget = toRenderPart(target)->widget();
             if (widget && passWheelEventToWidget(event, *widget))
                 RETURN_WHEEL_EVENT_HANDLED();
         }
 
         if (node && !node->dispatchWheelEvent(event))
             RETURN_WHEEL_EVENT_HANDLED();
     }
@@ skipping 392 matching lines @@
         if (m_resizeScrollableArea && m_resizeScrollableArea->inResizeMode()) {
             m_resizeScrollableArea->setInResizeMode(false);
             m_resizeScrollableArea = nullptr;
             return false;
         }
     }
 
     return false;
 }
 
-bool EventHandler::passScrollGestureEventToWidget(const PlatformGestureEvent& gestureEvent, RenderObject* renderer)
+bool EventHandler::passScrollGestureEventToWidget(const PlatformGestureEvent& gestureEvent, LayoutObject* renderer)
 {
     ASSERT(gestureEvent.isScrollEvent());
 
     if (!m_lastGestureScrollOverWidget)
         return false;
 
     if (!renderer || !renderer->isRenderPart())
         return false;
 
     Widget* widget = toRenderPart(renderer)->widget();
@@ skipping 47 matching lines @@
 bool EventHandler::handleGestureScrollUpdate(const PlatformGestureEvent& gestureEvent)
 {
     ASSERT(gestureEvent.type() == PlatformEvent::GestureScrollUpdate);
 
     FloatSize delta(gestureEvent.deltaX(), gestureEvent.deltaY());
     if (delta.isZero())
         return false;
 
     Node* node = m_scrollGestureHandlingNode.get();
     if (node) {
-        RenderObject* renderer = node->renderer();
+        LayoutObject* renderer = node->renderer();
         if (!renderer)
             return false;
 
         RefPtrWillBeRawPtr<FrameView> protector(m_frame->view());
 
         Node* stopNode = nullptr;
 
         // Try to send the event to the correct view.
         if (passScrollGestureEventToWidget(gestureEvent, renderer)) {
             if (gestureEvent.preventPropagation())
@@ skipping 782 matching lines @@
 {
     // The DataTransfer would only be non-empty if we missed a dragEnd.
     // Clear it anyway, just to make sure it gets numbified.
     clearDragDataTransfer();
 
     dragState().m_dragDataTransfer = createDraggingDataTransfer();
 
     // Check to see if this a DOM based drag, if it is get the DOM specified drag
     // image and offset
     if (dragState().m_dragType == DragSourceActionDHTML) {
-        if (RenderObject* renderer = dragState().m_dragSrc->renderer()) {
+        if (LayoutObject* renderer = dragState().m_dragSrc->renderer()) {
             FloatPoint absPos = renderer->localToAbsolute(FloatPoint(), UseTransforms);
             IntSize delta = m_mouseDownPos - roundedIntPoint(absPos);
             dragState().m_dragDataTransfer->setDragImageElement(dragState().m_dragSrc.get(), IntPoint(delta));
         } else {
             // The renderer has disappeared, this can happen if the onStartDrag handler has hidden
             // the element in some way. In this case we just kill the drag.
             return false;
         }
     }
 
@@ skipping 146 matching lines @@
 
 void EventHandler::defaultEscapeEventHandler(KeyboardEvent* event)
 {
     if (HTMLDialogElement* dialog = m_frame->document()->activeModalDialog())
         dialog->dispatchEvent(Event::createCancelable(EventTypeNames::cancel));
 }
 
 void EventHandler::capsLockStateMayHaveChanged()
 {
     if (Element* element = m_frame->document()->focusedElement()) {
-        if (RenderObject* r = element->renderer()) {
+        if (LayoutObject* r = element->renderer()) {
             if (r->isTextField())
                 toRenderTextControlSingleLine(r)->capsLockStateMayHaveChanged();
         }
     }
 }
 
 void EventHandler::setFrameWasScrolledByUser()
 {
     if (FrameView* view = m_frame->view())
         view->setWasScrolledByUser(true);
@@ skipping 319 matching lines @@
     return action1 & action2;
 }
 
 TouchAction EventHandler::computeEffectiveTouchAction(const Node& node)
 {
     // Start by permitting all actions, then walk the elements supporting
     // touch-action from the target node up to the nearest scrollable ancestor
     // and exclude any prohibited actions.
     TouchAction effectiveTouchAction = TouchActionAuto;
     for (const Node* curNode = &node; curNode; curNode = NodeRenderingTraversal::parent(*curNode)) {
-        if (RenderObject* renderer = curNode->renderer()) {
+        if (LayoutObject* renderer = curNode->renderer()) {
             if (renderer->supportsTouchAction()) {
                 TouchAction action = renderer->style()->touchAction();
                 effectiveTouchAction = intersectTouchAction(action, effectiveTouchAction);
                 if (effectiveTouchAction == TouchActionNone)
                     break;
             }
 
             // If we've reached an ancestor that supports a touch action, search no further.
             if (renderer->isBox() && toRenderBox(renderer)->scrollsOverflow())
                 break;
@@ skipping 75 matching lines @@
 unsigned EventHandler::accessKeyModifiers()
 {
 #if OS(MACOSX)
     return PlatformEvent::CtrlKey | PlatformEvent::AltKey;
 #else
     return PlatformEvent::AltKey;
 #endif
 }
 
 } // namespace blink