Move rendering/RenderProgress to layout/LayoutProgress

Source/core/html/HTMLProgressElement.cpp

 /*
  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
  *
  * 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
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 13 matching lines @@
 
 #include "bindings/core/v8/ExceptionMessages.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ExceptionStatePlaceholder.h"
 #include "core/HTMLNames.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/shadow/ShadowRoot.h"
 #include "core/frame/UseCounter.h"
 #include "core/html/parser/HTMLParserIdioms.h"
 #include "core/html/shadow/ProgressShadowElement.h"
-#include "core/rendering/RenderProgress.h"
+#include "core/layout/LayoutProgress.h"
 
 namespace blink {
 
 using namespace HTMLNames;
 
 const double HTMLProgressElement::IndeterminatePosition = -1;
 const double HTMLProgressElement::InvalidPosition = -2;
 
 HTMLProgressElement::HTMLProgressElement(Document& document)
     : LabelableElement(progressTag, document)
@@ skipping 10 matching lines @@
 {
     RefPtrWillBeRawPtr<HTMLProgressElement> progress = adoptRefWillBeNoop(new HTMLProgressElement(document));
     progress->ensureClosedShadowRoot();
     return progress.release();
 }
 
 LayoutObject* HTMLProgressElement::createRenderer(const LayoutStyle& style)
 {
     if (!style.hasAppearance() || hasOpenShadowRoot())
         return LayoutObject::createObject(this, style);
-    return new RenderProgress(this);
+    return new LayoutProgress(this);
 }
 
-RenderProgress* HTMLProgressElement::renderProgress() const
+LayoutProgress* HTMLProgressElement::layoutProgress() const
 {
     if (renderer() && renderer()->isProgress())
-        return toRenderProgress(renderer());
+        return toLayoutProgress(renderer());
 
     LayoutObject* layoutObject = closedShadowRoot()->firstChild()->renderer();
     ASSERT_WITH_SECURITY_IMPLICATION(!layoutObject || layoutObject->isProgress());
-    return toRenderProgress(layoutObject);
+    return toLayoutProgress(layoutObject);
 }
 
 void HTMLProgressElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
 {
     if (name == valueAttr)
         didElementStateChange();
     else if (name == maxAttr)
         didElementStateChange();
     else
         LabelableElement::parseAttribute(name, value);
 }
 
 void HTMLProgressElement::attach(const AttachContext& context)
 {
     LabelableElement::attach(context);
-    if (RenderProgress* render = renderProgress())
+    if (LayoutProgress* render = layoutProgress())
         render->updateFromElement();
 }
 
 double HTMLProgressElement::value() const
 {
     double value = getFloatingPointAttribute(valueAttr);
     // Otherwise, if the parsed value was greater than or equal to the maximum
     // value, then the current value of the progress bar is the maximum value
     // of the progress bar. Otherwise, if parsing the value attribute's value
     // resulted in an error, or a number less than or equal to zero, then the
@@ skipping 29 matching lines @@
 }
 
 bool HTMLProgressElement::isDeterminate() const
 {
     return fastHasAttribute(valueAttr);
 }
 
 void HTMLProgressElement::didElementStateChange()
 {
     m_value->setWidthPercentage(position() * 100);
-    if (RenderProgress* render = renderProgress()) {
+    if (LayoutProgress* render = layoutProgress()) {
         bool wasDeterminate = render->isDeterminate();
         render->updateFromElement();
         if (wasDeterminate != isDeterminate())
             pseudoStateChanged(CSSSelector::PseudoIndeterminate);
     }
 }
 
 void HTMLProgressElement::didAddClosedShadowRoot(ShadowRoot& root)
 {
     ASSERT(!m_value);
@@ skipping 24 matching lines @@
     lazyReattachIfAttached();
 }
 
 DEFINE_TRACE(HTMLProgressElement)
 {
     visitor->trace(m_value);
     LabelableElement::trace(visitor);
 }
 
 } // namespace