diff -r 000000000000 -r 6474c204b198 layout/style/ImageLoader.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/layout/style/ImageLoader.cpp	Wed Dec 31 06:09:35 2014 +0100
@@ -0,0 +1,491 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/* A class that handles style system image loads (other image loads are handled
+ * by the nodes in the content tree).
+ */
+
+#include "mozilla/css/ImageLoader.h"
+#include "nsContentUtils.h"
+#include "nsLayoutUtils.h"
+#include "nsError.h"
+#include "nsDisplayList.h"
+#include "FrameLayerBuilder.h"
+#include "nsSVGEffects.h"
+#include "imgIContainer.h"
+
+namespace mozilla {
+namespace css {
+
+/* static */ PLDHashOperator
+ImageLoader::SetAnimationModeEnumerator(nsISupports* aKey, FrameSet* aValue,
+                                        void* aClosure)
+{
+  imgIRequest* request = static_cast<imgIRequest*>(aKey);
+
+  uint16_t* mode = static_cast<uint16_t*>(aClosure);
+
+#ifdef DEBUG
+  {
+    nsCOMPtr<imgIRequest> debugRequest = do_QueryInterface(aKey);
+    NS_ASSERTION(debugRequest == request, "This is bad");
+  }
+#endif
+
+  nsCOMPtr<imgIContainer> container;
+  request->GetImage(getter_AddRefs(container));
+  if (!container) {
+    return PL_DHASH_NEXT;
+  }
+
+  // This can fail if the image is in error, and we don't care.
+  container->SetAnimationMode(*mode);
+
+  return PL_DHASH_NEXT;
+}
+
+static PLDHashOperator
+ClearImageHashSet(nsPtrHashKey<ImageLoader::Image>* aKey, void* aClosure)
+{
+  nsIDocument* doc = static_cast<nsIDocument*>(aClosure);
+  ImageLoader::Image* image = aKey->GetKey();
+
+  imgIRequest* request = image->mRequests.GetWeak(doc);
+  if (request) {
+    request->CancelAndForgetObserver(NS_BINDING_ABORTED);
+  }
+
+  image->mRequests.Remove(doc);
+
+  return PL_DHASH_REMOVE;
+}
+
+void
+ImageLoader::DropDocumentReference()
+{
+  ClearFrames();
+  mImages.EnumerateEntries(&ClearImageHashSet, mDocument);
+  mDocument = nullptr;
+}
+
+void
+ImageLoader::AssociateRequestToFrame(imgIRequest* aRequest,
+                                     nsIFrame* aFrame)
+{
+  nsCOMPtr<imgINotificationObserver> observer;
+  aRequest->GetNotificationObserver(getter_AddRefs(observer));
+  if (!observer) {
+    // The request has already been canceled, so ignore it.  This is ok because
+    // we're not going to get any more notifications from a canceled request.
+    return;
+  }
+
+  MOZ_ASSERT(observer == this);
+
+  FrameSet* frameSet = nullptr;
+  if (mRequestToFrameMap.Get(aRequest, &frameSet)) {
+    NS_ASSERTION(frameSet, "This should never be null!");
+  }
+
+  if (!frameSet) {
+    nsAutoPtr<FrameSet> newFrameSet(new FrameSet());
+
+    mRequestToFrameMap.Put(aRequest, newFrameSet);
+    frameSet = newFrameSet.forget();
+
+    nsPresContext* presContext = GetPresContext();
+    if (presContext) {
+      nsLayoutUtils::RegisterImageRequestIfAnimated(presContext,
+                                                    aRequest,
+                                                    nullptr);
+    }
+  }
+
+  RequestSet* requestSet = nullptr;
+  if (mFrameToRequestMap.Get(aFrame, &requestSet)) {
+    NS_ASSERTION(requestSet, "This should never be null");
+  }
+
+  if (!requestSet) {
+    nsAutoPtr<RequestSet> newRequestSet(new RequestSet());
+
+    mFrameToRequestMap.Put(aFrame, newRequestSet);
+    requestSet = newRequestSet.forget();
+  }
+
+  // Add these to the sets, but only if they're not already there.
+  uint32_t i = frameSet->IndexOfFirstElementGt(aFrame);
+  if (i == 0 || aFrame != frameSet->ElementAt(i-1)) {
+    frameSet->InsertElementAt(i, aFrame);
+  }
+  i = requestSet->IndexOfFirstElementGt(aRequest);
+  if (i == 0 || aRequest != requestSet->ElementAt(i-1)) {
+    requestSet->InsertElementAt(i, aRequest);
+  }
+}
+
+void
+ImageLoader::MaybeRegisterCSSImage(ImageLoader::Image* aImage)
+{
+  NS_ASSERTION(aImage, "This should never be null!");
+
+  bool found = false;
+  aImage->mRequests.GetWeak(mDocument, &found);
+  if (found) {
+    // This document already has a request.
+    return;
+  }
+
+  imgRequestProxy* canonicalRequest = aImage->mRequests.GetWeak(nullptr);
+  if (!canonicalRequest) {
+    // The image was blocked or something.
+    return;
+  }
+
+  nsRefPtr<imgRequestProxy> request;
+
+  // Ignore errors here.  If cloning fails for some reason we'll put a null
+  // entry in the hash and we won't keep trying to clone.
+  mInClone = true;
+  canonicalRequest->Clone(this, getter_AddRefs(request));
+  mInClone = false;
+
+  aImage->mRequests.Put(mDocument, request);
+
+  AddImage(aImage);
+}
+
+void
+ImageLoader::DeregisterCSSImage(ImageLoader::Image* aImage)
+{
+  RemoveImage(aImage);
+}
+
+void
+ImageLoader::DisassociateRequestFromFrame(imgIRequest* aRequest,
+                                          nsIFrame* aFrame)
+{
+  FrameSet* frameSet = nullptr;
+  RequestSet* requestSet = nullptr;
+
+#ifdef DEBUG
+  {
+    nsCOMPtr<imgINotificationObserver> observer;
+    aRequest->GetNotificationObserver(getter_AddRefs(observer));
+    MOZ_ASSERT(!observer || observer == this);
+  }
+#endif
+
+  mRequestToFrameMap.Get(aRequest, &frameSet);
+  mFrameToRequestMap.Get(aFrame, &requestSet);
+
+  if (frameSet) {
+    frameSet->RemoveElementSorted(aFrame);
+  }
+  if (requestSet) {
+    requestSet->RemoveElementSorted(aRequest);
+  }
+
+  if (frameSet && !frameSet->Length()) {
+    mRequestToFrameMap.Remove(aRequest);
+
+    nsPresContext* presContext = GetPresContext();
+    if (presContext) {
+      nsLayoutUtils::DeregisterImageRequest(presContext,
+                                            aRequest,
+                                            nullptr);
+    }
+  }
+
+  if (requestSet && !requestSet->Length()) {
+    mFrameToRequestMap.Remove(aFrame);
+  }
+}
+
+void
+ImageLoader::DropRequestsForFrame(nsIFrame* aFrame)
+{
+  RequestSet* requestSet = nullptr;
+  if (!mFrameToRequestMap.Get(aFrame, &requestSet)) {
+    return;
+  }
+
+  NS_ASSERTION(requestSet, "This should never be null");
+
+  RequestSet frozenRequestSet(*requestSet);
+  for (RequestSet::size_type i = frozenRequestSet.Length(); i != 0; --i) {
+    imgIRequest* request = frozenRequestSet.ElementAt(i - 1);
+
+    DisassociateRequestFromFrame(request, aFrame);
+  }
+}
+
+void
+ImageLoader::SetAnimationMode(uint16_t aMode)
+{
+  NS_ASSERTION(aMode == imgIContainer::kNormalAnimMode ||
+               aMode == imgIContainer::kDontAnimMode ||
+               aMode == imgIContainer::kLoopOnceAnimMode,
+               "Wrong Animation Mode is being set!");
+
+  mRequestToFrameMap.EnumerateRead(SetAnimationModeEnumerator, &aMode);
+}
+
+void
+ImageLoader::ClearFrames()
+{
+  mRequestToFrameMap.Clear();
+  mFrameToRequestMap.Clear();
+}
+
+void
+ImageLoader::LoadImage(nsIURI* aURI, nsIPrincipal* aOriginPrincipal,
+                       nsIURI* aReferrer, ImageLoader::Image* aImage)
+{
+  NS_ASSERTION(aImage->mRequests.Count() == 0, "Huh?");
+
+  aImage->mRequests.Put(nullptr, nullptr);
+
+  if (!aURI) {
+    return;
+  }
+
+  if (!nsContentUtils::CanLoadImage(aURI, mDocument, mDocument,
+                                    aOriginPrincipal)) {
+    return;
+  }
+
+  nsRefPtr<imgRequestProxy> request;
+  nsContentUtils::LoadImage(aURI, mDocument, aOriginPrincipal, aReferrer,
+                            nullptr, nsIRequest::LOAD_NORMAL,
+                            NS_LITERAL_STRING("css"),
+                            getter_AddRefs(request));
+
+  if (!request) {
+    return;
+  }
+
+  nsRefPtr<imgRequestProxy> clonedRequest;
+  mInClone = true;
+  nsresult rv = request->Clone(this, getter_AddRefs(clonedRequest));
+  mInClone = false;
+
+  if (NS_FAILED(rv)) {
+    return;
+  }
+
+  aImage->mRequests.Put(nullptr, request);
+  aImage->mRequests.Put(mDocument, clonedRequest);
+
+  AddImage(aImage);
+}
+
+void
+ImageLoader::AddImage(ImageLoader::Image* aImage)
+{
+  NS_ASSERTION(!mImages.Contains(aImage), "Huh?");
+  if (!mImages.PutEntry(aImage)) {
+    NS_RUNTIMEABORT("OOM");
+  }
+}
+
+void
+ImageLoader::RemoveImage(ImageLoader::Image* aImage)
+{
+  NS_ASSERTION(mImages.Contains(aImage), "Huh?");
+  mImages.RemoveEntry(aImage);
+}
+
+nsPresContext*
+ImageLoader::GetPresContext()
+{
+  if (!mDocument) {
+    return nullptr;
+  }
+
+  nsIPresShell* shell = mDocument->GetShell();
+  if (!shell) {
+    return nullptr;
+  }
+
+  return shell->GetPresContext();
+}
+
+void InvalidateImagesCallback(nsIFrame* aFrame, 
+                              FrameLayerBuilder::DisplayItemData* aItem)
+{
+  nsDisplayItem::Type type = nsDisplayItem::GetDisplayItemTypeFromKey(aItem->GetDisplayItemKey());
+  uint8_t flags = nsDisplayItem::GetDisplayItemFlagsForType(type);
+
+  if (flags & nsDisplayItem::TYPE_RENDERS_NO_IMAGES) {
+    return;
+  }
+
+  aItem->Invalidate();
+
+  // Update ancestor rendering observers (-moz-element etc)
+  nsIFrame *f = aFrame;
+  while (f && !f->HasAnyStateBits(NS_FRAME_DESCENDANT_NEEDS_PAINT)) {
+    nsSVGEffects::InvalidateDirectRenderingObservers(f);
+    f = nsLayoutUtils::GetCrossDocParentFrame(f);
+  }
+}
+
+void
+ImageLoader::DoRedraw(FrameSet* aFrameSet)
+{
+  NS_ASSERTION(aFrameSet, "Must have a frame set");
+  NS_ASSERTION(mDocument, "Should have returned earlier!");
+
+  FrameSet::size_type length = aFrameSet->Length();
+  for (FrameSet::size_type i = 0; i < length; i++) {
+    nsIFrame* frame = aFrameSet->ElementAt(i);
+
+    if (frame->StyleVisibility()->IsVisible()) {
+      if (frame->IsFrameOfType(nsIFrame::eTablePart)) {
+        // Tables don't necessarily build border/background display items
+        // for the individual table part frames, so IterateRetainedDataFor
+        // might not find the right display item.
+        frame->InvalidateFrame();
+      } else {
+        FrameLayerBuilder::IterateRetainedDataFor(frame, InvalidateImagesCallback);
+        frame->SchedulePaint();
+      }
+    }
+  }
+}
+
+NS_IMPL_ADDREF(ImageLoader)
+NS_IMPL_RELEASE(ImageLoader)
+
+NS_INTERFACE_MAP_BEGIN(ImageLoader)
+  NS_INTERFACE_MAP_ENTRY(imgINotificationObserver)
+  NS_INTERFACE_MAP_ENTRY(imgIOnloadBlocker)
+NS_INTERFACE_MAP_END
+
+NS_IMETHODIMP
+ImageLoader::Notify(imgIRequest *aRequest, int32_t aType, const nsIntRect* aData)
+{
+  if (aType == imgINotificationObserver::SIZE_AVAILABLE) {
+    nsCOMPtr<imgIContainer> image;
+    aRequest->GetImage(getter_AddRefs(image));
+    return OnStartContainer(aRequest, image);
+  }
+
+  if (aType == imgINotificationObserver::IS_ANIMATED) {
+    return OnImageIsAnimated(aRequest);
+  }
+
+  if (aType == imgINotificationObserver::LOAD_COMPLETE) {
+    return OnStopFrame(aRequest);
+  }
+
+  if (aType == imgINotificationObserver::FRAME_UPDATE) {
+    return FrameChanged(aRequest);
+  }
+
+  return NS_OK;
+}
+
+nsresult
+ImageLoader::OnStartContainer(imgIRequest* aRequest, imgIContainer* aImage)
+{ 
+  nsPresContext* presContext = GetPresContext();
+  if (!presContext) {
+    return NS_OK;
+  }
+
+  aImage->SetAnimationMode(presContext->ImageAnimationMode());
+
+  return NS_OK;
+}
+
+nsresult
+ImageLoader::OnImageIsAnimated(imgIRequest* aRequest)
+{
+  if (!mDocument) {
+    return NS_OK;
+  }
+
+  FrameSet* frameSet = nullptr;
+  if (!mRequestToFrameMap.Get(aRequest, &frameSet)) {
+    return NS_OK;
+  }
+
+  // Register with the refresh driver now that we are aware that
+  // we are animated.
+  nsPresContext* presContext = GetPresContext();
+  if (presContext) {
+    nsLayoutUtils::RegisterImageRequest(presContext,
+                                        aRequest,
+                                        nullptr);
+  }
+
+  return NS_OK;
+}
+
+nsresult
+ImageLoader::OnStopFrame(imgIRequest *aRequest)
+{
+  if (!mDocument || mInClone) {
+    return NS_OK;
+  }
+
+  FrameSet* frameSet = nullptr;
+  if (!mRequestToFrameMap.Get(aRequest, &frameSet)) {
+    return NS_OK;
+  }
+
+  NS_ASSERTION(frameSet, "This should never be null!");
+
+  DoRedraw(frameSet);
+
+  return NS_OK;
+}
+
+nsresult
+ImageLoader::FrameChanged(imgIRequest *aRequest)
+{
+  if (!mDocument || mInClone) {
+    return NS_OK;
+  }
+
+  FrameSet* frameSet = nullptr;
+  if (!mRequestToFrameMap.Get(aRequest, &frameSet)) {
+    return NS_OK;
+  }
+
+  NS_ASSERTION(frameSet, "This should never be null!");
+
+  DoRedraw(frameSet);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+ImageLoader::BlockOnload(imgIRequest* aRequest)
+{
+  if (!mDocument) {
+    return NS_OK;
+  }
+
+  mDocument->BlockOnload();
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+ImageLoader::UnblockOnload(imgIRequest* aRequest)
+{
+  if (!mDocument) {
+    return NS_OK;
+  }
+
+  mDocument->UnblockOnload(false);
+
+  return NS_OK;
+}
+
+} // namespace css
+} // namespace mozilla