layout/style/ImageLoader.cpp

   1 /* This Source Code Form is subject to the terms of the Mozilla Public
   2  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
   3  * You can obtain one at http://mozilla.org/MPL/2.0/. */
   4
   5 /* A class that handles style system image loads (other image loads are handled
   6  * by the nodes in the content tree).
   7  */
   8
   9 #include "mozilla/css/ImageLoader.h"
  10 #include "nsContentUtils.h"
  11 #include "nsLayoutUtils.h"
  12 #include "nsError.h"
  13 #include "nsDisplayList.h"
  14 #include "FrameLayerBuilder.h"
  15 #include "nsSVGEffects.h"
  16 #include "imgIContainer.h"
  17
  18 namespace mozilla {
  19 namespace css {
  20
  21 /* static */ PLDHashOperator
  22 ImageLoader::SetAnimationModeEnumerator(nsISupports* aKey, FrameSet* aValue,
  23                                         void* aClosure)
  24 {
  25   imgIRequest* request = static_cast<imgIRequest*>(aKey);
  26
  27   uint16_t* mode = static_cast<uint16_t*>(aClosure);
  28
  29 #ifdef DEBUG
  30   {
  31     nsCOMPtr<imgIRequest> debugRequest = do_QueryInterface(aKey);
  32     NS_ASSERTION(debugRequest == request, "This is bad");
  33   }
  34 #endif
  35
  36   nsCOMPtr<imgIContainer> container;
  37   request->GetImage(getter_AddRefs(container));
  38   if (!container) {
  39     return PL_DHASH_NEXT;
  40   }
  41
  42   // This can fail if the image is in error, and we don't care.
  43   container->SetAnimationMode(*mode);
  44
  45   return PL_DHASH_NEXT;
  46 }
  47
  48 static PLDHashOperator
  49 ClearImageHashSet(nsPtrHashKey<ImageLoader::Image>* aKey, void* aClosure)
  50 {
  51   nsIDocument* doc = static_cast<nsIDocument*>(aClosure);
  52   ImageLoader::Image* image = aKey->GetKey();
  53
  54   imgIRequest* request = image->mRequests.GetWeak(doc);
  55   if (request) {
  56     request->CancelAndForgetObserver(NS_BINDING_ABORTED);
  57   }
  58
  59   image->mRequests.Remove(doc);
  60
  61   return PL_DHASH_REMOVE;
  62 }
  63
  64 void
  65 ImageLoader::DropDocumentReference()
  66 {
  67   // It's okay if GetPresContext returns null here (due to the presshell pointer
  68   // on the document being null) as that means the presshell has already
  69   // been destroyed, and it also calls ClearFrames when it is destroyed.
  70   ClearFrames(GetPresContext());
  71   mImages.EnumerateEntries(&ClearImageHashSet, mDocument);
  72   mDocument = nullptr;
  73 }
  74
  75 void
  76 ImageLoader::AssociateRequestToFrame(imgIRequest* aRequest,
  77                                      nsIFrame* aFrame)
  78 {
  79   nsCOMPtr<imgINotificationObserver> observer;
  80   aRequest->GetNotificationObserver(getter_AddRefs(observer));
  81   if (!observer) {
  82     // The request has already been canceled, so ignore it.  This is ok because
  83     // we're not going to get any more notifications from a canceled request.
  84     return;
  85   }
  86
  87   MOZ_ASSERT(observer == this);
  88
  89   FrameSet* frameSet = nullptr;
  90   if (mRequestToFrameMap.Get(aRequest, &frameSet)) {
  91     NS_ASSERTION(frameSet, "This should never be null!");
  92   }
  93
  94   if (!frameSet) {
  95     nsAutoPtr<FrameSet> newFrameSet(new FrameSet());
  96
  97     mRequestToFrameMap.Put(aRequest, newFrameSet);
  98     frameSet = newFrameSet.forget();
  99
 100     nsPresContext* presContext = GetPresContext();
 101     if (presContext) {
 102       nsLayoutUtils::RegisterImageRequestIfAnimated(presContext,
 103                                                     aRequest,
 104                                                     nullptr);
 105     }
 106   }
 107
 108   RequestSet* requestSet = nullptr;
 109   if (mFrameToRequestMap.Get(aFrame, &requestSet)) {
 110     NS_ASSERTION(requestSet, "This should never be null");
 111   }
 112
 113   if (!requestSet) {
 114     nsAutoPtr<RequestSet> newRequestSet(new RequestSet());
 115
 116     mFrameToRequestMap.Put(aFrame, newRequestSet);
 117     requestSet = newRequestSet.forget();
 118   }
 119
 120   // Add these to the sets, but only if they're not already there.
 121   uint32_t i = frameSet->IndexOfFirstElementGt(aFrame);
 122   if (i == 0 || aFrame != frameSet->ElementAt(i-1)) {
 123     frameSet->InsertElementAt(i, aFrame);
 124   }
 125   i = requestSet->IndexOfFirstElementGt(aRequest);
 126   if (i == 0 || aRequest != requestSet->ElementAt(i-1)) {
 127     requestSet->InsertElementAt(i, aRequest);
 128   }
 129 }
 130
 131 void
 132 ImageLoader::MaybeRegisterCSSImage(ImageLoader::Image* aImage)
 133 {
 134   NS_ASSERTION(aImage, "This should never be null!");
 135
 136   bool found = false;
 137   aImage->mRequests.GetWeak(mDocument, &found);
 138   if (found) {
 139     // This document already has a request.
 140     return;
 141   }
 142
 143   imgRequestProxy* canonicalRequest = aImage->mRequests.GetWeak(nullptr);
 144   if (!canonicalRequest) {
 145     // The image was blocked or something.
 146     return;
 147   }
 148
 149   nsRefPtr<imgRequestProxy> request;
 150
 151   // Ignore errors here.  If cloning fails for some reason we'll put a null
 152   // entry in the hash and we won't keep trying to clone.
 153   mInClone = true;
 154   canonicalRequest->Clone(this, getter_AddRefs(request));
 155   mInClone = false;
 156
 157   aImage->mRequests.Put(mDocument, request);
 158
 159   AddImage(aImage);
 160 }
 161
 162 void
 163 ImageLoader::DeregisterCSSImage(ImageLoader::Image* aImage)
 164 {
 165   RemoveImage(aImage);
 166 }
 167
 168 void
 169 ImageLoader::DisassociateRequestFromFrame(imgIRequest* aRequest,
 170                                           nsIFrame* aFrame)
 171 {
 172   FrameSet* frameSet = nullptr;
 173   RequestSet* requestSet = nullptr;
 174
 175 #ifdef DEBUG
 176   {
 177     nsCOMPtr<imgINotificationObserver> observer;
 178     aRequest->GetNotificationObserver(getter_AddRefs(observer));
 179     MOZ_ASSERT(!observer || observer == this);
 180   }
 181 #endif
 182
 183   mRequestToFrameMap.Get(aRequest, &frameSet);
 184   mFrameToRequestMap.Get(aFrame, &requestSet);
 185
 186   if (frameSet) {
 187     frameSet->RemoveElementSorted(aFrame);
 188   }
 189   if (requestSet) {
 190     requestSet->RemoveElementSorted(aRequest);
 191   }
 192
 193   if (frameSet && !frameSet->Length()) {
 194     mRequestToFrameMap.Remove(aRequest);
 195
 196     nsPresContext* presContext = GetPresContext();
 197     if (presContext) {
 198       nsLayoutUtils::DeregisterImageRequest(presContext,
 199                                             aRequest,
 200                                             nullptr);
 201     }
 202   }
 203
 204   if (requestSet && !requestSet->Length()) {
 205     mFrameToRequestMap.Remove(aFrame);
 206   }
 207 }
 208
 209 void
 210 ImageLoader::DropRequestsForFrame(nsIFrame* aFrame)
 211 {
 212   RequestSet* requestSet = nullptr;
 213   if (!mFrameToRequestMap.Get(aFrame, &requestSet)) {
 214     return;
 215   }
 216
 217   NS_ASSERTION(requestSet, "This should never be null");
 218
 219   RequestSet frozenRequestSet(*requestSet);
 220   for (RequestSet::size_type i = frozenRequestSet.Length(); i != 0; --i) {
 221     imgIRequest* request = frozenRequestSet.ElementAt(i - 1);
 222
 223     DisassociateRequestFromFrame(request, aFrame);
 224   }
 225 }
 226
 227 void
 228 ImageLoader::SetAnimationMode(uint16_t aMode)
 229 {
 230   NS_ASSERTION(aMode == imgIContainer::kNormalAnimMode ||
 231                aMode == imgIContainer::kDontAnimMode ||
 232                aMode == imgIContainer::kLoopOnceAnimMode,
 233                "Wrong Animation Mode is being set!");
 234
 235   mRequestToFrameMap.EnumerateRead(SetAnimationModeEnumerator, &aMode);
 236 }
 237
 238 /* static */ PLDHashOperator
 239 ImageLoader::DeregisterRequestEnumerator(nsISupports* aKey, FrameSet* aValue,
 240                                          void* aClosure)
 241 {
 242   imgIRequest* request = static_cast<imgIRequest*>(aKey);
 243
 244 #ifdef DEBUG
 245   {
 246     nsCOMPtr<imgIRequest> debugRequest = do_QueryInterface(aKey);
 247     NS_ASSERTION(debugRequest == request, "This is bad");
 248   }
 249 #endif
 250
 251   nsPresContext* presContext = static_cast<nsPresContext*>(aClosure);
 252   if (presContext) {
 253     nsLayoutUtils::DeregisterImageRequest(presContext,
 254                                           request,
 255                                           nullptr);
 256   }
 257
 258   return PL_DHASH_NEXT;
 259 }
 260
 261 void
 262 ImageLoader::ClearFrames(nsPresContext* aPresContext)
 263 {
 264   mRequestToFrameMap.EnumerateRead(DeregisterRequestEnumerator, aPresContext);
 265   mRequestToFrameMap.Clear();
 266   mFrameToRequestMap.Clear();
 267 }
 268
 269 void
 270 ImageLoader::LoadImage(nsIURI* aURI, nsIPrincipal* aOriginPrincipal,
 271                        nsIURI* aReferrer, ImageLoader::Image* aImage)
 272 {
 273   NS_ASSERTION(aImage->mRequests.Count() == 0, "Huh?");
 274
 275   aImage->mRequests.Put(nullptr, nullptr);
 276
 277   if (!aURI) {
 278     return;
 279   }
 280
 281   if (!nsContentUtils::CanLoadImage(aURI, mDocument, mDocument,
 282                                     aOriginPrincipal)) {
 283     return;
 284   }
 285
 286   nsRefPtr<imgRequestProxy> request;
 287   nsContentUtils::LoadImage(aURI, mDocument, aOriginPrincipal, aReferrer,
 288                             mDocument->GetReferrerPolicy(),
 289                             nullptr, nsIRequest::LOAD_NORMAL,
 290                             NS_LITERAL_STRING("css"),
 291                             getter_AddRefs(request));
 292
 293   if (!request) {
 294     return;
 295   }
 296
 297   nsRefPtr<imgRequestProxy> clonedRequest;
 298   mInClone = true;
 299   nsresult rv = request->Clone(this, getter_AddRefs(clonedRequest));
 300   mInClone = false;
 301
 302   if (NS_FAILED(rv)) {
 303     return;
 304   }
 305
 306   aImage->mRequests.Put(nullptr, request);
 307   aImage->mRequests.Put(mDocument, clonedRequest);
 308
 309   AddImage(aImage);
 310 }
 311
 312 void
 313 ImageLoader::AddImage(ImageLoader::Image* aImage)
 314 {
 315   NS_ASSERTION(!mImages.Contains(aImage), "Huh?");
 316   if (!mImages.PutEntry(aImage)) {
 317     NS_RUNTIMEABORT("OOM");
 318   }
 319 }
 320
 321 void
 322 ImageLoader::RemoveImage(ImageLoader::Image* aImage)
 323 {
 324   NS_ASSERTION(mImages.Contains(aImage), "Huh?");
 325   mImages.RemoveEntry(aImage);
 326 }
 327
 328 nsPresContext*
 329 ImageLoader::GetPresContext()
 330 {
 331   if (!mDocument) {
 332     return nullptr;
 333   }
 334
 335   nsIPresShell* shell = mDocument->GetShell();
 336   if (!shell) {
 337     return nullptr;
 338   }
 339
 340   return shell->GetPresContext();
 341 }
 342
 343 void InvalidateImagesCallback(nsIFrame* aFrame,
 344                               FrameLayerBuilder::DisplayItemData* aItem)
 345 {
 346   nsDisplayItem::Type type = nsDisplayItem::GetDisplayItemTypeFromKey(aItem->GetDisplayItemKey());
 347   uint8_t flags = nsDisplayItem::GetDisplayItemFlagsForType(type);
 348
 349   if (flags & nsDisplayItem::TYPE_RENDERS_NO_IMAGES) {
 350     return;
 351   }
 352
 353   aItem->Invalidate();
 354   aFrame->SchedulePaint();
 355
 356   // Update ancestor rendering observers (-moz-element etc)
 357   nsIFrame *f = aFrame;
 358   while (f && !f->HasAnyStateBits(NS_FRAME_DESCENDANT_NEEDS_PAINT)) {
 359     nsSVGEffects::InvalidateDirectRenderingObservers(f);
 360     f = nsLayoutUtils::GetCrossDocParentFrame(f);
 361   }
 362 }
 363
 364 void
 365 ImageLoader::DoRedraw(FrameSet* aFrameSet, bool aForcePaint)
 366 {
 367   NS_ASSERTION(aFrameSet, "Must have a frame set");
 368   NS_ASSERTION(mDocument, "Should have returned earlier!");
 369
 370   FrameSet::size_type length = aFrameSet->Length();
 371   for (FrameSet::size_type i = 0; i < length; i++) {
 372     nsIFrame* frame = aFrameSet->ElementAt(i);
 373
 374     if (frame->StyleVisibility()->IsVisible()) {
 375       if (frame->IsFrameOfType(nsIFrame::eTablePart)) {
 376         // Tables don't necessarily build border/background display items
 377         // for the individual table part frames, so IterateRetainedDataFor
 378         // might not find the right display item.
 379         frame->InvalidateFrame();
 380       } else {
 381         FrameLayerBuilder::IterateRetainedDataFor(frame, InvalidateImagesCallback);
 382         if (aForcePaint) {
 383           frame->SchedulePaint();
 384         }
 385       }
 386     }
 387   }
 388 }
 389
 390 NS_IMPL_ADDREF(ImageLoader)
 391 NS_IMPL_RELEASE(ImageLoader)
 392
 393 NS_INTERFACE_MAP_BEGIN(ImageLoader)
 394   NS_INTERFACE_MAP_ENTRY(imgINotificationObserver)
 395   NS_INTERFACE_MAP_ENTRY(imgIOnloadBlocker)
 396 NS_INTERFACE_MAP_END
 397
 398 NS_IMETHODIMP
 399 ImageLoader::Notify(imgIRequest* aRequest, int32_t aType, const nsIntRect* aData)
 400 {
 401   if (aType == imgINotificationObserver::SIZE_AVAILABLE) {
 402     nsCOMPtr<imgIContainer> image;
 403     aRequest->GetImage(getter_AddRefs(image));
 404     return OnSizeAvailable(aRequest, image);
 405   }
 406
 407   if (aType == imgINotificationObserver::IS_ANIMATED) {
 408     return OnImageIsAnimated(aRequest);
 409   }
 410
 411   if (aType == imgINotificationObserver::FRAME_COMPLETE) {
 412     return OnFrameComplete(aRequest);
 413   }
 414
 415   if (aType == imgINotificationObserver::FRAME_UPDATE) {
 416     return OnFrameUpdate(aRequest);
 417   }
 418
 419   return NS_OK;
 420 }
 421
 422 nsresult
 423 ImageLoader::OnSizeAvailable(imgIRequest* aRequest, imgIContainer* aImage)
 424 {
 425   nsPresContext* presContext = GetPresContext();
 426   if (!presContext) {
 427     return NS_OK;
 428   }
 429
 430   aImage->SetAnimationMode(presContext->ImageAnimationMode());
 431
 432   return NS_OK;
 433 }
 434
 435 nsresult
 436 ImageLoader::OnImageIsAnimated(imgIRequest* aRequest)
 437 {
 438   if (!mDocument) {
 439     return NS_OK;
 440   }
 441
 442   FrameSet* frameSet = nullptr;
 443   if (!mRequestToFrameMap.Get(aRequest, &frameSet)) {
 444     return NS_OK;
 445   }
 446
 447   // Register with the refresh driver now that we are aware that
 448   // we are animated.
 449   nsPresContext* presContext = GetPresContext();
 450   if (presContext) {
 451     nsLayoutUtils::RegisterImageRequest(presContext,
 452                                         aRequest,
 453                                         nullptr);
 454   }
 455
 456   return NS_OK;
 457 }
 458
 459 nsresult
 460 ImageLoader::OnFrameComplete(imgIRequest* aRequest)
 461 {
 462   if (!mDocument || mInClone) {
 463     return NS_OK;
 464   }
 465
 466   FrameSet* frameSet = nullptr;
 467   if (!mRequestToFrameMap.Get(aRequest, &frameSet)) {
 468     return NS_OK;
 469   }
 470
 471   NS_ASSERTION(frameSet, "This should never be null!");
 472
 473   // Since we just finished decoding a frame, we always want to paint, in case
 474   // we're now able to paint an image that we couldn't paint before (and hence
 475   // that we don't have retained data for).
 476   DoRedraw(frameSet, /* aForcePaint = */ true);
 477
 478   return NS_OK;
 479 }
 480
 481 nsresult
 482 ImageLoader::OnFrameUpdate(imgIRequest* aRequest)
 483 {
 484   if (!mDocument || mInClone) {
 485     return NS_OK;
 486   }
 487
 488   FrameSet* frameSet = nullptr;
 489   if (!mRequestToFrameMap.Get(aRequest, &frameSet)) {
 490     return NS_OK;
 491   }
 492
 493   NS_ASSERTION(frameSet, "This should never be null!");
 494
 495   DoRedraw(frameSet, /* aForcePaint = */ false);
 496
 497   return NS_OK;
 498 }
 499
 500 NS_IMETHODIMP
 501 ImageLoader::BlockOnload(imgIRequest* aRequest)
 502 {
 503   if (!mDocument) {
 504     return NS_OK;
 505   }
 506
 507   mDocument->BlockOnload();
 508
 509   return NS_OK;
 510 }
 511
 512 NS_IMETHODIMP
 513 ImageLoader::UnblockOnload(imgIRequest* aRequest)
 514 {
 515   if (!mDocument) {
 516     return NS_OK;
 517   }
 518
 519   mDocument->UnblockOnload(false);
 520
 521   return NS_OK;
 522 }
 523
 524 } // namespace css
 525 } // namespace mozilla