Use Shadow DOM to display fallback content for images

Source/core/html/forms/ImageInputType.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2010 Google Inc. All rights reserved.
  * Copyright (C) 2012 Samsung Electronics. 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
  * 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
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  *
  */
 
 #include "config.h"
 #include "core/html/forms/ImageInputType.h"
 
 #include "core/HTMLNames.h"
 #include "core/InputTypeNames.h"
+#include "core/dom/shadow/ShadowRoot.h"
 #include "core/events/MouseEvent.h"
 #include "core/fetch/ImageResource.h"
 #include "core/html/FormDataList.h"
 #include "core/html/HTMLFormElement.h"
+#include "core/html/HTMLImageFallbackHelper.h"
 #include "core/html/HTMLImageLoader.h"
 #include "core/html/HTMLInputElement.h"
 #include "core/html/parser/HTMLParserIdioms.h"
+#include "core/rendering/RenderBlockFlow.h"
 #include "core/rendering/RenderImage.h"
 #include "wtf/PassOwnPtr.h"
 #include "wtf/text/StringBuilder.h"
 
 namespace blink {
 
 using namespace HTMLNames;
 
 inline ImageInputType::ImageInputType(HTMLInputElement& element)
     : BaseButtonInputType(element)
+    , m_useFallbackContent(false)
 {
 }
 
 PassRefPtrWillBeRawPtr<InputType> ImageInputType::create(HTMLInputElement& element)
 {
     return adoptRefWillBeNoop(new ImageInputType(element));
 }
 
 const AtomicString& ImageInputType::formControlType() const
 {
@@ skipping 55 matching lines @@
     RefPtrWillBeRawPtr<HTMLInputElement> element(this->element());
     if (element->isDisabledFormControl() || !element->form())
         return;
     element->setActivatedSubmit(true);
     m_clickLocation = extractClickLocation(event);
     element->form()->prepareForSubmission(event); // Event handlers can run.
     element->setActivatedSubmit(false);
     event->setDefaultHandled();
 }
 
-RenderObject* ImageInputType::createRenderer(RenderStyle*) const
+RenderObject* ImageInputType::createRenderer(RenderStyle* style) const
 {
+    if (m_useFallbackContent)
+        return new RenderBlockFlow(&element());
     RenderImage* image = new RenderImage(&element());
     image->setImageResource(RenderImageResource::create());
     return image;
 }
 
 void ImageInputType::altAttributeChanged()
 {
-    RenderImage* image = toRenderImage(element().renderer());
-    if (!image)
-        return;
-    image->updateAltText();
+    if (element().userAgentShadowRoot()) {
+        Element* text = element().userAgentShadowRoot()->getElementById("alttext");
+        String value = element().altText();
+        if (text && text->textContent() != value)
+            text->setTextContent(element().altText());
+    }
 }
 
 void ImageInputType::srcAttributeChanged()
 {
     if (!element().renderer())
         return;
     element().ensureImageLoader().updateFromElement(ImageLoader::UpdateIgnorePreviousError);
 }
 
+void ImageInputType::valueAttributeChanged()
+{
+    if (m_useFallbackContent)
+        return;
+    BaseButtonInputType::valueAttributeChanged();
+}
+
 void ImageInputType::startResourceLoading()
 {
     BaseButtonInputType::startResourceLoading();
 
     HTMLImageLoader& imageLoader = element().ensureImageLoader();
     imageLoader.updateFromElement();
 
-    RenderImage* renderer = toRenderImage(element().renderer());
-    if (!renderer)
+    RenderObject* renderer = element().renderer();
+    if (!renderer || !renderer->isRenderImage())
         return;
 
-    RenderImageResource* imageResource = renderer->imageResource();
+    RenderImageResource* imageResource = toRenderImage(renderer)->imageResource();
     imageResource->setImageResource(imageLoader.image());
-
-    // If we have no image at all because we have no src attribute, set
-    // image height and width for the alt text instead.
-    if (!imageLoader.image() && !imageResource->cachedImage())
-        renderer->setImageSizeForAltText();
 }
 
 bool ImageInputType::shouldRespectAlignAttribute()
 {
     return true;
 }
 
 bool ImageInputType::canBeSuccessfulSubmitButton()
 {
     return true;
@@ skipping 56 matching lines @@
 bool ImageInputType::hasLegalLinkAttribute(const QualifiedName& name) const
 {
     return name == srcAttr || BaseButtonInputType::hasLegalLinkAttribute(name);
 }
 
 const QualifiedName& ImageInputType::subResourceAttributeName() const
 {
     return srcAttr;
 }
 
+void ImageInputType::ensureFallbackContent()
+{
+    if (m_useFallbackContent)
+        return;
+    setUseFallbackContent();
+    reattachFallbackContent();
+}
+
+void ImageInputType::setUseFallbackContent()
+{
+    if (m_useFallbackContent)
+        return;
+    m_useFallbackContent = true;
+    if (element().document().inStyleRecalc())
+        return;
+    if (ShadowRoot* root = element().userAgentShadowRoot())
+        root->removeChildren();
+    createShadowSubtree();
+}
+
+void ImageInputType::ensurePrimaryContent()
+{
+    if (!m_useFallbackContent)
+        return;
+    m_useFallbackContent = false;
+    reattachFallbackContent();
+}
+
+void ImageInputType::reattachFallbackContent()
+{
+    // This can happen inside of attach() in the middle of a recalcStyle so we need to
+    // reattach synchronously here.
+    if (element().document().inStyleRecalc())
+        element().reattach();
+    else
+        element().lazyReattachIfAttached();
+}
+
+void ImageInputType::createShadowSubtree()
+{
+    if (!m_useFallbackContent) {
+        BaseButtonInputType::createShadowSubtree();
+        return;
+    }
+    HTMLImageFallbackHelper::createAltTextShadowTree(element());
+}
+
+PassRefPtr<RenderStyle> ImageInputType::customStyleForRenderer(PassRefPtr<RenderStyle> newStyle)
+{
+    if (!m_useFallbackContent)
+        return newStyle;
+
+    return HTMLImageFallbackHelper::customStyleForAltText(element(), newStyle);
+}
+
 } // namespace blink