gecko-dev/image/MultipartImage.cpp

364 строки
13 KiB
C++

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* 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/. */
#include "MultipartImage.h"
#include "imgINotificationObserver.h"
namespace mozilla {
using gfx::IntSize;
using gfx::SourceSurface;
namespace image {
///////////////////////////////////////////////////////////////////////////////
// Helpers
///////////////////////////////////////////////////////////////////////////////
class NextPartObserver : public IProgressObserver {
public:
MOZ_DECLARE_REFCOUNTED_TYPENAME(NextPartObserver)
NS_INLINE_DECL_REFCOUNTING(NextPartObserver, override)
explicit NextPartObserver(MultipartImage* aOwner) : mOwner(aOwner) {
MOZ_ASSERT(mOwner);
}
void BeginObserving(Image* aImage) {
MOZ_ASSERT(aImage);
mImage = aImage;
RefPtr<ProgressTracker> tracker = mImage->GetProgressTracker();
tracker->AddObserver(this);
}
void BlockUntilDecodedAndFinishObserving() {
// Use RequestDecodeForSize() to block until our image finishes decoding.
// The size is ignored because we don't pass the FLAG_HIGH_QUALITY_SCALING
// flag.
mImage->RequestDecodeForSize(gfx::IntSize(0, 0),
imgIContainer::FLAG_SYNC_DECODE);
if (mImage && mImage->GetType() == imgIContainer::TYPE_VECTOR) {
// We don't want to make a pending part the current part until it has had
// it's load event because when we transition from the current part to the
// next part we remove the multipart image as an observer of the current
// part and the progress tracker will send a fake load event with the
// lastpart bit set whenever an observer is removed without having the
// load complete progress. That fake load event with the lastpart bit set
// will get out of the multipart image and to the imgRequestProxy and
// further, which will make it look like we got the last part of the
// multipart image and confuse things. If we get here then we are still
// waiting to make mNextPart the current part, but we've gotten
// OnDataAvailable for the part after mNextPart. That means we must have
// gotten OnStopRequest for mNextPart; OnStopRequest calls
// OnImageDataComplete. For raster images that are part of a multipart
// image OnImageDataComplete will synchronously fire the load event
// because we synchronously perform the metadata decode in that function,
// because parts of multipart images have the transient flag set. So for
// raster images we are assured that the load event has happened by this
// point for mNextPart. For vector images there is no such luck because
// OnImageDataComplete needs to wait for the load event in the underlying
// svg document, which we can't force to happen synchronously. So we just
// send a fake load event for mNextPart. We are the only listener for it
// right now so it won't confuse anyone. When the real load event comes,
// progress tracker won't send it out because it's already in the
// progress. And nobody should be caring about load events on the current
// part of multipart images since they might be sent multiple times or
// might not be sent at all depending on timing. So this should be okay.
RefPtr<ProgressTracker> tracker = mImage->GetProgressTracker();
if (tracker && !(tracker->GetProgress() & FLAG_LOAD_COMPLETE)) {
Progress loadProgress =
LoadCompleteProgress(/* aLastPart = */ false, /* aError = */ false,
/* aStatus = */ NS_OK);
tracker->SyncNotifyProgress(loadProgress | FLAG_SIZE_AVAILABLE);
}
}
// RequestDecodeForSize() should've sent synchronous notifications that
// would have caused us to call FinishObserving() (and null out mImage)
// already. If for some reason it didn't, we should do so here.
if (mImage) {
FinishObserving();
}
}
virtual void Notify(int32_t aType,
const nsIntRect* aRect = nullptr) override {
if (!mImage) {
// We've already finished observing the last image we were given.
return;
}
if (aType != imgINotificationObserver::FRAME_COMPLETE) {
return;
}
if (mImage && mImage->GetType() == imgIContainer::TYPE_VECTOR) {
RefPtr<ProgressTracker> tracker = mImage->GetProgressTracker();
if (tracker && !(tracker->GetProgress() & FLAG_LOAD_COMPLETE)) {
// Vector images can send frame complete during loading (any mutation in
// the underlying svg doc will call OnRenderingChange which sends frame
// complete). Whereas raster images can only send frame complete before
// the load event if there has been something to trigger a decode, but
// we do not request a decode. So we will ignore this for vector images
// so as to enforce the invariant described above in
// BlockUntilDecodedAndFinishObserving that the current part always has
// the load complete progress.
return;
}
}
FinishObserving();
}
virtual void OnLoadComplete(bool aLastPart) override {
if (!mImage) {
// We've already finished observing the last image we were given.
return;
}
// Retrieve the image's intrinsic size.
int32_t width = 0;
int32_t height = 0;
mImage->GetWidth(&width);
mImage->GetHeight(&height);
// Request decoding at the intrinsic size.
mImage->RequestDecodeForSize(IntSize(width, height),
imgIContainer::DECODE_FLAGS_DEFAULT |
imgIContainer::FLAG_HIGH_QUALITY_SCALING);
// If there's already an error, we may never get a FRAME_COMPLETE
// notification, so go ahead and notify our owner right away.
RefPtr<ProgressTracker> tracker = mImage->GetProgressTracker();
if (tracker->GetProgress() & FLAG_HAS_ERROR) {
FinishObserving();
return;
}
if (mImage && mImage->GetType() == imgIContainer::TYPE_VECTOR &&
(tracker->GetProgress() & FLAG_FRAME_COMPLETE)) {
// It's a vector image that we may have already got a frame complete
// before load that we ignored (see Notify above). Now that we have the
// load event too, we make this part current.
FinishObserving();
}
}
// Other notifications are ignored.
virtual void SetHasImage() override {}
virtual bool NotificationsDeferred() const override { return false; }
virtual void MarkPendingNotify() override {}
virtual void ClearPendingNotify() override {}
private:
virtual ~NextPartObserver() {}
void FinishObserving() {
MOZ_ASSERT(mImage);
RefPtr<ProgressTracker> tracker = mImage->GetProgressTracker();
tracker->RemoveObserver(this);
mImage = nullptr;
mOwner->FinishTransition();
}
MultipartImage* mOwner;
RefPtr<Image> mImage;
};
///////////////////////////////////////////////////////////////////////////////
// Implementation
///////////////////////////////////////////////////////////////////////////////
MultipartImage::MultipartImage(Image* aFirstPart)
: ImageWrapper(aFirstPart), mPendingNotify(false) {
mNextPartObserver = new NextPartObserver(this);
}
void MultipartImage::Init() {
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(mTracker, "Should've called SetProgressTracker() by now");
// Start observing the first part.
RefPtr<ProgressTracker> firstPartTracker = InnerImage()->GetProgressTracker();
firstPartTracker->AddObserver(this);
InnerImage()->IncrementAnimationConsumers();
}
MultipartImage::~MultipartImage() {
// Ask our ProgressTracker to drop its weak reference to us.
mTracker->ResetImage();
}
NS_IMPL_ISUPPORTS_INHERITED0(MultipartImage, ImageWrapper)
void MultipartImage::BeginTransitionToPart(Image* aNextPart) {
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(aNextPart);
if (mNextPart) {
// Let the decoder catch up so we don't drop frames.
mNextPartObserver->BlockUntilDecodedAndFinishObserving();
MOZ_ASSERT(!mNextPart);
}
mNextPart = aNextPart;
// Start observing the next part; we'll complete the transition when
// NextPartObserver calls FinishTransition.
mNextPartObserver->BeginObserving(mNextPart);
mNextPart->IncrementAnimationConsumers();
}
static Progress FilterProgress(Progress aProgress) {
// Filter out onload blocking notifications, since we don't want to block
// onload for multipart images.
// Filter out errors, since we don't want errors in one part to error out
// the whole stream.
return aProgress & ~FLAG_HAS_ERROR;
}
void MultipartImage::FinishTransition() {
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(mNextPart, "Should have a next part here");
RefPtr<ProgressTracker> newCurrentPartTracker =
mNextPart->GetProgressTracker();
if (newCurrentPartTracker->GetProgress() & FLAG_HAS_ERROR) {
// This frame has an error; drop it.
mNextPart = nullptr;
// We still need to notify, though.
mTracker->ResetForNewRequest();
RefPtr<ProgressTracker> currentPartTracker =
InnerImage()->GetProgressTracker();
mTracker->SyncNotifyProgress(
FilterProgress(currentPartTracker->GetProgress()));
return;
}
// Stop observing the current part.
{
RefPtr<ProgressTracker> currentPartTracker =
InnerImage()->GetProgressTracker();
currentPartTracker->RemoveObserver(this);
}
// Make the next part become the current part.
mTracker->ResetForNewRequest();
SetInnerImage(mNextPart);
mNextPart = nullptr;
newCurrentPartTracker->AddObserver(this);
// Finally, send all the notifications for the new current part and send a
// FRAME_UPDATE notification so that observers know to redraw.
mTracker->SyncNotifyProgress(
FilterProgress(newCurrentPartTracker->GetProgress()),
GetMaxSizedIntRect());
}
already_AddRefed<imgIContainer> MultipartImage::Unwrap() {
// Although we wrap another image, we don't allow callers to unwrap as. As far
// as external code is concerned, MultipartImage is atomic.
nsCOMPtr<imgIContainer> image = this;
return image.forget();
}
already_AddRefed<ProgressTracker> MultipartImage::GetProgressTracker() {
MOZ_ASSERT(mTracker);
RefPtr<ProgressTracker> tracker = mTracker;
return tracker.forget();
}
void MultipartImage::SetProgressTracker(ProgressTracker* aTracker) {
MOZ_ASSERT(aTracker);
MOZ_ASSERT(!mTracker);
mTracker = aTracker;
}
nsresult MultipartImage::OnImageDataAvailable(nsIRequest* aRequest,
nsIInputStream* aInStr,
uint64_t aSourceOffset,
uint32_t aCount) {
// Note that this method is special in that we forward it to the next part if
// one exists, and *not* the current part.
// We may trigger notifications that will free mNextPart, so keep it alive.
RefPtr<Image> nextPart = mNextPart;
if (nextPart) {
nextPart->OnImageDataAvailable(aRequest, aInStr, aSourceOffset, aCount);
} else {
InnerImage()->OnImageDataAvailable(aRequest, aInStr, aSourceOffset, aCount);
}
return NS_OK;
}
nsresult MultipartImage::OnImageDataComplete(nsIRequest* aRequest,
nsresult aStatus, bool aLastPart) {
// Note that this method is special in that we forward it to the next part if
// one exists, and *not* the current part.
// We may trigger notifications that will free mNextPart, so keep it alive.
RefPtr<Image> nextPart = mNextPart;
if (nextPart) {
nextPart->OnImageDataComplete(aRequest, aStatus, aLastPart);
} else {
InnerImage()->OnImageDataComplete(aRequest, aStatus, aLastPart);
}
return NS_OK;
}
void MultipartImage::Notify(int32_t aType,
const nsIntRect* aRect /* = nullptr*/) {
if (aType == imgINotificationObserver::SIZE_AVAILABLE) {
mTracker->SyncNotifyProgress(FLAG_SIZE_AVAILABLE);
} else if (aType == imgINotificationObserver::FRAME_UPDATE) {
mTracker->SyncNotifyProgress(NoProgress, *aRect);
} else if (aType == imgINotificationObserver::FRAME_COMPLETE) {
mTracker->SyncNotifyProgress(FLAG_FRAME_COMPLETE);
} else if (aType == imgINotificationObserver::LOAD_COMPLETE) {
mTracker->SyncNotifyProgress(FLAG_LOAD_COMPLETE);
} else if (aType == imgINotificationObserver::DECODE_COMPLETE) {
mTracker->SyncNotifyProgress(FLAG_DECODE_COMPLETE);
} else if (aType == imgINotificationObserver::DISCARD) {
mTracker->OnDiscard();
} else if (aType == imgINotificationObserver::UNLOCKED_DRAW) {
mTracker->OnUnlockedDraw();
} else if (aType == imgINotificationObserver::IS_ANIMATED) {
mTracker->SyncNotifyProgress(FLAG_IS_ANIMATED);
} else if (aType == imgINotificationObserver::HAS_TRANSPARENCY) {
mTracker->SyncNotifyProgress(FLAG_HAS_TRANSPARENCY);
} else {
MOZ_ASSERT_UNREACHABLE("Notification list should be exhaustive");
}
}
void MultipartImage::OnLoadComplete(bool aLastPart) {
Progress progress = FLAG_LOAD_COMPLETE;
if (aLastPart) {
progress |= FLAG_LAST_PART_COMPLETE;
}
mTracker->SyncNotifyProgress(progress);
}
void MultipartImage::SetHasImage() { mTracker->OnImageAvailable(); }
bool MultipartImage::NotificationsDeferred() const { return mPendingNotify; }
void MultipartImage::MarkPendingNotify() { mPendingNotify = true; }
void MultipartImage::ClearPendingNotify() { mPendingNotify = false; }
} // namespace image
} // namespace mozilla