Replace WTF::move with WTFMove
[WebKit-https.git] / Source / WebCore / html / HTMLMeterElement.cpp
index e230ea6..36d27a7 100644 (file)
  */
 
 #include "config.h"
-#if ENABLE(METER_TAG)
+#if ENABLE(METER_ELEMENT)
 #include "HTMLMeterElement.h"
 
 #include "Attribute.h"
+#include "ElementIterator.h"
 #include "EventNames.h"
 #include "ExceptionCode.h"
 #include "FormDataList.h"
 #include "HTMLNames.h"
 #include "HTMLParserIdioms.h"
 #include "MeterShadowElement.h"
+#include "Page.h"
 #include "RenderMeter.h"
+#include "RenderTheme.h"
 #include "ShadowRoot.h"
-#include <wtf/StdLibExtras.h>
 
 namespace WebCore {
 
 using namespace HTMLNames;
 
-HTMLMeterElement::HTMLMeterElement(const QualifiedName& tagName, Document* document, HTMLFormElement* form)
-    : HTMLFormControlElement(tagName, document, form)
+HTMLMeterElement::HTMLMeterElement(const QualifiedName& tagName, Document& document)
+    : LabelableElement(tagName, document)
 {
     ASSERT(hasTagName(meterTag));
 }
@@ -48,137 +50,120 @@ HTMLMeterElement::~HTMLMeterElement()
 {
 }
 
-PassRefPtr<HTMLMeterElement> HTMLMeterElement::create(const QualifiedName& tagName, Document* document, HTMLFormElement* form)
+Ref<HTMLMeterElement> HTMLMeterElement::create(const QualifiedName& tagName, Document& document)
 {
-    RefPtr<HTMLMeterElement> meter = adoptRef(new HTMLMeterElement(tagName, document, form));
-    meter->createShadowSubtree();
+    Ref<HTMLMeterElement> meter = adoptRef(*new HTMLMeterElement(tagName, document));
+    meter->ensureUserAgentShadowRoot();
     return meter;
 }
 
-RenderObject* HTMLMeterElement::createRenderer(RenderArena* arena, RenderStyle*)
+RenderPtr<RenderElement> HTMLMeterElement::createElementRenderer(Ref<RenderStyle>&& style, const RenderTreePosition&)
 {
-    return new (arena) RenderMeter(this);
-}
+    if (!document().page()->theme().supportsMeter(style.get().appearance()))
+        return RenderElement::createFor(*this, WTFMove(style));
 
-const AtomicString& HTMLMeterElement::formControlType() const
-{
-    DEFINE_STATIC_LOCAL(const AtomicString, meter, ("meter"));
-    return meter;
+    return createRenderer<RenderMeter>(*this, WTFMove(style));
 }
 
-bool HTMLMeterElement::supportsFocus() const
+bool HTMLMeterElement::childShouldCreateRenderer(const Node& child) const
 {
-    return Node::supportsFocus() && !disabled();
+    return hasShadowRootParent(child) && HTMLElement::childShouldCreateRenderer(child);
 }
 
-void HTMLMeterElement::parseAttribute(Attribute* attribute)
+void HTMLMeterElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
 {
-    if (attribute->name() == valueAttr || attribute->name() == minAttr || attribute->name() == maxAttr || attribute->name() == lowAttr || attribute->name() == highAttr || attribute->name() == optimumAttr)
+    if (name == valueAttr || name == minAttr || name == maxAttr || name == lowAttr || name == highAttr || name == optimumAttr)
         didElementStateChange();
     else
-        HTMLFormControlElement::parseAttribute(attribute);
-}
-
-void HTMLMeterElement::attach()
-{
-    HTMLFormControlElement::attach();
-    didElementStateChange();
+        LabelableElement::parseAttribute(name, value);
 }
 
 double HTMLMeterElement::min() const
 {
-    double min = 0;
-    parseToDoubleForNumberType(getAttribute(minAttr), &min);
-    return min;
+    return parseToDoubleForNumberType(getAttribute(minAttr), 0);
 }
 
 void HTMLMeterElement::setMin(double min, ExceptionCode& ec)
 {
-    if (!isfinite(min)) {
+    if (!std::isfinite(min)) {
         ec = NOT_SUPPORTED_ERR;
         return;
     }
-    setAttribute(minAttr, String::number(min));
+    setAttribute(minAttr, AtomicString::number(min));
 }
 
 double HTMLMeterElement::max() const
 {
-    double max = std::max(1.0, min());
-    parseToDoubleForNumberType(getAttribute(maxAttr), &max);
-    return std::max(max, min());
+    return std::max(parseToDoubleForNumberType(getAttribute(maxAttr), std::max(1.0, min())), min());
 }
 
 void HTMLMeterElement::setMax(double max, ExceptionCode& ec)
 {
-    if (!isfinite(max)) {
+    if (!std::isfinite(max)) {
         ec = NOT_SUPPORTED_ERR;
         return;
     }
-    setAttribute(maxAttr, String::number(max));
+    setAttribute(maxAttr, AtomicString::number(max));
 }
 
 double HTMLMeterElement::value() const
 {
-    double value = 0;
-    parseToDoubleForNumberType(getAttribute(valueAttr), &value);
+    double value = parseToDoubleForNumberType(getAttribute(valueAttr), 0);
     return std::min(std::max(value, min()), max());
 }
 
 void HTMLMeterElement::setValue(double value, ExceptionCode& ec)
 {
-    if (!isfinite(value)) {
+    if (!std::isfinite(value)) {
         ec = NOT_SUPPORTED_ERR;
         return;
     }
-    setAttribute(valueAttr, String::number(value));
+    setAttribute(valueAttr, AtomicString::number(value));
 }
 
 double HTMLMeterElement::low() const
 {
-    double low = min();
-    parseToDoubleForNumberType(getAttribute(lowAttr), &low);
+    double low = parseToDoubleForNumberType(getAttribute(lowAttr), min());
     return std::min(std::max(low, min()), max());
 }
 
 void HTMLMeterElement::setLow(double low, ExceptionCode& ec)
 {
-    if (!isfinite(low)) {
+    if (!std::isfinite(low)) {
         ec = NOT_SUPPORTED_ERR;
         return;
     }
-    setAttribute(lowAttr, String::number(low));
+    setAttribute(lowAttr, AtomicString::number(low));
 }
 
 double HTMLMeterElement::high() const
 {
-    double high = max();
-    parseToDoubleForNumberType(getAttribute(highAttr), &high);
+    double high = parseToDoubleForNumberType(getAttribute(highAttr), max());
     return std::min(std::max(high, low()), max());
 }
 
 void HTMLMeterElement::setHigh(double high, ExceptionCode& ec)
 {
-    if (!isfinite(high)) {
+    if (!std::isfinite(high)) {
         ec = NOT_SUPPORTED_ERR;
         return;
     }
-    setAttribute(highAttr, String::number(high));
+    setAttribute(highAttr, AtomicString::number(high));
 }
 
 double HTMLMeterElement::optimum() const
 {
-    double optimum = (max() + min()) / 2;
-    parseToDoubleForNumberType(getAttribute(optimumAttr), &optimum);
+    double optimum = parseToDoubleForNumberType(getAttribute(optimumAttr), (max() + min()) / 2);
     return std::min(std::max(optimum, min()), max());
 }
 
 void HTMLMeterElement::setOptimum(double optimum, ExceptionCode& ec)
 {
-    if (!isfinite(optimum)) {
+    if (!std::isfinite(optimum)) {
         ec = NOT_SUPPORTED_ERR;
         return;
     }
-    setAttribute(optimumAttr, String::number(optimum));
+    setAttribute(optimumAttr, AtomicString::number(optimum));
 }
 
 HTMLMeterElement::GaugeRegion HTMLMeterElement::gaugeRegion() const
@@ -228,17 +213,32 @@ double HTMLMeterElement::valueRatio() const
 void HTMLMeterElement::didElementStateChange()
 {
     m_value->setWidthPercentage(valueRatio()*100);
-    if (RenderObject* render = renderer())
+    m_value->updatePseudo();
+    if (RenderMeter* render = renderMeter())
         render->updateFromElement();
 }
 
-void HTMLMeterElement::createShadowSubtree()
+RenderMeter* HTMLMeterElement::renderMeter() const
 {
-    RefPtr<MeterBarElement> bar = MeterBarElement::create(document());
+    if (is<RenderMeter>(renderer()))
+        return downcast<RenderMeter>(renderer());
+    return downcast<RenderMeter>(descendantsOfType<Element>(*userAgentShadowRoot()).first()->renderer());
+}
+
+void HTMLMeterElement::didAddUserAgentShadowRoot(ShadowRoot* root)
+{
+    ASSERT(!m_value);
+
+    Ref<MeterInnerElement> inner = MeterInnerElement::create(document());
+    root->appendChild(inner.copyRef());
+
+    Ref<MeterBarElement> bar = MeterBarElement::create(document());
     m_value = MeterValueElement::create(document());
-    ExceptionCode ec = 0;
-    bar->appendChild(m_value, ec);
-    ensureShadowRoot()->appendChild(bar, ec);
+    m_value->setWidthPercentage(0);
+    m_value->updatePseudo();
+    bar->appendChild(*m_value, ASSERT_NO_EXCEPTION);
+
+    inner->appendChild(WTFMove(bar), ASSERT_NO_EXCEPTION);
 }
 
 } // namespace