src/third_party/WebKit/Source/core/fetch/ImageResource.cpp

   1 /*
   2     Copyright (C) 1998 Lars Knoll (knoll@mpi-hd.mpg.de)
   3     Copyright (C) 2001 Dirk Mueller (mueller@kde.org)
   4     Copyright (C) 2002 Waldo Bastian (bastian@kde.org)
   5     Copyright (C) 2006 Samuel Weinig (sam.weinig@gmail.com)
   6     Copyright (C) 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
   7
   8     This library is free software; you can redistribute it and/or
   9     modify it under the terms of the GNU Library General Public
  10     License as published by the Free Software Foundation; either
  11     version 2 of the License, or (at your option) any later version.
  12
  13     This library is distributed in the hope that it will be useful,
  14     but WITHOUT ANY WARRANTY; without even the implied warranty of
  15     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16     Library General Public License for more details.
  17
  18     You should have received a copy of the GNU Library General Public License
  19     along with this library; see the file COPYING.LIB.  If not, write to
  20     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  21     Boston, MA 02110-1301, USA.
  22 */
  23
  24 #include "config.h"
  25 #include "core/fetch/ImageResource.h"
  26
  27 #include "core/fetch/ImageResourceClient.h"
  28 #include "core/fetch/MemoryCache.h"
  29 #include "core/fetch/ResourceClient.h"
  30 #include "core/fetch/ResourceClientWalker.h"
  31 #include "core/fetch/ResourceFetcher.h"
  32 #include "core/frame/FrameView.h"
  33 #include "core/rendering/RenderObject.h"
  34 #include "core/svg/graphics/SVGImage.h"
  35 #include "platform/Logging.h"
  36 #include "platform/RuntimeEnabledFeatures.h"
  37 #include "platform/SharedBuffer.h"
  38 #include "platform/TraceEvent.h"
  39 #include "platform/graphics/BitmapImage.h"
  40 #include "wtf/CurrentTime.h"
  41 #include "wtf/StdLibExtras.h"
  42
  43 namespace blink {
  44
  45 ImageResource::ImageResource(const ResourceRequest& resourceRequest)
  46     : Resource(resourceRequest, Image)
  47     , m_devicePixelRatioHeaderValue(1.0)
  48     , m_image(nullptr)
  49     , m_loadingMultipartContent(false)
  50     , m_hasDevicePixelRatioHeaderValue(false)
  51 {
  52     WTF_LOG(Timers, "new ImageResource(ResourceRequest) %p", this);
  53     setStatus(Unknown);
  54     setCustomAcceptHeader();
  55 }
  56
  57 ImageResource::ImageResource(blink::Image* image)
  58     : Resource(ResourceRequest(""), Image)
  59     , m_image(image)
  60 {
  61     WTF_LOG(Timers, "new ImageResource(Image) %p", this);
  62     setStatus(Cached);
  63     setLoading(false);
  64     setCustomAcceptHeader();
  65 }
  66
  67 ImageResource::ImageResource(const ResourceRequest& resourceRequest, blink::Image* image)
  68     : Resource(resourceRequest, Image)
  69     , m_image(image)
  70 {
  71     WTF_LOG(Timers, "new ImageResource(ResourceRequest, Image) %p", this);
  72     setStatus(Cached);
  73     setLoading(false);
  74     setCustomAcceptHeader();
  75 }
  76
  77 ImageResource::~ImageResource()
  78 {
  79     WTF_LOG(Timers, "~ImageResource %p", this);
  80     clearImage();
  81 }
  82
  83 void ImageResource::load(ResourceFetcher* fetcher, const ResourceLoaderOptions& options)
  84 {
  85     if (!fetcher || fetcher->autoLoadImages())
  86         Resource::load(fetcher, options);
  87     else
  88         setLoading(false);
  89 }
  90
  91 void ImageResource::didAddClient(ResourceClient* c)
  92 {
  93     if (m_data && !m_image && !errorOccurred()) {
  94         createImage();
  95         m_image->setData(m_data, true);
  96     }
  97
  98     ASSERT(c->resourceClientType() == ImageResourceClient::expectedType());
  99     if (m_image && !m_image->isNull())
 100         static_cast<ImageResourceClient*>(c)->imageChanged(this);
 101
 102     Resource::didAddClient(c);
 103 }
 104
 105 void ImageResource::didRemoveClient(ResourceClient* c)
 106 {
 107     ASSERT(c);
 108     ASSERT(c->resourceClientType() == ImageResourceClient::expectedType());
 109
 110     m_pendingContainerSizeRequests.remove(static_cast<ImageResourceClient*>(c));
 111     if (m_svgImageCache)
 112         m_svgImageCache->removeClientFromCache(static_cast<ImageResourceClient*>(c));
 113
 114     Resource::didRemoveClient(c);
 115 }
 116
 117 void ImageResource::switchClientsToRevalidatedResource()
 118 {
 119     ASSERT(resourceToRevalidate());
 120     ASSERT(resourceToRevalidate()->isImage());
 121     // Pending container size requests need to be transferred to the revalidated resource.
 122     if (!m_pendingContainerSizeRequests.isEmpty()) {
 123         // A copy of pending size requests is needed as they are deleted during Resource::switchClientsToRevalidateResouce().
 124         ContainerSizeRequests switchContainerSizeRequests;
 125         for (ContainerSizeRequests::iterator it = m_pendingContainerSizeRequests.begin(); it != m_pendingContainerSizeRequests.end(); ++it)
 126             switchContainerSizeRequests.set(it->key, it->value);
 127         Resource::switchClientsToRevalidatedResource();
 128         ImageResource* revalidatedImageResource = toImageResource(resourceToRevalidate());
 129         for (ContainerSizeRequests::iterator it = switchContainerSizeRequests.begin(); it != switchContainerSizeRequests.end(); ++it)
 130             revalidatedImageResource->setContainerSizeForRenderer(it->key, it->value.first, it->value.second);
 131         return;
 132     }
 133
 134     Resource::switchClientsToRevalidatedResource();
 135 }
 136
 137 bool ImageResource::isSafeToUnlock() const
 138 {
 139     // Note that |m_image| holds a reference to |m_data| in addition to the one held by the Resource parent class.
 140     return !m_image || (m_image->hasOneRef() && m_data->refCount() == 2);
 141 }
 142
 143 void ImageResource::destroyDecodedDataIfPossible()
 144 {
 145     if (!hasClients() && !isLoading() && (!m_image || (m_image->hasOneRef() && m_image->isBitmapImage()))) {
 146         m_image = nullptr;
 147         setDecodedSize(0);
 148     } else if (m_image && !errorOccurred()) {
 149         m_image->destroyDecodedData(true);
 150     }
 151 }
 152
 153 void ImageResource::allClientsRemoved()
 154 {
 155     m_pendingContainerSizeRequests.clear();
 156     if (m_image && !errorOccurred())
 157         m_image->resetAnimation();
 158     Resource::allClientsRemoved();
 159 }
 160
 161 pair<blink::Image*, float> ImageResource::brokenImage(float deviceScaleFactor)
 162 {
 163     if (deviceScaleFactor >= 2) {
 164         DEFINE_STATIC_REF(blink::Image, brokenImageHiRes, (blink::Image::loadPlatformResource("missingImage@2x")));
 165         return std::make_pair(brokenImageHiRes, 2);
 166     }
 167
 168     DEFINE_STATIC_REF(blink::Image, brokenImageLoRes, (blink::Image::loadPlatformResource("missingImage")));
 169     return std::make_pair(brokenImageLoRes, 1);
 170 }
 171
 172 bool ImageResource::willPaintBrokenImage() const
 173 {
 174     return errorOccurred();
 175 }
 176
 177 blink::Image* ImageResource::image()
 178 {
 179     ASSERT(!isPurgeable());
 180
 181     if (errorOccurred()) {
 182         // Returning the 1x broken image is non-ideal, but we cannot reliably access the appropriate
 183         // deviceScaleFactor from here. It is critical that callers use ImageResource::brokenImage()
 184         // when they need the real, deviceScaleFactor-appropriate broken image icon.
 185         return brokenImage(1).first;
 186     }
 187
 188     if (m_image)
 189         return m_image.get();
 190
 191     return blink::Image::nullImage();
 192 }
 193
 194 blink::Image* ImageResource::imageForRenderer(const RenderObject* renderer)
 195 {
 196     ASSERT(!isPurgeable());
 197
 198     if (errorOccurred()) {
 199         // Returning the 1x broken image is non-ideal, but we cannot reliably access the appropriate
 200         // deviceScaleFactor from here. It is critical that callers use ImageResource::brokenImage()
 201         // when they need the real, deviceScaleFactor-appropriate broken image icon.
 202         return brokenImage(1).first;
 203     }
 204
 205     if (!m_image)
 206         return blink::Image::nullImage();
 207
 208     if (m_image->isSVGImage()) {
 209         blink::Image* image = m_svgImageCache->imageForRenderer(renderer);
 210         if (image != blink::Image::nullImage())
 211             return image;
 212     }
 213
 214     return m_image.get();
 215 }
 216
 217 void ImageResource::setContainerSizeForRenderer(const ImageResourceClient* renderer, const IntSize& containerSize, float containerZoom)
 218 {
 219     if (containerSize.isEmpty())
 220         return;
 221     ASSERT(renderer);
 222     ASSERT(containerZoom);
 223     if (!m_image) {
 224         m_pendingContainerSizeRequests.set(renderer, SizeAndZoom(containerSize, containerZoom));
 225         return;
 226     }
 227     if (!m_image->isSVGImage()) {
 228         m_image->setContainerSize(containerSize);
 229         return;
 230     }
 231
 232     m_svgImageCache->setContainerSizeForRenderer(renderer, containerSize, containerZoom);
 233 }
 234
 235 bool ImageResource::usesImageContainerSize() const
 236 {
 237     if (m_image)
 238         return m_image->usesContainerSize();
 239
 240     return false;
 241 }
 242
 243 bool ImageResource::imageHasRelativeWidth() const
 244 {
 245     if (m_image)
 246         return m_image->hasRelativeWidth();
 247
 248     return false;
 249 }
 250
 251 bool ImageResource::imageHasRelativeHeight() const
 252 {
 253     if (m_image)
 254         return m_image->hasRelativeHeight();
 255
 256     return false;
 257 }
 258
 259 LayoutSize ImageResource::imageSizeForRenderer(const RenderObject* renderer, float multiplier, SizeType sizeType)
 260 {
 261     ASSERT(!isPurgeable());
 262
 263     if (!m_image)
 264         return IntSize();
 265
 266     LayoutSize imageSize;
 267
 268     if (m_image->isBitmapImage() && (renderer && renderer->shouldRespectImageOrientation() == RespectImageOrientation))
 269         imageSize = toBitmapImage(m_image.get())->sizeRespectingOrientation();
 270     else if (m_image->isSVGImage() && sizeType == NormalSize)
 271         imageSize = m_svgImageCache->imageSizeForRenderer(renderer);
 272     else
 273         imageSize = m_image->size();
 274
 275     if (multiplier == 1.0f)
 276         return imageSize;
 277
 278     // Don't let images that have a width/height >= 1 shrink below 1 when zoomed.
 279     float widthScale = m_image->hasRelativeWidth() ? 1.0f : multiplier;
 280     float heightScale = m_image->hasRelativeHeight() ? 1.0f : multiplier;
 281     LayoutSize minimumSize(imageSize.width() > 0 ? 1 : 0, imageSize.height() > 0 ? 1 : 0);
 282     imageSize.scale(widthScale, heightScale);
 283     imageSize.clampToMinimumSize(minimumSize);
 284     ASSERT(multiplier != 1.0f || (imageSize.width().fraction() == 0.0f && imageSize.height().fraction() == 0.0f));
 285     return imageSize;
 286 }
 287
 288 void ImageResource::computeIntrinsicDimensions(Length& intrinsicWidth, Length& intrinsicHeight, FloatSize& intrinsicRatio)
 289 {
 290     if (m_image)
 291         m_image->computeIntrinsicDimensions(intrinsicWidth, intrinsicHeight, intrinsicRatio);
 292 }
 293
 294 void ImageResource::notifyObservers(const IntRect* changeRect)
 295 {
 296     ResourceClientWalker<ImageResourceClient> w(m_clients);
 297     while (ImageResourceClient* c = w.next())
 298         c->imageChanged(this, changeRect);
 299 }
 300
 301 void ImageResource::clear()
 302 {
 303     prune();
 304     clearImage();
 305     m_pendingContainerSizeRequests.clear();
 306     setEncodedSize(0);
 307 }
 308
 309 void ImageResource::setCustomAcceptHeader()
 310 {
 311     DEFINE_STATIC_LOCAL(const AtomicString, acceptWebP, ("image/webp,*/*;q=0.8", AtomicString::ConstructFromLiteral));
 312     setAccept(acceptWebP);
 313 }
 314
 315 inline void ImageResource::createImage()
 316 {
 317     // Create the image if it doesn't yet exist.
 318     if (m_image)
 319         return;
 320
 321     if (m_response.mimeType() == "image/svg+xml") {
 322         RefPtr<SVGImage> svgImage = SVGImage::create(this);
 323         m_svgImageCache = SVGImageCache::create(svgImage.get());
 324         m_image = svgImage.release();
 325     } else {
 326         m_image = BitmapImage::create(this);
 327     }
 328
 329     if (m_image) {
 330         // Send queued container size requests.
 331         if (m_image->usesContainerSize()) {
 332             for (ContainerSizeRequests::iterator it = m_pendingContainerSizeRequests.begin(); it != m_pendingContainerSizeRequests.end(); ++it)
 333                 setContainerSizeForRenderer(it->key, it->value.first, it->value.second);
 334         }
 335         m_pendingContainerSizeRequests.clear();
 336     }
 337 }
 338
 339 inline void ImageResource::clearImage()
 340 {
 341     // If our Image has an observer, it's always us so we need to clear the back pointer
 342     // before dropping our reference.
 343     if (m_image)
 344         m_image->setImageObserver(0);
 345     m_image.clear();
 346 }
 347
 348 void ImageResource::appendData(const char* data, int length)
 349 {
 350     Resource::appendData(data, length);
 351     if (!m_loadingMultipartContent)
 352         updateImage(false);
 353 }
 354
 355 void ImageResource::updateImage(bool allDataReceived)
 356 {
 357     TRACE_EVENT0("blink", "ImageResource::updateImage");
 358
 359     if (m_data)
 360         createImage();
 361
 362     bool sizeAvailable = false;
 363
 364     // Have the image update its data from its internal buffer.
 365     // It will not do anything now, but will delay decoding until
 366     // queried for info (like size or specific image frames).
 367     if (m_image)
 368         sizeAvailable = m_image->setData(m_data, allDataReceived);
 369
 370     // Go ahead and tell our observers to try to draw if we have either
 371     // received all the data or the size is known. Each chunk from the
 372     // network causes observers to repaint, which will force that chunk
 373     // to decode.
 374     if (sizeAvailable || allDataReceived) {
 375         if (!m_image || m_image->isNull()) {
 376             error(errorOccurred() ? status() : DecodeError);
 377             if (memoryCache()->contains(this))
 378                 memoryCache()->remove(this);
 379             return;
 380         }
 381
 382         // It would be nice to only redraw the decoded band of the image, but with the current design
 383         // (decoding delayed until painting) that seems hard.
 384         notifyObservers();
 385     }
 386 }
 387
 388 void ImageResource::updateBitmapImages(HashSet<ImageResource*>& images, bool redecodeImages)
 389 {
 390     for (HashSet<ImageResource*>::iterator it = images.begin(); it != images.end(); ++it) {
 391         ImageResource* imageResource = *it;
 392         if (!imageResource->hasImage() || imageResource->image()->isNull())
 393             continue;
 394         BitmapImage* image = toBitmapImage(imageResource->image());
 395         if (redecodeImages)
 396             image->resetDecoder();
 397         imageResource->updateImage(image->isAllDataReceived());
 398     }
 399 }
 400
 401 void ImageResource::finishOnePart()
 402 {
 403     if (m_loadingMultipartContent)
 404         clear();
 405     updateImage(true);
 406     if (m_loadingMultipartContent)
 407         m_data.clear();
 408     Resource::finishOnePart();
 409 }
 410
 411 void ImageResource::error(Resource::Status status)
 412 {
 413     clear();
 414     Resource::error(status);
 415     notifyObservers();
 416 }
 417
 418 void ImageResource::responseReceived(const ResourceResponse& response)
 419 {
 420     if (m_loadingMultipartContent && m_data)
 421         finishOnePart();
 422     else if (response.isMultipart())
 423         m_loadingMultipartContent = true;
 424     if (RuntimeEnabledFeatures::clientHintsDprEnabled()) {
 425         m_devicePixelRatioHeaderValue = response.httpHeaderField("DPR").toFloat(&m_hasDevicePixelRatioHeaderValue);
 426         if (!m_hasDevicePixelRatioHeaderValue || m_devicePixelRatioHeaderValue <= 0.0) {
 427             m_devicePixelRatioHeaderValue = 1.0;
 428             m_hasDevicePixelRatioHeaderValue = false;
 429         }
 430     }
 431     Resource::responseReceived(response);
 432 }
 433
 434 void ImageResource::decodedSizeChanged(const blink::Image* image, int delta)
 435 {
 436     if (!image || image != m_image)
 437         return;
 438
 439     setDecodedSize(decodedSize() + delta);
 440 }
 441
 442 void ImageResource::didDraw(const blink::Image* image)
 443 {
 444     if (!image || image != m_image)
 445         return;
 446     // decodedSize() == 0 indicates that the image is decoded into DiscardableMemory,
 447     // not in MemoryCache. So we don't need to call Resource::didAccessDecodedData()
 448     // to update MemoryCache.
 449     if (decodedSize() != 0)
 450         Resource::didAccessDecodedData();
 451 }
 452
 453 bool ImageResource::shouldPauseAnimation(const blink::Image* image)
 454 {
 455     if (!image || image != m_image)
 456         return false;
 457
 458     ResourceClientWalker<ImageResourceClient> w(m_clients);
 459     while (ImageResourceClient* c = w.next()) {
 460         if (c->willRenderImage(this))
 461             return false;
 462     }
 463
 464     return true;
 465 }
 466
 467 void ImageResource::animationAdvanced(const blink::Image* image)
 468 {
 469     if (!image || image != m_image)
 470         return;
 471     notifyObservers();
 472 }
 473
 474 void ImageResource::changedInRect(const blink::Image* image, const IntRect& rect)
 475 {
 476     if (!image || image != m_image)
 477         return;
 478     notifyObservers(&rect);
 479 }
 480
 481 bool ImageResource::currentFrameKnownToBeOpaque(const RenderObject* renderer)
 482 {
 483     blink::Image* image = imageForRenderer(renderer);
 484     if (image->isBitmapImage())
 485         image->nativeImageForCurrentFrame(); // force decode
 486     return image->currentFrameKnownToBeOpaque();
 487 }
 488
 489 bool ImageResource::isAccessAllowed(SecurityOrigin* securityOrigin)
 490 {
 491     if (!image()->currentFrameHasSingleSecurityOrigin())
 492         return false;
 493     if (passesAccessControlCheck(securityOrigin))
 494         return true;
 495     return !securityOrigin->taintsCanvas(response().url());
 496 }
 497
 498 } // namespace blink