Teach HTMLImageElement that it doesn't need ::attach.

sky/engine/core/rendering/RenderImage.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  *           (C) 2006 Allan Sandfeld Jensen (kde@carewolf.com)
  *           (C) 2006 Samuel Weinig (sam.weinig@gmail.com)
  * Copyright (C) 2003, 2004, 2005, 2006, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2010 Google Inc. All rights reserved.
  * Copyright (C) Research In Motion Limited 2011-2012. All rights reserved.
  *
@@ skipping 10 matching lines @@
  * 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/rendering/RenderImage.h"
 
+#include "core/HTMLNames.h"
 #include "core/editing/FrameSelection.h"
 #include "core/fetch/ImageResource.h"
 #include "core/fetch/ResourceLoader.h"
 #include "core/frame/LocalFrame.h"
 #include "core/html/HTMLImageElement.h"
 #include "core/inspector/InspectorTraceEvents.h"
 #include "core/rendering/HitTestResult.h"
 #include "core/rendering/PaintInfo.h"
 #include "core/rendering/RenderLayer.h"
 #include "core/rendering/RenderView.h"
@@ skipping 24 matching lines @@
 {
 }
 
 void RenderImage::destroy()
 {
     ASSERT(m_imageResource);
     m_imageResource->shutdown();
     RenderReplaced::destroy();
 }
 
+void RenderImage::intrinsicSizeChanged()
+{
+    if (m_imageResource)
+        imageChanged(m_imageResource->imagePtr());
+}
+
 void RenderImage::setImageResource(PassOwnPtr<RenderImageResource> imageResource)
 {
     ASSERT(!m_imageResource);
     m_imageResource = imageResource;
     m_imageResource->initialize(this);
 }
 
 void RenderImage::imageChanged(WrappedImagePtr newImage, const IntRect* rect)
 {
     if (documentBeingDestroyed())
         return;
 
-    if (hasBoxDecorationBackground() || hasMask())
-        RenderReplaced::imageChanged(newImage, rect);
-
     if (!m_imageResource)
         return;
 
     if (newImage != m_imageResource->imagePtr())
         return;
 
     // Per the spec, we let the server-sent header override srcset/other sources of dpr.
     // https://github.com/igrigorik/http-client-hints/blob/master/draft-grigorik-http-client-hints-01.txt#L255
     if (m_imageResource->cachedImage() && m_imageResource->cachedImage()->hasDevicePixelRatioHeaderValue())
         m_imageDevicePixelRatio = 1 / m_imageResource->cachedImage()->devicePixelRatioHeaderValue();
 
+    // If the RenderImage was just created we don't have style() or a parent()
+    // yet so all we can do is update our intrinsic size. Once we're inserted
+    // the resulting layout will do the rest of the work.
+    if (!parent()) {
+        updateIntrinsicSizeIfNeeded(m_imageResource->intrinsicSize());
+        return;
+    }
+
+    if (hasBoxDecorationBackground() || hasMask())
+        RenderReplaced::imageChanged(newImage, rect);

[ojan, 2014/11/18 03:34:47]

This makes me a little future-proof nervous. If someone changes
RenderReplaced::imageChanged to do real work then it might not happen when we
first create the renderer. Not sure what the fix is. Seems a bit fragile though.

+
     paintInvalidationOrMarkForLayout(rect);
 }
 
 void RenderImage::updateIntrinsicSizeIfNeeded(const LayoutSize& newSize)
 {
     if (m_imageResource->errorOccurred() || !m_imageResource->hasImage())
         return;
     setIntrinsicSize(newSize);
 }
 
 void RenderImage::updateInnerContentRect()
 {
     // Propagate container size to the image resource.
     LayoutRect containerRect = replacedContentRect();
     IntSize containerSize(containerRect.width(), containerRect.height());
     if (!containerSize.isEmpty())
         m_imageResource->setContainerSizeForRenderer(containerSize);
 }
 
 void RenderImage::paintInvalidationOrMarkForLayout(const IntRect* rect)
 {
+    ASSERT(isRooted());
+
     LayoutSize oldIntrinsicSize = intrinsicSize();
     LayoutSize newIntrinsicSize = m_imageResource->intrinsicSize();
     updateIntrinsicSizeIfNeeded(newIntrinsicSize);
 
-    // In the case of generated image content using :before/:after/content, we might not be
-    // in the render tree yet. In that case, we just need to update our intrinsic size.
-    // layout() will be called after we are inserted in the tree which will take care of
-    // what we are doing here.
-    if (!containingBlock())
-        return;
-
     bool imageSourceHasChangedSize = oldIntrinsicSize != newIntrinsicSize;
     if (imageSourceHasChangedSize)
         setPreferredLogicalWidthsDirty();
 
     // If the actual area occupied by the image has changed and it is not constrained by style then a layout is required.
     bool imageSizeIsConstrained = style()->logicalWidth().isSpecified() && style()->logicalHeight().isSpecified();
 
     // FIXME: We only need to recompute the containing block's preferred size if the containing block's size
     // depends on the image's size (i.e., the container uses shrink-to-fit sizing).
     // There's no easy way to detect that shrink-to-fit is needed, always force a layout.
@@ skipping 198 matching lines @@
         return;
     }
 }
 
 bool RenderImage::needsPreferredWidthsRecalculation() const
 {
     return RenderReplaced::needsPreferredWidthsRecalculation();
 }
 
 } // namespace blink