Move and rename RenderReplaced and RenderHTMLCanvas to Layout{Replaced,HTMLCanvas}.

Source/core/rendering/RenderPart.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 2000 Simon Hausmann <hausmann@kde.org>
  *           (C) 2000 Stefan Schimanski (1Stein@gmx.de)
  * Copyright (C) 2004, 2005, 2006, 2009 Apple Inc. All rights reserved.
  * Copyright (C) Research In Motion Limited 2011. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
@@ skipping 22 matching lines @@
 #include "core/layout/Layer.h"
 #include "core/paint/BoxPainter.h"
 #include "core/paint/PartPainter.h"
 #include "core/plugins/PluginView.h"
 #include "core/rendering/RenderView.h"
 #include "core/rendering/svg/RenderSVGRoot.h"
 
 namespace blink {
 
 RenderPart::RenderPart(Element* element)
-    : RenderReplaced(element)
+    : LayoutReplaced(element)
     // Reference counting is used to prevent the part from being destroyed
     // while inside the Widget code, which might not be able to handle that.
     , m_refCount(1)
 {
     ASSERT(element);
     frameView()->addPart(this);
     setInline(false);
 }
 
 void RenderPart::deref()
 {
     if (--m_refCount <= 0)
         postDestroy();
 }
 
 void RenderPart::willBeDestroyed()
 {
     frameView()->removePart(this);
 
     if (AXObjectCache* cache = document().existingAXObjectCache()) {
         cache->childrenChanged(this->parent());
         cache->remove(this);
     }
 
     Element* element = toElement(node());
     if (element && element->isFrameOwnerElement())
         toHTMLFrameOwnerElement(element)->setWidget(nullptr);
 
-    RenderReplaced::willBeDestroyed();
+    LayoutReplaced::willBeDestroyed();
 }
 
 void RenderPart::destroy()
 {
     willBeDestroyed();
     clearNode();
     deref();
 }
 
 RenderPart::~RenderPart()
 {
     ASSERT(m_refCount <= 0);
 }
 
 Widget* RenderPart::widget() const
 {
     // Plugin widgets are stored in their DOM node. This includes HTMLAppletElement.
     Element* element = toElement(node());
 
     if (element && element->isFrameOwnerElement())
         return toHTMLFrameOwnerElement(element)->ownedWidget();
 
     return 0;
 }
 
 LayerType RenderPart::layerTypeRequired() const
 {
-    LayerType type = RenderReplaced::layerTypeRequired();
+    LayerType type = LayoutReplaced::layerTypeRequired();
     if (type != NoLayer)
         return type;
     return ForcedLayer;
 }
 
 bool RenderPart::requiresAcceleratedCompositing() const
 {
     // There are two general cases in which we can return true. First, if this is a plugin
     // renderer and the plugin has a layer, then we need a layer. Second, if this is
     // a renderer with a contentDocument and that document needs a layer, then we need
@@ skipping 11 matching lines @@
     if (Document* contentDocument = element->contentDocument()) {
         if (RenderView* view = contentDocument->renderView())
             return view->usesCompositing();
     }
 
     return false;
 }
 
 bool RenderPart::needsPreferredWidthsRecalculation() const
 {
-    if (RenderReplaced::needsPreferredWidthsRecalculation())
+    if (LayoutReplaced::needsPreferredWidthsRecalculation())
         return true;
     return embeddedContentBox();
 }
 
 bool RenderPart::nodeAtPointOverWidget(const HitTestRequest& request, HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction action)
 {
     bool hadResult = result.innerNode();
-    bool inside = RenderReplaced::nodeAtPoint(request, result, locationInContainer, accumulatedOffset, action);
+    bool inside = LayoutReplaced::nodeAtPoint(request, result, locationInContainer, accumulatedOffset, action);
 
     // Check to see if we are really over the widget itself (and not just in the border/padding area).
     if ((inside || result.isRectBasedTest()) && !hadResult && result.innerNode() == node())
         result.setIsOverWidget(contentBoxRect().contains(result.localPoint()));
     return inside;
 }
 
 bool RenderPart::nodeAtPoint(const HitTestRequest& request, HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction action)
 {
     if (!widget() || !widget()->isFrameView() || !request.allowsChildFrameContent())
@@ skipping 25 matching lines @@
 
 CompositingReasons RenderPart::additionalCompositingReasons() const
 {
     if (requiresAcceleratedCompositing())
         return CompositingReasonIFrame;
     return CompositingReasonNone;
 }
 
 void RenderPart::styleDidChange(StyleDifference diff, const LayoutStyle* oldStyle)
 {
-    RenderReplaced::styleDidChange(diff, oldStyle);
+    LayoutReplaced::styleDidChange(diff, oldStyle);
     Widget* widget = this->widget();
 
     if (!widget)
         return;
 
     // If the iframe has custom scrollbars, recalculate their style.
     if (widget && widget->isFrameView())
         toFrameView(widget)->recalculateCustomScrollbarStyle();
 
     if (style()->visibility() != VISIBLE) {
@@ skipping 19 matching lines @@
 {
     PartPainter(*this).paintContents(paintInfo, paintOffset);
 }
 
 CursorDirective RenderPart::getCursor(const LayoutPoint& point, Cursor& cursor) const
 {
     if (widget() && widget()->isPluginView()) {
         // A plug-in is responsible for setting the cursor when the pointer is over it.
         return DoNotSetCursor;
     }
-    return RenderReplaced::getCursor(point, cursor);
+    return LayoutReplaced::getCursor(point, cursor);
 }
 
 void RenderPart::updateOnWidgetChange()
 {
     Widget* widget = this->widget();
     if (!widget)
         return;
 
     if (!style())
         return;
@@ skipping 72 matching lines @@
     if (widget->frameRect() == newFrame)
         return false;
 
     RefPtrWillBeRawPtr<RenderPart> protector(this);
     RefPtrWillBeRawPtr<Node> protectedNode(node());
     widget->setFrameRect(newFrame);
     return widget->frameRect().size() != newFrame.size();
 }
 
 }