forked from mozilla/gecko-dev
-
Notifications
You must be signed in to change notification settings - Fork 2
/
Image.h
238 lines (205 loc) · 8.1 KB
/
Image.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
/* -*- 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/. */
#ifndef MOZILLA_IMAGELIB_IMAGE_H_
#define MOZILLA_IMAGELIB_IMAGE_H_
#include "mozilla/MemoryReporting.h"
#include "mozilla/TimeStamp.h"
#include "gfx2DGlue.h" // for gfxMemoryLocation
#include "imgIContainer.h"
#include "ProgressTracker.h"
#include "ImageURL.h"
#include "nsStringFwd.h"
class nsIRequest;
class nsIInputStream;
namespace mozilla {
namespace image {
class Image : public imgIContainer
{
public:
// Mimetype translation
enum eDecoderType {
eDecoderType_png = 0,
eDecoderType_gif = 1,
eDecoderType_jpeg = 2,
eDecoderType_bmp = 3,
eDecoderType_ico = 4,
eDecoderType_icon = 5,
eDecoderType_unknown = 6
};
static eDecoderType GetDecoderType(const char* aMimeType);
/**
* Flags for Image initialization.
*
* Meanings:
*
* INIT_FLAG_NONE: Lack of flags
*
* INIT_FLAG_DISCARDABLE: The container should be discardable
*
* INIT_FLAG_DECODE_ON_DRAW: The container should decode on draw rather than
* decoding on load.
*
* INIT_FLAG_TRANSIENT: The container is likely to exist for only a short time
* before being destroyed. (For example, containers for
* multipart/x-mixed-replace image parts fall into this category.) If this
* flag is set, INIT_FLAG_DISCARDABLE and INIT_FLAG_DECODE_ON_DRAW must not be
* set.
*
* INIT_FLAG_DOWNSCALE_DURING_DECODE: The container should attempt to
* downscale images during decoding instead of decoding them to their
* intrinsic size.
*/
static const uint32_t INIT_FLAG_NONE = 0x0;
static const uint32_t INIT_FLAG_DISCARDABLE = 0x1;
static const uint32_t INIT_FLAG_DECODE_ON_DRAW = 0x2;
static const uint32_t INIT_FLAG_TRANSIENT = 0x4;
static const uint32_t INIT_FLAG_DOWNSCALE_DURING_DECODE = 0x8;
/**
* Creates a new image container.
*
* @param aMimeType The mimetype of the image.
* @param aFlags Initialization flags of the INIT_FLAG_* variety.
*/
virtual nsresult Init(const char* aMimeType,
uint32_t aFlags) = 0;
virtual already_AddRefed<ProgressTracker> GetProgressTracker() = 0;
virtual void SetProgressTracker(ProgressTracker* aProgressTracker) {}
/**
* The size, in bytes, occupied by the compressed source data of the image.
* If MallocSizeOf does not work on this platform, uses a fallback approach to
* ensure that something reasonable is always returned.
*/
virtual size_t SizeOfSourceWithComputedFallback(
MallocSizeOf aMallocSizeOf) const = 0;
/**
* The size, in bytes, occupied by the image's decoded data.
*/
virtual size_t SizeOfDecoded(gfxMemoryLocation aLocation,
MallocSizeOf aMallocSizeOf) const = 0;
virtual void IncrementAnimationConsumers() = 0;
virtual void DecrementAnimationConsumers() = 0;
#ifdef DEBUG
virtual uint32_t GetAnimationConsumers() = 0;
#endif
/**
* Called from OnDataAvailable when the stream associated with the image has
* received new image data. The arguments are the same as OnDataAvailable's,
* but by separating this functionality into a different method we don't
* interfere with subclasses which wish to implement nsIStreamListener.
*
* Images should not do anything that could send out notifications until they
* have received their first OnImageDataAvailable notification; in
* particular, this means that instantiating decoders should be deferred
* until OnImageDataAvailable is called.
*/
virtual nsresult OnImageDataAvailable(nsIRequest* aRequest,
nsISupports* aContext,
nsIInputStream* aInStr,
uint64_t aSourceOffset,
uint32_t aCount) = 0;
/**
* Called from OnStopRequest when the image's underlying request completes.
*
* @param aRequest The completed request.
* @param aContext Context from Necko's OnStopRequest.
* @param aStatus A success or failure code.
* @param aLastPart Whether this is the final part of the underlying request.
*/
virtual nsresult OnImageDataComplete(nsIRequest* aRequest,
nsISupports* aContext,
nsresult aStatus,
bool aLastPart) = 0;
/**
* Called when the SurfaceCache discards a persistent surface belonging to
* this image.
*/
virtual void OnSurfaceDiscarded() = 0;
virtual void SetInnerWindowID(uint64_t aInnerWindowId) = 0;
virtual uint64_t InnerWindowID() const = 0;
virtual bool HasError() = 0;
virtual void SetHasError() = 0;
virtual ImageURL* GetURI() = 0;
};
class ImageResource : public Image
{
public:
already_AddRefed<ProgressTracker> GetProgressTracker() MOZ_OVERRIDE
{
nsRefPtr<ProgressTracker> progressTracker = mProgressTracker;
MOZ_ASSERT(progressTracker);
return progressTracker.forget();
}
void SetProgressTracker(
ProgressTracker* aProgressTracker) MOZ_OVERRIDE MOZ_FINAL
{
MOZ_ASSERT(aProgressTracker);
MOZ_ASSERT(!mProgressTracker);
mProgressTracker = aProgressTracker;
}
virtual void IncrementAnimationConsumers() MOZ_OVERRIDE;
virtual void DecrementAnimationConsumers() MOZ_OVERRIDE;
#ifdef DEBUG
virtual uint32_t GetAnimationConsumers() MOZ_OVERRIDE
{
return mAnimationConsumers;
}
#endif
virtual void OnSurfaceDiscarded() MOZ_OVERRIDE { }
virtual void SetInnerWindowID(uint64_t aInnerWindowId) MOZ_OVERRIDE
{
mInnerWindowId = aInnerWindowId;
}
virtual uint64_t InnerWindowID() const MOZ_OVERRIDE { return mInnerWindowId; }
virtual bool HasError() MOZ_OVERRIDE { return mError; }
virtual void SetHasError() MOZ_OVERRIDE { mError = true; }
/*
* Returns a non-AddRefed pointer to the URI associated with this image.
* Illegal to use off-main-thread.
*/
virtual ImageURL* GetURI() MOZ_OVERRIDE { return mURI.get(); }
protected:
explicit ImageResource(ImageURL* aURI);
// Shared functionality for implementors of imgIContainer. Every
// implementation of attribute animationMode should forward here.
nsresult GetAnimationModeInternal(uint16_t* aAnimationMode);
nsresult SetAnimationModeInternal(uint16_t aAnimationMode);
/**
* Helper for RequestRefresh.
*
* If we've had a "recent" refresh (i.e. if this image is being used in
* multiple documents & some other document *just* called RequestRefresh() on
* this image with a timestamp close to aTime), this method returns true.
*
* Otherwise, this method updates mLastRefreshTime to aTime & returns false.
*/
bool HadRecentRefresh(const TimeStamp& aTime);
/**
* Decides whether animation should or should not be happening,
* and makes sure the right thing is being done.
*/
virtual void EvaluateAnimation();
/**
* Extended by child classes, if they have additional
* conditions for being able to animate.
*/
virtual bool ShouldAnimate() {
return mAnimationConsumers > 0 && mAnimationMode != kDontAnimMode;
}
virtual nsresult StartAnimation() = 0;
virtual nsresult StopAnimation() = 0;
// Member data shared by all implementations of this abstract class
nsRefPtr<ProgressTracker> mProgressTracker;
nsRefPtr<ImageURL> mURI;
TimeStamp mLastRefreshTime;
uint64_t mInnerWindowId;
uint32_t mAnimationConsumers;
uint16_t mAnimationMode; // Enum values in imgIContainer
bool mInitialized:1; // Have we been initalized?
bool mAnimating:1; // Are we currently animating?
bool mError:1; // Error handling
};
} // namespace image
} // namespace mozilla
#endif // MOZILLA_IMAGELIB_IMAGE_H_