[ImageResource 4] Split ImageResource into Resource and Image parts

third_party/WebKit/Source/core/html/HTMLImageElement.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2010 Apple Inc. All rights
  * reserved.
  * Copyright (C) 2010 Google Inc. 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 15 matching lines @@
 #include "bindings/core/v8/ScriptEventListener.h"
 #include "core/CSSPropertyNames.h"
 #include "core/HTMLNames.h"
 #include "core/MediaTypeNames.h"
 #include "core/css/MediaQueryMatcher.h"
 #include "core/css/MediaValuesDynamic.h"
 #include "core/css/parser/SizesAttributeParser.h"
 #include "core/dom/Attribute.h"
 #include "core/dom/NodeTraversal.h"
 #include "core/dom/shadow/ShadowRoot.h"
-#include "core/fetch/ImageResource.h"
+#include "core/fetch/ImageResourceContent.h"
 #include "core/frame/Deprecation.h"
 #include "core/frame/ImageBitmap.h"
 #include "core/frame/LocalDOMWindow.h"
 #include "core/html/HTMLAnchorElement.h"
 #include "core/html/HTMLCanvasElement.h"
 #include "core/html/HTMLFormElement.h"
 #include "core/html/HTMLImageFallbackHelper.h"
 #include "core/html/HTMLPictureElement.h"
 #include "core/html/HTMLSourceElement.h"
 #include "core/html/parser/HTMLParserIdioms.h"
@@ skipping 313 matching lines @@
 
 void HTMLImageElement::attachLayoutTree(const AttachContext& context) {
   HTMLElement::attachLayoutTree(context);
 
   if (layoutObject() && layoutObject()->isImage()) {
     LayoutImage* layoutImage = toLayoutImage(layoutObject());
     LayoutImageResource* layoutImageResource = layoutImage->imageResource();
     if (m_isFallbackImage) {
       float deviceScaleFactor = blink::deviceScaleFactor(layoutImage->frame());
       std::pair<Image*, float> brokenImageAndImageScaleFactor =
-          ImageResource::brokenImage(deviceScaleFactor);
-      ImageResource* newImageResource =
-          ImageResource::create(brokenImageAndImageScaleFactor.first);
+          ImageResourceContent::brokenImage(deviceScaleFactor);
+      ImageResourceContent* newImageResource =
+          ImageResourceContent::create(brokenImageAndImageScaleFactor.first);
       layoutImage->imageResource()->setImageResource(newImageResource);
     }
     if (layoutImageResource->hasImage())
       return;
 
     if (!imageLoader().image() && !layoutImageResource->cachedImage())
       return;
     layoutImageResource->setImageResource(imageLoader().image());
   }
 }
@@ skipping 98 matching lines @@
 }
 
 unsigned HTMLImageElement::naturalWidth() const {
   if (!imageLoader().image())
     return 0;
 
   return imageLoader()
       .image()
       ->imageSize(LayoutObject::shouldRespectImageOrientation(layoutObject()),
                   m_imageDevicePixelRatio,
-                  ImageResource::IntrinsicCorrectedToDPR)
+                  ImageResourceContent::IntrinsicCorrectedToDPR)
       .width()
       .toUnsigned();
 }
 
 unsigned HTMLImageElement::naturalHeight() const {
   if (!imageLoader().image())
     return 0;
 
   return imageLoader()
       .image()
       ->imageSize(LayoutObject::shouldRespectImageOrientation(layoutObject()),
                   m_imageDevicePixelRatio,
-                  ImageResource::IntrinsicCorrectedToDPR)
+                  ImageResourceContent::IntrinsicCorrectedToDPR)
       .height()
       .toUnsigned();
 }
 
 const String& HTMLImageElement::currentSrc() const {
   // http://www.whatwg.org/specs/web-apps/current-work/multipage/edits.html#dom-img-currentsrc
   // The currentSrc IDL attribute must return the img element's current
   // request's current URL.
 
   // Return the picked URL string in case of load error.
@@ skipping 133 matching lines @@
   *status = NormalSourceImageStatus;
   return sourceImage->imageForDefaultFrame();
 }
 
 bool HTMLImageElement::isSVGSource() const {
   return cachedImage() && cachedImage()->getImage()->isSVGImage();
 }
 
 bool HTMLImageElement::wouldTaintOrigin(
     SecurityOrigin* destinationSecurityOrigin) const {
-  ImageResource* image = cachedImage();
+  ImageResourceContent* image = cachedImage();
   if (!image)
     return false;
   return !image->isAccessAllowed(destinationSecurityOrigin);
 }
 
 FloatSize HTMLImageElement::elementSize(
     const FloatSize& defaultObjectSize) const {
-  ImageResource* image = cachedImage();
+  ImageResourceContent* image = cachedImage();
   if (!image)
     return FloatSize();
 
   if (image->getImage() && image->getImage()->isSVGImage())
     return toSVGImage(cachedImage()->getImage())
         ->concreteObjectSize(defaultObjectSize);
 
   return FloatSize(image->imageSize(
       LayoutObject::shouldRespectImageOrientation(layoutObject()), 1.0f));
 }
 
 FloatSize HTMLImageElement::defaultDestinationSize(
     const FloatSize& defaultObjectSize) const {
-  ImageResource* image = cachedImage();
+  ImageResourceContent* image = cachedImage();
   if (!image)
     return FloatSize();
 
   if (image->getImage() && image->getImage()->isSVGImage())
     return toSVGImage(cachedImage()->getImage())
         ->concreteObjectSize(defaultObjectSize);
 
   LayoutSize size;
   size = image->imageSize(
       LayoutObject::shouldRespectImageOrientation(layoutObject()), 1.0f);
@@ skipping 90 matching lines @@
       !imageHasLoaded && imageLoader().hasPendingActivity() &&
       !imageLoader().hasPendingError() && !imageSourceURL().isEmpty();
   bool imageHasImage =
       imageLoader().image() && imageLoader().image()->hasImage();
   bool imageIsDocument = imageLoader().isLoadingImageDocument() &&
                          imageLoader().image() &&
                          !imageLoader().image()->errorOccurred();
 
   // Icky special case for deferred images:
   // A deferred image is not loading, does have pending activity, does not
-  // have an error, but it does have an ImageResource associated
+  // have an error, but it does have an ImageResourceContent associated
   // with it, so imageHasLoaded will be true even though the image hasn't
   // actually loaded. Fixing the definition of imageHasLoaded isn't
   // sufficient, because a deferred image does have pending activity, does not
   // have a pending error, and does have a source URL, so if imageHasLoaded
   // was correct, imageStillLoading would become wrong.
   //
   // Instead of dealing with that, there's a separate check that the
-  // ImageResource has non-null image data associated with it, which isn't
-  // folded into imageHasLoaded above.
+  // ImageResourceContent has non-null image data associated with it, which
+  // isn't folded into imageHasLoaded above.
   if ((imageHasLoaded && imageHasImage) || imageStillLoading || imageIsDocument)
     ensurePrimaryContent();
   else
     ensureFallbackContent();
 }
 
 const KURL& HTMLImageElement::sourceURL() const {
   return cachedImage()->response().url();
 }
 
@@ skipping 64 matching lines @@
 int HTMLImageElement::sourceHeight() {
   SourceImageStatus status;
   FloatSize defaultObjectSize(width(), height());
   RefPtr<Image> image = getSourceImageForCanvas(
       &status, PreferNoAcceleration, SnapshotReasonCopyToWebGLTexture,
       defaultObjectSize);
   return image->height();
 }
 
 IntSize HTMLImageElement::bitmapSourceSize() const {
-  ImageResource* image = cachedImage();
+  ImageResourceContent* image = cachedImage();
   if (!image)
     return IntSize();
   LayoutSize lSize = image->imageSize(
       LayoutObject::shouldRespectImageOrientation(layoutObject()), 1.0f);
   DCHECK(lSize.fraction().isZero());
   return IntSize(lSize.width().toInt(), lSize.height().toInt());
 }
 
 }  // namespace blink