image/MultipartImage.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #include "MultipartImage.h"
   7
   8 #include "imgINotificationObserver.h"
   9
  10 namespace mozilla {
  11
  12 using gfx::IntSize;
  13 using gfx::SourceSurface;
  14
  15 namespace image {
  16
  17 ///////////////////////////////////////////////////////////////////////////////
  18 // Helpers
  19 ///////////////////////////////////////////////////////////////////////////////
  20
  21 class NextPartObserver : public IProgressObserver {
  22  public:
  23   MOZ_DECLARE_REFCOUNTED_TYPENAME(NextPartObserver)
  24   NS_INLINE_DECL_REFCOUNTING(NextPartObserver, override)
  25
  26   explicit NextPartObserver(MultipartImage* aOwner) : mOwner(aOwner) {
  27     MOZ_ASSERT(mOwner);
  28   }
  29
  30   void BeginObserving(Image* aImage) {
  31     MOZ_ASSERT(aImage);
  32     mImage = aImage;
  33
  34     RefPtr<ProgressTracker> tracker = mImage->GetProgressTracker();
  35     tracker->AddObserver(this);
  36   }
  37
  38   void BlockUntilDecodedAndFinishObserving() {
  39     // Use RequestDecodeForSize() to block until our image finishes decoding.
  40     // The size is ignored because we don't pass the FLAG_HIGH_QUALITY_SCALING
  41     // flag.
  42     mImage->RequestDecodeForSize(gfx::IntSize(0, 0),
  43                                  imgIContainer::FLAG_SYNC_DECODE);
  44
  45     // RequestDecodeForSize() should've sent synchronous notifications that
  46     // would have caused us to call FinishObserving() (and null out mImage)
  47     // already. If for some reason it didn't, we should do so here.
  48     if (mImage) {
  49       FinishObserving();
  50     }
  51   }
  52
  53   virtual void Notify(int32_t aType,
  54                       const nsIntRect* aRect = nullptr) override {
  55     if (!mImage) {
  56       // We've already finished observing the last image we were given.
  57       return;
  58     }
  59
  60     if (aType == imgINotificationObserver::FRAME_COMPLETE) {
  61       FinishObserving();
  62     }
  63   }
  64
  65   virtual void OnLoadComplete(bool aLastPart) override {
  66     if (!mImage) {
  67       // We've already finished observing the last image we were given.
  68       return;
  69     }
  70
  71     // Retrieve the image's intrinsic size.
  72     int32_t width = 0;
  73     int32_t height = 0;
  74     mImage->GetWidth(&width);
  75     mImage->GetHeight(&height);
  76
  77     // Request decoding at the intrinsic size.
  78     mImage->RequestDecodeForSize(IntSize(width, height),
  79                                  imgIContainer::DECODE_FLAGS_DEFAULT |
  80                                      imgIContainer::FLAG_HIGH_QUALITY_SCALING);
  81
  82     // If there's already an error, we may never get a FRAME_COMPLETE
  83     // notification, so go ahead and notify our owner right away.
  84     RefPtr<ProgressTracker> tracker = mImage->GetProgressTracker();
  85     if (tracker->GetProgress() & FLAG_HAS_ERROR) {
  86       FinishObserving();
  87     }
  88   }
  89
  90   // Other notifications are ignored.
  91   virtual void SetHasImage() override {}
  92   virtual bool NotificationsDeferred() const override { return false; }
  93   virtual void MarkPendingNotify() override {}
  94   virtual void ClearPendingNotify() override {}
  95
  96  private:
  97   virtual ~NextPartObserver() {}
  98
  99   void FinishObserving() {
 100     MOZ_ASSERT(mImage);
 101
 102     RefPtr<ProgressTracker> tracker = mImage->GetProgressTracker();
 103     tracker->RemoveObserver(this);
 104     mImage = nullptr;
 105
 106     mOwner->FinishTransition();
 107   }
 108
 109   MultipartImage* mOwner;
 110   RefPtr<Image> mImage;
 111 };
 112
 113 ///////////////////////////////////////////////////////////////////////////////
 114 // Implementation
 115 ///////////////////////////////////////////////////////////////////////////////
 116
 117 MultipartImage::MultipartImage(Image* aFirstPart)
 118     : ImageWrapper(aFirstPart), mPendingNotify(false) {
 119   mNextPartObserver = new NextPartObserver(this);
 120 }
 121
 122 void MultipartImage::Init() {
 123   MOZ_ASSERT(NS_IsMainThread());
 124   MOZ_ASSERT(mTracker, "Should've called SetProgressTracker() by now");
 125
 126   // Start observing the first part.
 127   RefPtr<ProgressTracker> firstPartTracker = InnerImage()->GetProgressTracker();
 128   firstPartTracker->AddObserver(this);
 129   InnerImage()->IncrementAnimationConsumers();
 130 }
 131
 132 MultipartImage::~MultipartImage() {
 133   // Ask our ProgressTracker to drop its weak reference to us.
 134   mTracker->ResetImage();
 135 }
 136
 137 NS_IMPL_ISUPPORTS_INHERITED0(MultipartImage, ImageWrapper)
 138
 139 void MultipartImage::BeginTransitionToPart(Image* aNextPart) {
 140   MOZ_ASSERT(NS_IsMainThread());
 141   MOZ_ASSERT(aNextPart);
 142
 143   if (mNextPart) {
 144     // Let the decoder catch up so we don't drop frames.
 145     mNextPartObserver->BlockUntilDecodedAndFinishObserving();
 146     MOZ_ASSERT(!mNextPart);
 147   }
 148
 149   mNextPart = aNextPart;
 150
 151   // Start observing the next part; we'll complete the transition when
 152   // NextPartObserver calls FinishTransition.
 153   mNextPartObserver->BeginObserving(mNextPart);
 154   mNextPart->IncrementAnimationConsumers();
 155 }
 156
 157 static Progress FilterProgress(Progress aProgress) {
 158   // Filter out onload blocking notifications, since we don't want to block
 159   // onload for multipart images.
 160   // Filter out errors, since we don't want errors in one part to error out
 161   // the whole stream.
 162   return aProgress & ~FLAG_HAS_ERROR;
 163 }
 164
 165 void MultipartImage::FinishTransition() {
 166   MOZ_ASSERT(NS_IsMainThread());
 167   MOZ_ASSERT(mNextPart, "Should have a next part here");
 168
 169   RefPtr<ProgressTracker> newCurrentPartTracker =
 170       mNextPart->GetProgressTracker();
 171   if (newCurrentPartTracker->GetProgress() & FLAG_HAS_ERROR) {
 172     // This frame has an error; drop it.
 173     mNextPart = nullptr;
 174
 175     // We still need to notify, though.
 176     mTracker->ResetForNewRequest();
 177     RefPtr<ProgressTracker> currentPartTracker =
 178         InnerImage()->GetProgressTracker();
 179     mTracker->SyncNotifyProgress(
 180         FilterProgress(currentPartTracker->GetProgress()));
 181
 182     return;
 183   }
 184
 185   // Stop observing the current part.
 186   {
 187     RefPtr<ProgressTracker> currentPartTracker =
 188         InnerImage()->GetProgressTracker();
 189     currentPartTracker->RemoveObserver(this);
 190   }
 191
 192   // Make the next part become the current part.
 193   mTracker->ResetForNewRequest();
 194   SetInnerImage(mNextPart);
 195   mNextPart = nullptr;
 196   newCurrentPartTracker->AddObserver(this);
 197
 198   // Finally, send all the notifications for the new current part and send a
 199   // FRAME_UPDATE notification so that observers know to redraw.
 200   mTracker->SyncNotifyProgress(
 201       FilterProgress(newCurrentPartTracker->GetProgress()),
 202       GetMaxSizedIntRect());
 203 }
 204
 205 already_AddRefed<imgIContainer> MultipartImage::Unwrap() {
 206   // Although we wrap another image, we don't allow callers to unwrap as. As far
 207   // as external code is concerned, MultipartImage is atomic.
 208   nsCOMPtr<imgIContainer> image = this;
 209   return image.forget();
 210 }
 211
 212 already_AddRefed<ProgressTracker> MultipartImage::GetProgressTracker() {
 213   MOZ_ASSERT(mTracker);
 214   RefPtr<ProgressTracker> tracker = mTracker;
 215   return tracker.forget();
 216 }
 217
 218 void MultipartImage::SetProgressTracker(ProgressTracker* aTracker) {
 219   MOZ_ASSERT(aTracker);
 220   MOZ_ASSERT(!mTracker);
 221   mTracker = aTracker;
 222 }
 223
 224 nsresult MultipartImage::OnImageDataAvailable(nsIRequest* aRequest,
 225                                               nsISupports* aContext,
 226                                               nsIInputStream* aInStr,
 227                                               uint64_t aSourceOffset,
 228                                               uint32_t aCount) {
 229   // Note that this method is special in that we forward it to the next part if
 230   // one exists, and *not* the current part.
 231
 232   // We may trigger notifications that will free mNextPart, so keep it alive.
 233   RefPtr<Image> nextPart = mNextPart;
 234   if (nextPart) {
 235     nextPart->OnImageDataAvailable(aRequest, aContext, aInStr, aSourceOffset,
 236                                    aCount);
 237   } else {
 238     InnerImage()->OnImageDataAvailable(aRequest, aContext, aInStr,
 239                                        aSourceOffset, aCount);
 240   }
 241
 242   return NS_OK;
 243 }
 244
 245 nsresult MultipartImage::OnImageDataComplete(nsIRequest* aRequest,
 246                                              nsISupports* aContext,
 247                                              nsresult aStatus, bool aLastPart) {
 248   // Note that this method is special in that we forward it to the next part if
 249   // one exists, and *not* the current part.
 250
 251   // We may trigger notifications that will free mNextPart, so keep it alive.
 252   RefPtr<Image> nextPart = mNextPart;
 253   if (nextPart) {
 254     nextPart->OnImageDataComplete(aRequest, aContext, aStatus, aLastPart);
 255   } else {
 256     InnerImage()->OnImageDataComplete(aRequest, aContext, aStatus, aLastPart);
 257   }
 258
 259   return NS_OK;
 260 }
 261
 262 void MultipartImage::Notify(int32_t aType,
 263                             const nsIntRect* aRect /* = nullptr*/) {
 264   if (aType == imgINotificationObserver::SIZE_AVAILABLE) {
 265     mTracker->SyncNotifyProgress(FLAG_SIZE_AVAILABLE);
 266   } else if (aType == imgINotificationObserver::FRAME_UPDATE) {
 267     mTracker->SyncNotifyProgress(NoProgress, *aRect);
 268   } else if (aType == imgINotificationObserver::FRAME_COMPLETE) {
 269     mTracker->SyncNotifyProgress(FLAG_FRAME_COMPLETE);
 270   } else if (aType == imgINotificationObserver::LOAD_COMPLETE) {
 271     mTracker->SyncNotifyProgress(FLAG_LOAD_COMPLETE);
 272   } else if (aType == imgINotificationObserver::DECODE_COMPLETE) {
 273     mTracker->SyncNotifyProgress(FLAG_DECODE_COMPLETE);
 274   } else if (aType == imgINotificationObserver::DISCARD) {
 275     mTracker->OnDiscard();
 276   } else if (aType == imgINotificationObserver::UNLOCKED_DRAW) {
 277     mTracker->OnUnlockedDraw();
 278   } else if (aType == imgINotificationObserver::IS_ANIMATED) {
 279     mTracker->SyncNotifyProgress(FLAG_IS_ANIMATED);
 280   } else if (aType == imgINotificationObserver::HAS_TRANSPARENCY) {
 281     mTracker->SyncNotifyProgress(FLAG_HAS_TRANSPARENCY);
 282   } else {
 283     MOZ_ASSERT_UNREACHABLE("Notification list should be exhaustive");
 284   }
 285 }
 286
 287 void MultipartImage::OnLoadComplete(bool aLastPart) {
 288   Progress progress = FLAG_LOAD_COMPLETE;
 289   if (aLastPart) {
 290     progress |= FLAG_LAST_PART_COMPLETE;
 291   }
 292   mTracker->SyncNotifyProgress(progress);
 293 }
 294
 295 void MultipartImage::SetHasImage() { mTracker->OnImageAvailable(); }
 296
 297 bool MultipartImage::NotificationsDeferred() const { return mPendingNotify; }
 298
 299 void MultipartImage::MarkPendingNotify() { mPendingNotify = true; }
 300
 301 void MultipartImage::ClearPendingNotify() { mPendingNotify = false; }
 302
 303 }  // namespace image
 304 }  // namespace mozilla