--- a/gfx/2d/DataSourceSurfaceWrapper.h
+++ b/gfx/2d/DataSourceSurfaceWrapper.h
@@ -11,17 +11,17 @@
namespace mozilla {
namespace gfx {
// Wraps a DataSourceSurface and forwards all methods except for GetType(),
// from which it always returns SurfaceType::DATA.
class DataSourceSurfaceWrapper : public DataSourceSurface
{
public:
- MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(DataSourceSurfaceWrapper)
+ MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(DataSourceSurfaceWrapper, MOZ_OVERRIDE)
explicit DataSourceSurfaceWrapper(DataSourceSurface *aSurface)
: mSurface(aSurface)
{}
virtual SurfaceType GetType() const MOZ_OVERRIDE { return SurfaceType::DATA; }
virtual uint8_t *GetData() MOZ_OVERRIDE { return mSurface->GetData(); }
virtual int32_t Stride() MOZ_OVERRIDE { return mSurface->Stride(); }
--- a/gfx/2d/DrawTargetCG.h
+++ b/gfx/2d/DrawTargetCG.h
@@ -89,102 +89,102 @@ SetStrokeOptions(CGContextRef cg, const
CGContextSetLineDash(cg, aStrokeOptions.mDashOffset, dashes, aStrokeOptions.mDashLength);
delete[] dashes;
}
}
class GlyphRenderingOptionsCG : public GlyphRenderingOptions
{
public:
- MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(GlyphRenderingOptionsCG)
+ MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(GlyphRenderingOptionsCG, MOZ_OVERRIDE)
explicit GlyphRenderingOptionsCG(const Color &aFontSmoothingBackgroundColor)
: mFontSmoothingBackgroundColor(aFontSmoothingBackgroundColor)
{}
const Color &FontSmoothingBackgroundColor() const { return mFontSmoothingBackgroundColor; }
virtual FontType GetType() const MOZ_OVERRIDE { return FontType::MAC; }
private:
Color mFontSmoothingBackgroundColor;
};
class DrawTargetCG : public DrawTarget
{
public:
- MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(DrawTargetCG)
+ MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(DrawTargetCG, MOZ_OVERRIDE)
friend class BorrowedCGContext;
friend class SourceSurfaceCGBitmapContext;
DrawTargetCG();
virtual ~DrawTargetCG();
virtual DrawTargetType GetType() const MOZ_OVERRIDE;
- virtual BackendType GetBackendType() const;
- virtual TemporaryRef<SourceSurface> Snapshot();
+ virtual BackendType GetBackendType() const MOZ_OVERRIDE;
+ virtual TemporaryRef<SourceSurface> Snapshot() MOZ_OVERRIDE;
virtual void DrawSurface(SourceSurface *aSurface,
const Rect &aDest,
const Rect &aSource,
const DrawSurfaceOptions &aSurfOptions = DrawSurfaceOptions(),
- const DrawOptions &aOptions = DrawOptions());
+ const DrawOptions &aOptions = DrawOptions()) MOZ_OVERRIDE;
virtual void DrawFilter(FilterNode *aNode,
const Rect &aSourceRect,
const Point &aDestPoint,
- const DrawOptions &aOptions = DrawOptions());
+ const DrawOptions &aOptions = DrawOptions()) MOZ_OVERRIDE;
virtual void MaskSurface(const Pattern &aSource,
SourceSurface *aMask,
Point aOffset,
- const DrawOptions &aOptions = DrawOptions());
+ const DrawOptions &aOptions = DrawOptions()) MOZ_OVERRIDE;
virtual void FillRect(const Rect &aRect,
const Pattern &aPattern,
- const DrawOptions &aOptions = DrawOptions());
+ const DrawOptions &aOptions = DrawOptions()) MOZ_OVERRIDE;
//XXX: why do we take a reference to SurfaceFormat?
bool Init(BackendType aType, const IntSize &aSize, SurfaceFormat&);
bool Init(BackendType aType, unsigned char* aData, const IntSize &aSize, int32_t aStride, SurfaceFormat aFormat);
bool Init(CGContextRef cgContext, const IntSize &aSize);
// Flush if using IOSurface context
- virtual void Flush();
+ virtual void Flush() MOZ_OVERRIDE;
- virtual void DrawSurfaceWithShadow(SourceSurface *, const Point &, const Color &, const Point &, Float, CompositionOp);
- virtual void ClearRect(const Rect &);
- virtual void CopySurface(SourceSurface *, const IntRect&, const IntPoint&);
- virtual void StrokeRect(const Rect &, const Pattern &, const StrokeOptions&, const DrawOptions&);
- virtual void StrokeLine(const Point &, const Point &, const Pattern &, const StrokeOptions &, const DrawOptions &);
- virtual void Stroke(const Path *, const Pattern &, const StrokeOptions &, const DrawOptions &);
- virtual void Fill(const Path *, const Pattern &, const DrawOptions &);
- virtual void FillGlyphs(ScaledFont *, const GlyphBuffer&, const Pattern &, const DrawOptions &, const GlyphRenderingOptions *);
+ virtual void DrawSurfaceWithShadow(SourceSurface *, const Point &, const Color &, const Point &, Float, CompositionOp) MOZ_OVERRIDE;
+ virtual void ClearRect(const Rect &) MOZ_OVERRIDE;
+ virtual void CopySurface(SourceSurface *, const IntRect&, const IntPoint&) MOZ_OVERRIDE;
+ virtual void StrokeRect(const Rect &, const Pattern &, const StrokeOptions&, const DrawOptions&) MOZ_OVERRIDE;
+ virtual void StrokeLine(const Point &, const Point &, const Pattern &, const StrokeOptions &, const DrawOptions &) MOZ_OVERRIDE;
+ virtual void Stroke(const Path *, const Pattern &, const StrokeOptions &, const DrawOptions &) MOZ_OVERRIDE;
+ virtual void Fill(const Path *, const Pattern &, const DrawOptions &) MOZ_OVERRIDE;
+ virtual void FillGlyphs(ScaledFont *, const GlyphBuffer&, const Pattern &, const DrawOptions &, const GlyphRenderingOptions *) MOZ_OVERRIDE;
virtual void Mask(const Pattern &aSource,
const Pattern &aMask,
- const DrawOptions &aOptions = DrawOptions());
- virtual void PushClip(const Path *);
- virtual void PushClipRect(const Rect &aRect);
- virtual void PopClip();
- virtual TemporaryRef<SourceSurface> CreateSourceSurfaceFromNativeSurface(const NativeSurface&) const { return nullptr;}
- virtual TemporaryRef<DrawTarget> CreateSimilarDrawTarget(const IntSize &, SurfaceFormat) const;
- virtual TemporaryRef<PathBuilder> CreatePathBuilder(FillRule) const;
+ const DrawOptions &aOptions = DrawOptions()) MOZ_OVERRIDE;
+ virtual void PushClip(const Path *) MOZ_OVERRIDE;
+ virtual void PushClipRect(const Rect &aRect) MOZ_OVERRIDE;
+ virtual void PopClip() MOZ_OVERRIDE;
+ virtual TemporaryRef<SourceSurface> CreateSourceSurfaceFromNativeSurface(const NativeSurface&) const MOZ_OVERRIDE { return nullptr;}
+ virtual TemporaryRef<DrawTarget> CreateSimilarDrawTarget(const IntSize &, SurfaceFormat) const MOZ_OVERRIDE;
+ virtual TemporaryRef<PathBuilder> CreatePathBuilder(FillRule) const MOZ_OVERRIDE;
virtual TemporaryRef<GradientStops> CreateGradientStops(GradientStop *, uint32_t,
- ExtendMode aExtendMode = ExtendMode::CLAMP) const;
- virtual TemporaryRef<FilterNode> CreateFilter(FilterType aType);
+ ExtendMode aExtendMode = ExtendMode::CLAMP) const MOZ_OVERRIDE;
+ virtual TemporaryRef<FilterNode> CreateFilter(FilterType aType) MOZ_OVERRIDE;
- virtual void *GetNativeSurface(NativeSurfaceType);
+ virtual void *GetNativeSurface(NativeSurfaceType) MOZ_OVERRIDE;
- virtual IntSize GetSize() { return mSize; }
+ virtual IntSize GetSize() MOZ_OVERRIDE { return mSize; }
/* This is for creating good compatible surfaces */
virtual TemporaryRef<SourceSurface> CreateSourceSurfaceFromData(unsigned char *aData,
const IntSize &aSize,
int32_t aStride,
- SurfaceFormat aFormat) const;
- virtual TemporaryRef<SourceSurface> OptimizeSourceSurface(SourceSurface *aSurface) const;
+ SurfaceFormat aFormat) const MOZ_OVERRIDE;
+ virtual TemporaryRef<SourceSurface> OptimizeSourceSurface(SourceSurface *aSurface) const MOZ_OVERRIDE;
CGContextRef GetCGContext() {
return mCg;
}
private:
void MarkChanged();
IntSize mSize;
CGColorSpaceRef mColorSpace;
--- a/gfx/2d/DrawTargetCairo.h
+++ b/gfx/2d/DrawTargetCairo.h
@@ -47,126 +47,126 @@ class GradientStopsCairo : public Gradie
private:
std::vector<GradientStop> mStops;
ExtendMode mExtendMode;
};
class DrawTargetCairo : public DrawTarget
{
public:
- MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(DrawTargetCairo)
+ MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(DrawTargetCairo, MOZ_OVERRIDE)
friend class BorrowedCairoContext;
DrawTargetCairo();
virtual ~DrawTargetCairo();
virtual DrawTargetType GetType() const MOZ_OVERRIDE;
- virtual BackendType GetBackendType() const { return BackendType::CAIRO; }
- virtual TemporaryRef<SourceSurface> Snapshot();
- virtual IntSize GetSize();
+ virtual BackendType GetBackendType() const MOZ_OVERRIDE { return BackendType::CAIRO; }
+ virtual TemporaryRef<SourceSurface> Snapshot() MOZ_OVERRIDE;
+ virtual IntSize GetSize() MOZ_OVERRIDE;
- virtual void SetPermitSubpixelAA(bool aPermitSubpixelAA);
+ virtual void SetPermitSubpixelAA(bool aPermitSubpixelAA) MOZ_OVERRIDE;
virtual bool LockBits(uint8_t** aData, IntSize* aSize,
- int32_t* aStride, SurfaceFormat* aFormat);
- virtual void ReleaseBits(uint8_t* aData);
+ int32_t* aStride, SurfaceFormat* aFormat) MOZ_OVERRIDE;
+ virtual void ReleaseBits(uint8_t* aData) MOZ_OVERRIDE;
- virtual void Flush();
+ virtual void Flush() MOZ_OVERRIDE;
virtual void DrawSurface(SourceSurface *aSurface,
const Rect &aDest,
const Rect &aSource,
const DrawSurfaceOptions &aSurfOptions = DrawSurfaceOptions(),
- const DrawOptions &aOptions = DrawOptions());
+ const DrawOptions &aOptions = DrawOptions()) MOZ_OVERRIDE;
virtual void DrawFilter(FilterNode *aNode,
const Rect &aSourceRect,
const Point &aDestPoint,
- const DrawOptions &aOptions = DrawOptions());
+ const DrawOptions &aOptions = DrawOptions()) MOZ_OVERRIDE;
virtual void DrawSurfaceWithShadow(SourceSurface *aSurface,
const Point &aDest,
const Color &aColor,
const Point &aOffset,
Float aSigma,
- CompositionOp aOperator);
+ CompositionOp aOperator) MOZ_OVERRIDE;
- virtual void ClearRect(const Rect &aRect);
+ virtual void ClearRect(const Rect &aRect) MOZ_OVERRIDE;
virtual void CopySurface(SourceSurface *aSurface,
const IntRect &aSourceRect,
- const IntPoint &aDestination);
+ const IntPoint &aDestination) MOZ_OVERRIDE;
virtual void CopyRect(const IntRect &aSourceRect,
- const IntPoint &aDestination);
+ const IntPoint &aDestination) MOZ_OVERRIDE;
virtual void FillRect(const Rect &aRect,
const Pattern &aPattern,
- const DrawOptions &aOptions = DrawOptions());
+ const DrawOptions &aOptions = DrawOptions()) MOZ_OVERRIDE;
virtual void StrokeRect(const Rect &aRect,
const Pattern &aPattern,
const StrokeOptions &aStrokeOptions = StrokeOptions(),
- const DrawOptions &aOptions = DrawOptions());
+ const DrawOptions &aOptions = DrawOptions()) MOZ_OVERRIDE;
virtual void StrokeLine(const Point &aStart,
const Point &aEnd,
const Pattern &aPattern,
const StrokeOptions &aStrokeOptions = StrokeOptions(),
- const DrawOptions &aOptions = DrawOptions());
+ const DrawOptions &aOptions = DrawOptions()) MOZ_OVERRIDE;
virtual void Stroke(const Path *aPath,
const Pattern &aPattern,
const StrokeOptions &aStrokeOptions = StrokeOptions(),
- const DrawOptions &aOptions = DrawOptions());
+ const DrawOptions &aOptions = DrawOptions()) MOZ_OVERRIDE;
virtual void Fill(const Path *aPath,
const Pattern &aPattern,
- const DrawOptions &aOptions = DrawOptions());
+ const DrawOptions &aOptions = DrawOptions()) MOZ_OVERRIDE;
virtual void FillGlyphs(ScaledFont *aFont,
const GlyphBuffer &aBuffer,
const Pattern &aPattern,
const DrawOptions &aOptions,
- const GlyphRenderingOptions *aRenderingOptions = nullptr);
+ const GlyphRenderingOptions *aRenderingOptions = nullptr) MOZ_OVERRIDE;
virtual void Mask(const Pattern &aSource,
const Pattern &aMask,
- const DrawOptions &aOptions = DrawOptions());
+ const DrawOptions &aOptions = DrawOptions()) MOZ_OVERRIDE;
virtual void MaskSurface(const Pattern &aSource,
SourceSurface *aMask,
Point aOffset,
- const DrawOptions &aOptions = DrawOptions());
+ const DrawOptions &aOptions = DrawOptions()) MOZ_OVERRIDE;
- virtual void PushClip(const Path *aPath);
- virtual void PushClipRect(const Rect &aRect);
- virtual void PopClip();
+ virtual void PushClip(const Path *aPath) MOZ_OVERRIDE;
+ virtual void PushClipRect(const Rect &aRect) MOZ_OVERRIDE;
+ virtual void PopClip() MOZ_OVERRIDE;
- virtual TemporaryRef<PathBuilder> CreatePathBuilder(FillRule aFillRule = FillRule::FILL_WINDING) const;
+ virtual TemporaryRef<PathBuilder> CreatePathBuilder(FillRule aFillRule = FillRule::FILL_WINDING) const MOZ_OVERRIDE;
virtual TemporaryRef<SourceSurface> CreateSourceSurfaceFromData(unsigned char *aData,
const IntSize &aSize,
int32_t aStride,
- SurfaceFormat aFormat) const;
- virtual TemporaryRef<SourceSurface> OptimizeSourceSurface(SourceSurface *aSurface) const;
+ SurfaceFormat aFormat) const MOZ_OVERRIDE;
+ virtual TemporaryRef<SourceSurface> OptimizeSourceSurface(SourceSurface *aSurface) const MOZ_OVERRIDE;
virtual TemporaryRef<SourceSurface>
- CreateSourceSurfaceFromNativeSurface(const NativeSurface &aSurface) const;
+ CreateSourceSurfaceFromNativeSurface(const NativeSurface &aSurface) const MOZ_OVERRIDE;
virtual TemporaryRef<DrawTarget>
- CreateSimilarDrawTarget(const IntSize &aSize, SurfaceFormat aFormat) const;
+ CreateSimilarDrawTarget(const IntSize &aSize, SurfaceFormat aFormat) const MOZ_OVERRIDE;
virtual TemporaryRef<DrawTarget>
CreateShadowDrawTarget(const IntSize &aSize, SurfaceFormat aFormat,
- float aSigma) const;
+ float aSigma) const MOZ_OVERRIDE;
virtual TemporaryRef<GradientStops>
CreateGradientStops(GradientStop *aStops,
uint32_t aNumStops,
- ExtendMode aExtendMode = ExtendMode::CLAMP) const;
+ ExtendMode aExtendMode = ExtendMode::CLAMP) const MOZ_OVERRIDE;
- virtual TemporaryRef<FilterNode> CreateFilter(FilterType aType);
+ virtual TemporaryRef<FilterNode> CreateFilter(FilterType aType) MOZ_OVERRIDE;
- virtual void *GetNativeSurface(NativeSurfaceType aType);
+ virtual void *GetNativeSurface(NativeSurfaceType aType) MOZ_OVERRIDE;
bool Init(cairo_surface_t* aSurface, const IntSize& aSize, SurfaceFormat* aFormat = nullptr);
bool Init(const IntSize& aSize, SurfaceFormat aFormat);
bool Init(unsigned char* aData, const IntSize &aSize, int32_t aStride, SurfaceFormat aFormat);
- virtual void SetTransform(const Matrix& aTransform);
+ virtual void SetTransform(const Matrix& aTransform) MOZ_OVERRIDE;
// Call to set up aContext for drawing (with the current transform, etc).
// Pass the path you're going to be using if you have one.
// Implicitly calls WillChange(aPath).
void PrepareForDrawing(cairo_t* aContext, const Path* aPath = nullptr);
static cairo_surface_t *GetDummySurface();
--- a/gfx/2d/DrawTargetDual.h
+++ b/gfx/2d/DrawTargetDual.h
@@ -13,148 +13,148 @@
#include "2D.h"
#include "Filters.h"
namespace mozilla {
namespace gfx {
#define FORWARD_FUNCTION(funcName) \
- virtual void funcName() { mA->funcName(); mB->funcName(); }
+ virtual void funcName() MOZ_OVERRIDE { mA->funcName(); mB->funcName(); }
#define FORWARD_FUNCTION1(funcName, var1Type, var1Name) \
- virtual void funcName(var1Type var1Name) { mA->funcName(var1Name); mB->funcName(var1Name); }
+ virtual void funcName(var1Type var1Name) MOZ_OVERRIDE { mA->funcName(var1Name); mB->funcName(var1Name); }
/* This is a special type of DrawTarget. It duplicates all drawing calls
* accross two drawtargets. An exception to this is when a snapshot of another
* dual DrawTarget is used as the source for any surface data. In this case
* the snapshot of the first source DrawTarget is used as a source for the call
* to the first destination DrawTarget (mA) and the snapshot of the second
* source DrawTarget is used at the source for the second destination
* DrawTarget (mB). This class facilitates black-background/white-background
* drawing for per-component alpha extraction for backends which do not support
* native component alpha.
*/
class DrawTargetDual : public DrawTarget
{
public:
- MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(DrawTargetDual)
+ MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(DrawTargetDual, MOZ_OVERRIDE)
DrawTargetDual(DrawTarget *aA, DrawTarget *aB)
: mA(aA)
, mB(aB)
{
mFormat = aA->GetFormat();
}
virtual DrawTargetType GetType() const MOZ_OVERRIDE { return mA->GetType(); }
- virtual BackendType GetBackendType() const { return mA->GetBackendType(); }
- virtual TemporaryRef<SourceSurface> Snapshot() { return new SourceSurfaceDual(mA, mB); }
- virtual IntSize GetSize() { return mA->GetSize(); }
+ virtual BackendType GetBackendType() const MOZ_OVERRIDE { return mA->GetBackendType(); }
+ virtual TemporaryRef<SourceSurface> Snapshot() MOZ_OVERRIDE { return new SourceSurfaceDual(mA, mB); }
+ virtual IntSize GetSize() MOZ_OVERRIDE { return mA->GetSize(); }
FORWARD_FUNCTION(Flush)
FORWARD_FUNCTION1(PushClip, const Path *, aPath)
FORWARD_FUNCTION1(PushClipRect, const Rect &, aRect)
FORWARD_FUNCTION(PopClip)
FORWARD_FUNCTION1(ClearRect, const Rect &, aRect)
- virtual void SetTransform(const Matrix &aTransform) {
+ virtual void SetTransform(const Matrix &aTransform) MOZ_OVERRIDE {
mTransform = aTransform;
mA->SetTransform(aTransform);
mB->SetTransform(aTransform);
}
virtual void DrawSurface(SourceSurface *aSurface, const Rect &aDest, const Rect & aSource,
- const DrawSurfaceOptions &aSurfOptions, const DrawOptions &aOptions);
+ const DrawSurfaceOptions &aSurfOptions, const DrawOptions &aOptions) MOZ_OVERRIDE;
virtual void DrawFilter(FilterNode *aNode,
const Rect &aSourceRect,
const Point &aDestPoint,
- const DrawOptions &aOptions = DrawOptions())
+ const DrawOptions &aOptions = DrawOptions()) MOZ_OVERRIDE
{
mA->DrawFilter(aNode, aSourceRect, aDestPoint, aOptions);
mB->DrawFilter(aNode, aSourceRect, aDestPoint, aOptions);
}
virtual void MaskSurface(const Pattern &aSource,
SourceSurface *aMask,
Point aOffset,
- const DrawOptions &aOptions = DrawOptions());
+ const DrawOptions &aOptions = DrawOptions()) MOZ_OVERRIDE;
virtual void DrawSurfaceWithShadow(SourceSurface *aSurface, const Point &aDest,
const Color &aColor, const Point &aOffset,
- Float aSigma, CompositionOp aOp);
+ Float aSigma, CompositionOp aOp) MOZ_OVERRIDE;
virtual void CopySurface(SourceSurface *aSurface, const IntRect &aSourceRect,
- const IntPoint &aDestination);
+ const IntPoint &aDestination) MOZ_OVERRIDE;
- virtual void FillRect(const Rect &aRect, const Pattern &aPattern, const DrawOptions &aOptions);
+ virtual void FillRect(const Rect &aRect, const Pattern &aPattern, const DrawOptions &aOptions) MOZ_OVERRIDE;
virtual void StrokeRect(const Rect &aRect, const Pattern &aPattern,
- const StrokeOptions &aStrokeOptions, const DrawOptions &aOptions);
+ const StrokeOptions &aStrokeOptions, const DrawOptions &aOptions) MOZ_OVERRIDE;
virtual void StrokeLine(const Point &aStart, const Point &aEnd, const Pattern &aPattern,
- const StrokeOptions &aStrokeOptions, const DrawOptions &aOptions);
+ const StrokeOptions &aStrokeOptions, const DrawOptions &aOptions) MOZ_OVERRIDE;
virtual void Stroke(const Path *aPath, const Pattern &aPattern,
- const StrokeOptions &aStrokeOptions, const DrawOptions &aOptions);
+ const StrokeOptions &aStrokeOptions, const DrawOptions &aOptions) MOZ_OVERRIDE;
- virtual void Fill(const Path *aPath, const Pattern &aPattern, const DrawOptions &aOptions);
+ virtual void Fill(const Path *aPath, const Pattern &aPattern, const DrawOptions &aOptions) MOZ_OVERRIDE;
virtual void FillGlyphs(ScaledFont *aScaledFont, const GlyphBuffer &aBuffer,
const Pattern &aPattern, const DrawOptions &aOptions,
- const GlyphRenderingOptions *aRenderingOptions);
+ const GlyphRenderingOptions *aRenderingOptions) MOZ_OVERRIDE;
- virtual void Mask(const Pattern &aSource, const Pattern &aMask, const DrawOptions &aOptions);
+ virtual void Mask(const Pattern &aSource, const Pattern &aMask, const DrawOptions &aOptions) MOZ_OVERRIDE;
virtual TemporaryRef<SourceSurface>
CreateSourceSurfaceFromData(unsigned char *aData,
const IntSize &aSize,
int32_t aStride,
- SurfaceFormat aFormat) const
+ SurfaceFormat aFormat) const MOZ_OVERRIDE
{
return mA->CreateSourceSurfaceFromData(aData, aSize, aStride, aFormat);
}
- virtual TemporaryRef<SourceSurface> OptimizeSourceSurface(SourceSurface *aSurface) const
+ virtual TemporaryRef<SourceSurface> OptimizeSourceSurface(SourceSurface *aSurface) const MOZ_OVERRIDE
{
return mA->OptimizeSourceSurface(aSurface);
}
virtual TemporaryRef<SourceSurface>
- CreateSourceSurfaceFromNativeSurface(const NativeSurface &aSurface) const
+ CreateSourceSurfaceFromNativeSurface(const NativeSurface &aSurface) const MOZ_OVERRIDE
{
return mA->CreateSourceSurfaceFromNativeSurface(aSurface);
}
virtual TemporaryRef<DrawTarget>
- CreateSimilarDrawTarget(const IntSize &aSize, SurfaceFormat aFormat) const;
+ CreateSimilarDrawTarget(const IntSize &aSize, SurfaceFormat aFormat) const MOZ_OVERRIDE;
- virtual TemporaryRef<PathBuilder> CreatePathBuilder(FillRule aFillRule = FillRule::FILL_WINDING) const
+ virtual TemporaryRef<PathBuilder> CreatePathBuilder(FillRule aFillRule = FillRule::FILL_WINDING) const MOZ_OVERRIDE
{
return mA->CreatePathBuilder(aFillRule);
}
virtual TemporaryRef<GradientStops>
CreateGradientStops(GradientStop *aStops,
uint32_t aNumStops,
- ExtendMode aExtendMode = ExtendMode::CLAMP) const
+ ExtendMode aExtendMode = ExtendMode::CLAMP) const MOZ_OVERRIDE
{
return mA->CreateGradientStops(aStops, aNumStops, aExtendMode);
}
- virtual TemporaryRef<FilterNode> CreateFilter(FilterType aType)
+ virtual TemporaryRef<FilterNode> CreateFilter(FilterType aType) MOZ_OVERRIDE
{
return mA->CreateFilter(aType);
}
- virtual void *GetNativeSurface(NativeSurfaceType aType)
+ virtual void *GetNativeSurface(NativeSurfaceType aType) MOZ_OVERRIDE
{
return nullptr;
}
- virtual bool IsDualDrawTarget() const
+ virtual bool IsDualDrawTarget() const MOZ_OVERRIDE
{
return true;
}
private:
RefPtr<DrawTarget> mA;
RefPtr<DrawTarget> mB;
};
--- a/gfx/2d/DrawTargetRecording.cpp
+++ b/gfx/2d/DrawTargetRecording.cpp
@@ -75,50 +75,50 @@ GetGradientStops(GradientStops *aStops)
}
return static_cast<GradientStopsRecording*>(aStops)->mFinalGradientStops;
}
class FilterNodeRecording : public FilterNode
{
public:
- MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(FilterNodeRecording)
+ MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(FilterNodeRecording, MOZ_OVERRIDE)
using FilterNode::SetAttribute;
FilterNodeRecording(FilterNode *aFinalFilterNode, DrawEventRecorderPrivate *aRecorder)
: mFinalFilterNode(aFinalFilterNode), mRecorder(aRecorder)
{
}
~FilterNodeRecording()
{
mRecorder->RecordEvent(RecordedFilterNodeDestruction(this));
}
- virtual void SetInput(uint32_t aIndex, SourceSurface *aSurface)
+ virtual void SetInput(uint32_t aIndex, SourceSurface *aSurface) MOZ_OVERRIDE
{
mRecorder->RecordEvent(RecordedFilterNodeSetInput(this, aIndex, aSurface));
mFinalFilterNode->SetInput(aIndex, GetSourceSurface(aSurface));
}
- virtual void SetInput(uint32_t aIndex, FilterNode *aFilter)
+ virtual void SetInput(uint32_t aIndex, FilterNode *aFilter) MOZ_OVERRIDE
{
FilterNode *finalNode = aFilter;
if (aFilter->GetBackendType() != FILTER_BACKEND_RECORDING) {
gfxWarning() << "Non recording filter node used with recording DrawTarget!";
} else {
finalNode = static_cast<FilterNodeRecording*>(aFilter)->mFinalFilterNode;
}
mRecorder->RecordEvent(RecordedFilterNodeSetInput(this, aIndex, aFilter));
mFinalFilterNode->SetInput(aIndex, finalNode);
}
#define FORWARD_SET_ATTRIBUTE(type, argtype) \
- virtual void SetAttribute(uint32_t aIndex, type aValue) { \
+ virtual void SetAttribute(uint32_t aIndex, type aValue) MOZ_OVERRIDE { \
mRecorder->RecordEvent(RecordedFilterNodeSetAttribute(this, aIndex, aValue, RecordedFilterNodeSetAttribute::ARGTYPE_##argtype)); \
mFinalFilterNode->SetAttribute(aIndex, aValue); \
}
FORWARD_SET_ATTRIBUTE(bool, BOOL);
FORWARD_SET_ATTRIBUTE(uint32_t, UINT32);
FORWARD_SET_ATTRIBUTE(Float, FLOAT);
FORWARD_SET_ATTRIBUTE(const Size&, SIZE);
@@ -128,17 +128,17 @@ public:
FORWARD_SET_ATTRIBUTE(const IntRect&, INTRECT);
FORWARD_SET_ATTRIBUTE(const Point&, POINT);
FORWARD_SET_ATTRIBUTE(const Matrix5x4&, MATRIX5X4);
FORWARD_SET_ATTRIBUTE(const Point3D&, POINT3D);
FORWARD_SET_ATTRIBUTE(const Color&, COLOR);
#undef FORWARD_SET_ATTRIBUTE
- virtual void SetAttribute(uint32_t aIndex, const Float* aFloat, uint32_t aSize) {
+ virtual void SetAttribute(uint32_t aIndex, const Float* aFloat, uint32_t aSize) MOZ_OVERRIDE {
mRecorder->RecordEvent(RecordedFilterNodeSetAttribute(this, aIndex, aFloat, aSize));
mFinalFilterNode->SetAttribute(aIndex, aFloat, aSize);
}
virtual FilterBackend GetBackendType() MOZ_OVERRIDE { return FILTER_BACKEND_RECORDING; }
RefPtr<FilterNode> mFinalFilterNode;
RefPtr<DrawEventRecorderPrivate> mRecorder;
--- a/gfx/2d/DrawTargetRecording.h
+++ b/gfx/2d/DrawTargetRecording.h
@@ -10,54 +10,54 @@
#include "DrawEventRecorder.h"
namespace mozilla {
namespace gfx {
class DrawTargetRecording : public DrawTarget
{
public:
- MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(DrawTargetRecording)
+ MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(DrawTargetRecording, MOZ_OVERRIDE)
DrawTargetRecording(DrawEventRecorder *aRecorder, DrawTarget *aDT, bool aHasData = false);
~DrawTargetRecording();
virtual DrawTargetType GetType() const MOZ_OVERRIDE { return mFinalDT->GetType(); }
- virtual BackendType GetBackendType() const { return mFinalDT->GetBackendType(); }
+ virtual BackendType GetBackendType() const MOZ_OVERRIDE { return mFinalDT->GetBackendType(); }
- virtual TemporaryRef<SourceSurface> Snapshot();
+ virtual TemporaryRef<SourceSurface> Snapshot() MOZ_OVERRIDE;
- virtual IntSize GetSize() { return mFinalDT->GetSize(); }
+ virtual IntSize GetSize() MOZ_OVERRIDE { return mFinalDT->GetSize(); }
/* Ensure that the DrawTarget backend has flushed all drawing operations to
* this draw target. This must be called before using the backing surface of
* this draw target outside of GFX 2D code.
*/
- virtual void Flush() { mFinalDT->Flush(); }
+ virtual void Flush() MOZ_OVERRIDE { mFinalDT->Flush(); }
/*
* Draw a surface to the draw target. Possibly doing partial drawing or
* applying scaling. No sampling happens outside the source.
*
* aSurface Source surface to draw
* aDest Destination rectangle that this drawing operation should draw to
* aSource Source rectangle in aSurface coordinates, this area of aSurface
* will be stretched to the size of aDest.
* aOptions General draw options that are applied to the operation
* aSurfOptions DrawSurface options that are applied
*/
virtual void DrawSurface(SourceSurface *aSurface,
const Rect &aDest,
const Rect &aSource,
const DrawSurfaceOptions &aSurfOptions = DrawSurfaceOptions(),
- const DrawOptions &aOptions = DrawOptions());
+ const DrawOptions &aOptions = DrawOptions()) MOZ_OVERRIDE;
virtual void DrawFilter(FilterNode *aNode,
const Rect &aSourceRect,
const Point &aDestPoint,
- const DrawOptions &aOptions = DrawOptions());
+ const DrawOptions &aOptions = DrawOptions()) MOZ_OVERRIDE;
/*
* Blend a surface to the draw target with a shadow. The shadow is drawn as a
* gaussian blur using a specified sigma. The shadow is clipped to the size
* of the input surface, so the input surface should contain a transparent
* border the size of the approximate coverage of the blur (3 * aSigma).
* NOTE: This function works in device space!
*
@@ -68,215 +68,215 @@ public:
* aSigma Sigma used for the guassian filter kernel
* aOperator Composition operator used
*/
virtual void DrawSurfaceWithShadow(SourceSurface *aSurface,
const Point &aDest,
const Color &aColor,
const Point &aOffset,
Float aSigma,
- CompositionOp aOperator);
+ CompositionOp aOperator) MOZ_OVERRIDE;
/*
* Clear a rectangle on the draw target to transparent black. This will
* respect the clipping region and transform.
*
* aRect Rectangle to clear
*/
- virtual void ClearRect(const Rect &aRect);
+ virtual void ClearRect(const Rect &aRect) MOZ_OVERRIDE;
/*
* This is essentially a 'memcpy' between two surfaces. It moves a pixel
* aligned area from the source surface unscaled directly onto the
* drawtarget. This ignores both transform and clip.
*
* aSurface Surface to copy from
* aSourceRect Source rectangle to be copied
* aDest Destination point to copy the surface to
*/
virtual void CopySurface(SourceSurface *aSurface,
const IntRect &aSourceRect,
- const IntPoint &aDestination);
+ const IntPoint &aDestination) MOZ_OVERRIDE;
/*
* Fill a rectangle on the DrawTarget with a certain source pattern.
*
* aRect Rectangle that forms the mask of this filling operation
* aPattern Pattern that forms the source of this filling operation
* aOptions Options that are applied to this operation
*/
virtual void FillRect(const Rect &aRect,
const Pattern &aPattern,
- const DrawOptions &aOptions = DrawOptions());
+ const DrawOptions &aOptions = DrawOptions()) MOZ_OVERRIDE;
/*
* Stroke a rectangle on the DrawTarget with a certain source pattern.
*
* aRect Rectangle that forms the mask of this stroking operation
* aPattern Pattern that forms the source of this stroking operation
* aOptions Options that are applied to this operation
*/
virtual void StrokeRect(const Rect &aRect,
const Pattern &aPattern,
const StrokeOptions &aStrokeOptions = StrokeOptions(),
- const DrawOptions &aOptions = DrawOptions());
+ const DrawOptions &aOptions = DrawOptions()) MOZ_OVERRIDE;
/*
* Stroke a line on the DrawTarget with a certain source pattern.
*
* aStart Starting point of the line
* aEnd End point of the line
* aPattern Pattern that forms the source of this stroking operation
* aOptions Options that are applied to this operation
*/
virtual void StrokeLine(const Point &aStart,
const Point &aEnd,
const Pattern &aPattern,
const StrokeOptions &aStrokeOptions = StrokeOptions(),
- const DrawOptions &aOptions = DrawOptions());
+ const DrawOptions &aOptions = DrawOptions()) MOZ_OVERRIDE;
/*
* Stroke a path on the draw target with a certain source pattern.
*
* aPath Path that is to be stroked
* aPattern Pattern that should be used for the stroke
* aStrokeOptions Stroke options used for this operation
* aOptions Draw options used for this operation
*/
virtual void Stroke(const Path *aPath,
const Pattern &aPattern,
const StrokeOptions &aStrokeOptions = StrokeOptions(),
- const DrawOptions &aOptions = DrawOptions());
+ const DrawOptions &aOptions = DrawOptions()) MOZ_OVERRIDE;
/*
* Fill a path on the draw target with a certain source pattern.
*
* aPath Path that is to be filled
* aPattern Pattern that should be used for the fill
* aOptions Draw options used for this operation
*/
virtual void Fill(const Path *aPath,
const Pattern &aPattern,
- const DrawOptions &aOptions = DrawOptions());
+ const DrawOptions &aOptions = DrawOptions()) MOZ_OVERRIDE;
/*
* Fill a series of clyphs on the draw target with a certain source pattern.
*/
virtual void FillGlyphs(ScaledFont *aFont,
const GlyphBuffer &aBuffer,
const Pattern &aPattern,
const DrawOptions &aOptions = DrawOptions(),
- const GlyphRenderingOptions *aRenderingOptions = nullptr);
+ const GlyphRenderingOptions *aRenderingOptions = nullptr) MOZ_OVERRIDE;
/*
* This takes a source pattern and a mask, and composites the source pattern
* onto the destination surface using the alpha channel of the mask pattern
* as a mask for the operation.
*
* aSource Source pattern
* aMask Mask pattern
* aOptions Drawing options
*/
virtual void Mask(const Pattern &aSource,
const Pattern &aMask,
- const DrawOptions &aOptions = DrawOptions());
+ const DrawOptions &aOptions = DrawOptions()) MOZ_OVERRIDE;
virtual void MaskSurface(const Pattern &aSource,
SourceSurface *aMask,
Point aOffset,
- const DrawOptions &aOptions = DrawOptions());
+ const DrawOptions &aOptions = DrawOptions()) MOZ_OVERRIDE;
/*
* Push a clip to the DrawTarget.
*
* aPath The path to clip to
*/
- virtual void PushClip(const Path *aPath);
+ virtual void PushClip(const Path *aPath) MOZ_OVERRIDE;
/*
* Push an axis-aligned rectangular clip to the DrawTarget. This rectangle
* is specified in user space.
*
* aRect The rect to clip to
*/
- virtual void PushClipRect(const Rect &aRect);
+ virtual void PushClipRect(const Rect &aRect) MOZ_OVERRIDE;
/* Pop a clip from the DrawTarget. A pop without a corresponding push will
* be ignored.
*/
- virtual void PopClip();
+ virtual void PopClip() MOZ_OVERRIDE;
/*
* Create a SourceSurface optimized for use with this DrawTarget from
* existing bitmap data in memory.
*
* The SourceSurface does not take ownership of aData, and may be freed at any time.
*/
virtual TemporaryRef<SourceSurface> CreateSourceSurfaceFromData(unsigned char *aData,
const IntSize &aSize,
int32_t aStride,
- SurfaceFormat aFormat) const;
+ SurfaceFormat aFormat) const MOZ_OVERRIDE;
/*
* Create a SourceSurface optimized for use with this DrawTarget from
* an arbitrary other SourceSurface. This may return aSourceSurface or some
* other existing surface.
*/
- virtual TemporaryRef<SourceSurface> OptimizeSourceSurface(SourceSurface *aSurface) const;
+ virtual TemporaryRef<SourceSurface> OptimizeSourceSurface(SourceSurface *aSurface) const MOZ_OVERRIDE;
/*
* Create a SourceSurface for a type of NativeSurface. This may fail if the
* draw target does not know how to deal with the type of NativeSurface passed
* in.
*/
virtual TemporaryRef<SourceSurface>
- CreateSourceSurfaceFromNativeSurface(const NativeSurface &aSurface) const;
+ CreateSourceSurfaceFromNativeSurface(const NativeSurface &aSurface) const MOZ_OVERRIDE;
/*
* Create a DrawTarget whose snapshot is optimized for use with this DrawTarget.
*/
virtual TemporaryRef<DrawTarget>
- CreateSimilarDrawTarget(const IntSize &aSize, SurfaceFormat aFormat) const;
+ CreateSimilarDrawTarget(const IntSize &aSize, SurfaceFormat aFormat) const MOZ_OVERRIDE;
/*
* Create a path builder with the specified fillmode.
*
* We need the fill mode up front because of Direct2D.
* ID2D1SimplifiedGeometrySink requires the fill mode
* to be set before calling BeginFigure().
*/
- virtual TemporaryRef<PathBuilder> CreatePathBuilder(FillRule aFillRule = FillRule::FILL_WINDING) const;
+ virtual TemporaryRef<PathBuilder> CreatePathBuilder(FillRule aFillRule = FillRule::FILL_WINDING) const MOZ_OVERRIDE;
/*
* Create a GradientStops object that holds information about a set of
* gradient stops, this object is required for linear or radial gradient
* patterns to represent the color stops in the gradient.
*
* aStops An array of gradient stops
* aNumStops Number of stops in the array aStops
* aExtendNone This describes how to extend the stop color outside of the
* gradient area.
*/
virtual TemporaryRef<GradientStops>
CreateGradientStops(GradientStop *aStops,
uint32_t aNumStops,
- ExtendMode aExtendMode = ExtendMode::CLAMP) const;
+ ExtendMode aExtendMode = ExtendMode::CLAMP) const MOZ_OVERRIDE;
- virtual TemporaryRef<FilterNode> CreateFilter(FilterType aType);
+ virtual TemporaryRef<FilterNode> CreateFilter(FilterType aType) MOZ_OVERRIDE;
/*
* Set a transform on the surface, this transform is applied at drawing time
* to both the mask and source of the operation.
*/
- virtual void SetTransform(const Matrix &aTransform);
+ virtual void SetTransform(const Matrix &aTransform) MOZ_OVERRIDE;
/* Tries to get a native surface for a DrawTarget, this may fail if the
* draw target cannot convert to this surface type.
*/
- virtual void *GetNativeSurface(NativeSurfaceType aType) { return mFinalDT->GetNativeSurface(aType); }
+ virtual void *GetNativeSurface(NativeSurfaceType aType) MOZ_OVERRIDE { return mFinalDT->GetNativeSurface(aType); }
private:
Path *GetPathForPathRecording(const Path *aPath) const;
void EnsureStored(const Path *aPath);
RefPtr<DrawEventRecorderPrivate> mRecorder;
RefPtr<DrawTarget> mFinalDT;
};
--- a/gfx/2d/DrawTargetSkia.h
+++ b/gfx/2d/DrawTargetSkia.h
@@ -23,92 +23,92 @@
namespace mozilla {
namespace gfx {
class SourceSurfaceSkia;
class DrawTargetSkia : public DrawTarget
{
public:
- MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(DrawTargetSkia)
+ MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(DrawTargetSkia, MOZ_OVERRIDE)
DrawTargetSkia();
virtual ~DrawTargetSkia();
virtual DrawTargetType GetType() const MOZ_OVERRIDE;
- virtual BackendType GetBackendType() const { return BackendType::SKIA; }
- virtual TemporaryRef<SourceSurface> Snapshot();
- virtual IntSize GetSize() { return mSize; }
- virtual void Flush();
+ virtual BackendType GetBackendType() const MOZ_OVERRIDE { return BackendType::SKIA; }
+ virtual TemporaryRef<SourceSurface> Snapshot() MOZ_OVERRIDE;
+ virtual IntSize GetSize() MOZ_OVERRIDE { return mSize; }
+ virtual void Flush() MOZ_OVERRIDE;
virtual void DrawSurface(SourceSurface *aSurface,
const Rect &aDest,
const Rect &aSource,
const DrawSurfaceOptions &aSurfOptions = DrawSurfaceOptions(),
- const DrawOptions &aOptions = DrawOptions());
+ const DrawOptions &aOptions = DrawOptions()) MOZ_OVERRIDE;
virtual void DrawFilter(FilterNode *aNode,
const Rect &aSourceRect,
const Point &aDestPoint,
- const DrawOptions &aOptions = DrawOptions());
+ const DrawOptions &aOptions = DrawOptions()) MOZ_OVERRIDE;
virtual void DrawSurfaceWithShadow(SourceSurface *aSurface,
const Point &aDest,
const Color &aColor,
const Point &aOffset,
Float aSigma,
- CompositionOp aOperator);
- virtual void ClearRect(const Rect &aRect);
+ CompositionOp aOperator) MOZ_OVERRIDE;
+ virtual void ClearRect(const Rect &aRect) MOZ_OVERRIDE;
virtual void CopySurface(SourceSurface *aSurface,
const IntRect &aSourceRect,
- const IntPoint &aDestination);
+ const IntPoint &aDestination) MOZ_OVERRIDE;
virtual void FillRect(const Rect &aRect,
const Pattern &aPattern,
- const DrawOptions &aOptions = DrawOptions());
+ const DrawOptions &aOptions = DrawOptions()) MOZ_OVERRIDE;
virtual void StrokeRect(const Rect &aRect,
const Pattern &aPattern,
const StrokeOptions &aStrokeOptions = StrokeOptions(),
- const DrawOptions &aOptions = DrawOptions());
+ const DrawOptions &aOptions = DrawOptions()) MOZ_OVERRIDE;
virtual void StrokeLine(const Point &aStart,
const Point &aEnd,
const Pattern &aPattern,
const StrokeOptions &aStrokeOptions = StrokeOptions(),
- const DrawOptions &aOptions = DrawOptions());
+ const DrawOptions &aOptions = DrawOptions()) MOZ_OVERRIDE;
virtual void Stroke(const Path *aPath,
const Pattern &aPattern,
const StrokeOptions &aStrokeOptions = StrokeOptions(),
- const DrawOptions &aOptions = DrawOptions());
+ const DrawOptions &aOptions = DrawOptions()) MOZ_OVERRIDE;
virtual void Fill(const Path *aPath,
const Pattern &aPattern,
- const DrawOptions &aOptions = DrawOptions());
+ const DrawOptions &aOptions = DrawOptions()) MOZ_OVERRIDE;
virtual void FillGlyphs(ScaledFont *aFont,
const GlyphBuffer &aBuffer,
const Pattern &aPattern,
const DrawOptions &aOptions = DrawOptions(),
- const GlyphRenderingOptions *aRenderingOptions = nullptr);
+ const GlyphRenderingOptions *aRenderingOptions = nullptr) MOZ_OVERRIDE;
virtual void Mask(const Pattern &aSource,
const Pattern &aMask,
- const DrawOptions &aOptions = DrawOptions());
+ const DrawOptions &aOptions = DrawOptions()) MOZ_OVERRIDE;
virtual void MaskSurface(const Pattern &aSource,
SourceSurface *aMask,
Point aOffset,
- const DrawOptions &aOptions = DrawOptions());
- virtual void PushClip(const Path *aPath);
- virtual void PushClipRect(const Rect& aRect);
- virtual void PopClip();
+ const DrawOptions &aOptions = DrawOptions()) MOZ_OVERRIDE;
+ virtual void PushClip(const Path *aPath) MOZ_OVERRIDE;
+ virtual void PushClipRect(const Rect& aRect) MOZ_OVERRIDE;
+ virtual void PopClip() MOZ_OVERRIDE;
virtual TemporaryRef<SourceSurface> CreateSourceSurfaceFromData(unsigned char *aData,
const IntSize &aSize,
int32_t aStride,
- SurfaceFormat aFormat) const;
- virtual TemporaryRef<SourceSurface> OptimizeSourceSurface(SourceSurface *aSurface) const;
+ SurfaceFormat aFormat) const MOZ_OVERRIDE;
+ virtual TemporaryRef<SourceSurface> OptimizeSourceSurface(SourceSurface *aSurface) const MOZ_OVERRIDE;
virtual TemporaryRef<SourceSurface>
- CreateSourceSurfaceFromNativeSurface(const NativeSurface &aSurface) const;
+ CreateSourceSurfaceFromNativeSurface(const NativeSurface &aSurface) const MOZ_OVERRIDE;
virtual TemporaryRef<DrawTarget>
- CreateSimilarDrawTarget(const IntSize &aSize, SurfaceFormat aFormat) const;
- virtual TemporaryRef<PathBuilder> CreatePathBuilder(FillRule aFillRule = FillRule::FILL_WINDING) const;
- virtual TemporaryRef<GradientStops> CreateGradientStops(GradientStop *aStops, uint32_t aNumStops, ExtendMode aExtendMode = ExtendMode::CLAMP) const;
- virtual TemporaryRef<FilterNode> CreateFilter(FilterType aType);
- virtual void SetTransform(const Matrix &aTransform);
- virtual void *GetNativeSurface(NativeSurfaceType aType);
+ CreateSimilarDrawTarget(const IntSize &aSize, SurfaceFormat aFormat) const MOZ_OVERRIDE;
+ virtual TemporaryRef<PathBuilder> CreatePathBuilder(FillRule aFillRule = FillRule::FILL_WINDING) const MOZ_OVERRIDE;
+ virtual TemporaryRef<GradientStops> CreateGradientStops(GradientStop *aStops, uint32_t aNumStops, ExtendMode aExtendMode = ExtendMode::CLAMP) const MOZ_OVERRIDE;
+ virtual TemporaryRef<FilterNode> CreateFilter(FilterType aType) MOZ_OVERRIDE;
+ virtual void SetTransform(const Matrix &aTransform) MOZ_OVERRIDE;
+ virtual void *GetNativeSurface(NativeSurfaceType aType) MOZ_OVERRIDE;
bool Init(const IntSize &aSize, SurfaceFormat aFormat);
void Init(unsigned char* aData, const IntSize &aSize, int32_t aStride, SurfaceFormat aFormat);
#ifdef USE_SKIA_GPU
bool InitWithGrContext(GrContext* aGrContext,
const IntSize &aSize,
SurfaceFormat aFormat) MOZ_OVERRIDE;
--- a/gfx/2d/DrawTargetTiled.h
+++ b/gfx/2d/DrawTargetTiled.h
@@ -30,123 +30,123 @@ struct TileInternal : public Tile {
class DrawTargetTiled : public DrawTarget
{
public:
DrawTargetTiled();
bool Init(const TileSet& mTiles);
- virtual bool IsTiledDrawTarget() const { return true; }
+ virtual bool IsTiledDrawTarget() const MOZ_OVERRIDE { return true; }
virtual DrawTargetType GetType() const MOZ_OVERRIDE { return mTiles[0].mDrawTarget->GetType(); }
- virtual BackendType GetBackendType() const { return mTiles[0].mDrawTarget->GetBackendType(); }
- virtual TemporaryRef<SourceSurface> Snapshot();
- virtual IntSize GetSize() {
+ virtual BackendType GetBackendType() const MOZ_OVERRIDE { return mTiles[0].mDrawTarget->GetBackendType(); }
+ virtual TemporaryRef<SourceSurface> Snapshot() MOZ_OVERRIDE;
+ virtual IntSize GetSize() MOZ_OVERRIDE {
MOZ_ASSERT(mRect.width > 0 && mRect.height > 0);
return IntSize(mRect.XMost(), mRect.YMost());
}
- virtual void Flush();
+ virtual void Flush() MOZ_OVERRIDE;
virtual void DrawSurface(SourceSurface *aSurface,
const Rect &aDest,
const Rect &aSource,
const DrawSurfaceOptions &aSurfOptions,
- const DrawOptions &aOptions);
+ const DrawOptions &aOptions) MOZ_OVERRIDE;
virtual void DrawFilter(FilterNode *aNode,
const Rect &aSourceRect,
const Point &aDestPoint,
- const DrawOptions &aOptions = DrawOptions());
+ const DrawOptions &aOptions = DrawOptions()) MOZ_OVERRIDE;
virtual void DrawSurfaceWithShadow(SourceSurface *aSurface,
const Point &aDest,
const Color &aColor,
const Point &aOffset,
Float aSigma,
- CompositionOp aOperator) { /* Not implemented */ MOZ_CRASH(); }
+ CompositionOp aOperator) MOZ_OVERRIDE { /* Not implemented */ MOZ_CRASH(); }
- virtual void ClearRect(const Rect &aRect);
+ virtual void ClearRect(const Rect &aRect) MOZ_OVERRIDE;
virtual void MaskSurface(const Pattern &aSource,
SourceSurface *aMask,
Point aOffset,
- const DrawOptions &aOptions = DrawOptions());
+ const DrawOptions &aOptions = DrawOptions()) MOZ_OVERRIDE;
virtual void CopySurface(SourceSurface *aSurface,
const IntRect &aSourceRect,
- const IntPoint &aDestination);
+ const IntPoint &aDestination) MOZ_OVERRIDE;
virtual void FillRect(const Rect &aRect,
const Pattern &aPattern,
- const DrawOptions &aOptions = DrawOptions());
+ const DrawOptions &aOptions = DrawOptions()) MOZ_OVERRIDE;
virtual void StrokeRect(const Rect &aRect,
const Pattern &aPattern,
const StrokeOptions &aStrokeOptions = StrokeOptions(),
- const DrawOptions &aOptions = DrawOptions());
+ const DrawOptions &aOptions = DrawOptions()) MOZ_OVERRIDE;
virtual void StrokeLine(const Point &aStart,
const Point &aEnd,
const Pattern &aPattern,
const StrokeOptions &aStrokeOptions = StrokeOptions(),
- const DrawOptions &aOptions = DrawOptions());
+ const DrawOptions &aOptions = DrawOptions()) MOZ_OVERRIDE;
virtual void Stroke(const Path *aPath,
const Pattern &aPattern,
const StrokeOptions &aStrokeOptions = StrokeOptions(),
- const DrawOptions &aOptions = DrawOptions());
+ const DrawOptions &aOptions = DrawOptions()) MOZ_OVERRIDE;
virtual void Fill(const Path *aPath,
const Pattern &aPattern,
- const DrawOptions &aOptions = DrawOptions());
+ const DrawOptions &aOptions = DrawOptions()) MOZ_OVERRIDE;
virtual void FillGlyphs(ScaledFont *aFont,
const GlyphBuffer &aBuffer,
const Pattern &aPattern,
const DrawOptions &aOptions = DrawOptions(),
- const GlyphRenderingOptions *aRenderingOptions = nullptr);
+ const GlyphRenderingOptions *aRenderingOptions = nullptr) MOZ_OVERRIDE;
virtual void Mask(const Pattern &aSource,
const Pattern &aMask,
- const DrawOptions &aOptions = DrawOptions());
- virtual void PushClip(const Path *aPath);
- virtual void PushClipRect(const Rect &aRect);
- virtual void PopClip();
+ const DrawOptions &aOptions = DrawOptions()) MOZ_OVERRIDE;
+ virtual void PushClip(const Path *aPath) MOZ_OVERRIDE;
+ virtual void PushClipRect(const Rect &aRect) MOZ_OVERRIDE;
+ virtual void PopClip() MOZ_OVERRIDE;
- virtual void SetTransform(const Matrix &aTransform);
+ virtual void SetTransform(const Matrix &aTransform) MOZ_OVERRIDE;
virtual TemporaryRef<SourceSurface> CreateSourceSurfaceFromData(unsigned char *aData,
const IntSize &aSize,
int32_t aStride,
- SurfaceFormat aFormat) const
+ SurfaceFormat aFormat) const MOZ_OVERRIDE
{
return mTiles[0].mDrawTarget->CreateSourceSurfaceFromData(aData, aSize, aStride, aFormat);
}
- virtual TemporaryRef<SourceSurface> OptimizeSourceSurface(SourceSurface *aSurface) const
+ virtual TemporaryRef<SourceSurface> OptimizeSourceSurface(SourceSurface *aSurface) const MOZ_OVERRIDE
{
return mTiles[0].mDrawTarget->OptimizeSourceSurface(aSurface);
}
virtual TemporaryRef<SourceSurface>
- CreateSourceSurfaceFromNativeSurface(const NativeSurface &aSurface) const
+ CreateSourceSurfaceFromNativeSurface(const NativeSurface &aSurface) const MOZ_OVERRIDE
{
return mTiles[0].mDrawTarget->CreateSourceSurfaceFromNativeSurface(aSurface);
}
virtual TemporaryRef<DrawTarget>
- CreateSimilarDrawTarget(const IntSize &aSize, SurfaceFormat aFormat) const
+ CreateSimilarDrawTarget(const IntSize &aSize, SurfaceFormat aFormat) const MOZ_OVERRIDE
{
return mTiles[0].mDrawTarget->CreateSimilarDrawTarget(aSize, aFormat);
}
- virtual TemporaryRef<PathBuilder> CreatePathBuilder(FillRule aFillRule = FillRule::FILL_WINDING) const
+ virtual TemporaryRef<PathBuilder> CreatePathBuilder(FillRule aFillRule = FillRule::FILL_WINDING) const MOZ_OVERRIDE
{
return mTiles[0].mDrawTarget->CreatePathBuilder(aFillRule);
}
virtual TemporaryRef<GradientStops>
CreateGradientStops(GradientStop *aStops,
uint32_t aNumStops,
- ExtendMode aExtendMode = ExtendMode::CLAMP) const
+ ExtendMode aExtendMode = ExtendMode::CLAMP) const MOZ_OVERRIDE
{
return mTiles[0].mDrawTarget->CreateGradientStops(aStops, aNumStops, aExtendMode);
}
- virtual TemporaryRef<FilterNode> CreateFilter(FilterType aType)
+ virtual TemporaryRef<FilterNode> CreateFilter(FilterType aType) MOZ_OVERRIDE
{
return mTiles[0].mDrawTarget->CreateFilter(aType);
}
private:
std::vector<TileInternal> mTiles;
std::vector<std::vector<uint32_t> > mClippedOutTilesStack;
IntRect mRect;
--- a/gfx/2d/FilterNodeSoftware.h
+++ b/gfx/2d/FilterNodeSoftware.h
@@ -33,17 +33,17 @@ public:
* This is the base class for the software (i.e. pure CPU, non-accelerated)
* FilterNode implementation. The software implementation is backend-agnostic,
* so it can be used as a fallback for all DrawTarget implementations.
*/
class FilterNodeSoftware : public FilterNode,
public FilterInvalidationListener
{
public:
- MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(FilterNodeSoftware)
+ MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(FilterNodeSoftware, MOZ_OVERRIDE)
virtual ~FilterNodeSoftware();
// Factory method, intended to be called from DrawTarget*::CreateFilter.
static TemporaryRef<FilterNode> Create(FilterType aType);
// Draw the filter, intended to be called by DrawTarget*::DrawFilter.
void Draw(DrawTarget* aDrawTarget, const Rect &aSourceRect,
const Point &aDestPoint, const DrawOptions &aOptions);
@@ -53,17 +53,17 @@ public:
virtual void SetInput(uint32_t aIndex, FilterNode *aFilter) MOZ_OVERRIDE;
virtual const char* GetName() { return "Unknown"; }
virtual void AddInvalidationListener(FilterInvalidationListener* aListener);
virtual void RemoveInvalidationListener(FilterInvalidationListener* aListener);
// FilterInvalidationListener implementation
- virtual void FilterInvalidated(FilterNodeSoftware* aFilter);
+ virtual void FilterInvalidated(FilterNodeSoftware* aFilter) MOZ_OVERRIDE;
protected:
// The following methods are intended to be overriden by subclasses.
/**
* Translates a *FilterInputs enum value into an index for the
* mInputFilters / mInputSurfaces arrays. Returns -1 for invalid inputs.
@@ -213,17 +213,17 @@ protected:
RefPtr<DataSourceSurface> mCachedOutput;
};
// Subclasses for specific filters.
class FilterNodeTransformSoftware : public FilterNodeSoftware
{
public:
- MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(FilterNodeTransformSoftware)
+ MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(FilterNodeTransformSoftware, MOZ_OVERRIDE)
FilterNodeTransformSoftware();
virtual const char* GetName() MOZ_OVERRIDE { return "Transform"; }
using FilterNodeSoftware::SetAttribute;
virtual void SetAttribute(uint32_t aIndex, uint32_t aGraphicsFilter) MOZ_OVERRIDE;
virtual void SetAttribute(uint32_t aIndex, const Matrix &aMatrix) MOZ_OVERRIDE;
protected:
virtual TemporaryRef<DataSourceSurface> Render(const IntRect& aRect) MOZ_OVERRIDE;
@@ -235,17 +235,17 @@ protected:
private:
Matrix mMatrix;
Filter mFilter;
};
class FilterNodeBlendSoftware : public FilterNodeSoftware
{
public:
- MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(FilterNodeBlendSoftware)
+ MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(FilterNodeBlendSoftware, MOZ_OVERRIDE)
FilterNodeBlendSoftware();
virtual const char* GetName() MOZ_OVERRIDE { return "Blend"; }
using FilterNodeSoftware::SetAttribute;
virtual void SetAttribute(uint32_t aIndex, uint32_t aBlendMode) MOZ_OVERRIDE;
protected:
virtual TemporaryRef<DataSourceSurface> Render(const IntRect& aRect) MOZ_OVERRIDE;
virtual IntRect GetOutputRectInRect(const IntRect& aRect) MOZ_OVERRIDE;
@@ -254,17 +254,17 @@ protected:
private:
BlendMode mBlendMode;
};
class FilterNodeMorphologySoftware : public FilterNodeSoftware
{
public:
- MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(FilterNodeMorphologySoftware)
+ MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(FilterNodeMorphologySoftware, MOZ_OVERRIDE)
FilterNodeMorphologySoftware();
virtual const char* GetName() MOZ_OVERRIDE { return "Morphology"; }
using FilterNodeSoftware::SetAttribute;
virtual void SetAttribute(uint32_t aIndex, const IntSize &aRadii) MOZ_OVERRIDE;
virtual void SetAttribute(uint32_t aIndex, uint32_t aOperator) MOZ_OVERRIDE;
protected:
virtual TemporaryRef<DataSourceSurface> Render(const IntRect& aRect) MOZ_OVERRIDE;
@@ -275,17 +275,17 @@ protected:
private:
IntSize mRadii;
MorphologyOperator mOperator;
};
class FilterNodeColorMatrixSoftware : public FilterNodeSoftware
{
public:
- MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(FilterNodeColorMatrixSoftware)
+ MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(FilterNodeColorMatrixSoftware, MOZ_OVERRIDE)
virtual const char* GetName() MOZ_OVERRIDE { return "ColorMatrix"; }
using FilterNodeSoftware::SetAttribute;
virtual void SetAttribute(uint32_t aIndex, const Matrix5x4 &aMatrix) MOZ_OVERRIDE;
virtual void SetAttribute(uint32_t aIndex, uint32_t aAlphaMode) MOZ_OVERRIDE;
protected:
virtual TemporaryRef<DataSourceSurface> Render(const IntRect& aRect) MOZ_OVERRIDE;
virtual IntRect GetOutputRectInRect(const IntRect& aRect) MOZ_OVERRIDE;
@@ -295,34 +295,34 @@ protected:
private:
Matrix5x4 mMatrix;
AlphaMode mAlphaMode;
};
class FilterNodeFloodSoftware : public FilterNodeSoftware
{
public:
- MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(FilterNodeFloodSoftware)
+ MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(FilterNodeFloodSoftware, MOZ_OVERRIDE)
virtual const char* GetName() MOZ_OVERRIDE { return "Flood"; }
using FilterNodeSoftware::SetAttribute;
virtual void SetAttribute(uint32_t aIndex, const Color &aColor) MOZ_OVERRIDE;
protected:
virtual TemporaryRef<DataSourceSurface> GetOutput(const IntRect &aRect) MOZ_OVERRIDE;
virtual TemporaryRef<DataSourceSurface> Render(const IntRect& aRect) MOZ_OVERRIDE;
virtual IntRect GetOutputRectInRect(const IntRect& aRect) MOZ_OVERRIDE;
private:
Color mColor;
};
class FilterNodeTileSoftware : public FilterNodeSoftware
{
public:
- MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(FilterNodeTileSoftware)
+ MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(FilterNodeTileSoftware, MOZ_OVERRIDE)
virtual const char* GetName() MOZ_OVERRIDE { return "Tile"; }
using FilterNodeSoftware::SetAttribute;
virtual void SetAttribute(uint32_t aIndex, const IntRect &aSourceRect) MOZ_OVERRIDE;
protected:
virtual TemporaryRef<DataSourceSurface> Render(const IntRect& aRect) MOZ_OVERRIDE;
virtual IntRect GetOutputRectInRect(const IntRect& aRect) MOZ_OVERRIDE;
virtual int32_t InputIndex(uint32_t aInputEnumIndex) MOZ_OVERRIDE;
@@ -333,17 +333,17 @@ private:
};
/**
* Baseclass for the four different component transfer filters.
*/
class FilterNodeComponentTransferSoftware : public FilterNodeSoftware
{
public:
- MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(FilterNodeComponentTransferSoftware)
+ MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(FilterNodeComponentTransferSoftware, MOZ_OVERRIDE)
FilterNodeComponentTransferSoftware();
using FilterNodeSoftware::SetAttribute;
virtual void SetAttribute(uint32_t aIndex, bool aDisable) MOZ_OVERRIDE;
protected:
virtual TemporaryRef<DataSourceSurface> Render(const IntRect& aRect) MOZ_OVERRIDE;
virtual IntRect GetOutputRectInRect(const IntRect& aRect) MOZ_OVERRIDE;
@@ -357,17 +357,17 @@ protected:
bool mDisableG;
bool mDisableB;
bool mDisableA;
};
class FilterNodeTableTransferSoftware : public FilterNodeComponentTransferSoftware
{
public:
- MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(FilterNodeTableTransferSoftware)
+ MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(FilterNodeTableTransferSoftware, MOZ_OVERRIDE)
virtual const char* GetName() MOZ_OVERRIDE { return "TableTransfer"; }
using FilterNodeComponentTransferSoftware::SetAttribute;
virtual void SetAttribute(uint32_t aIndex, const Float* aFloat, uint32_t aSize) MOZ_OVERRIDE;
protected:
virtual void FillLookupTable(ptrdiff_t aComponent, uint8_t aTable[256]) MOZ_OVERRIDE;
private:
@@ -377,17 +377,17 @@ private:
std::vector<Float> mTableG;
std::vector<Float> mTableB;
std::vector<Float> mTableA;
};
class FilterNodeDiscreteTransferSoftware : public FilterNodeComponentTransferSoftware
{
public:
- MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(FilterNodeDiscreteTransferSoftware)
+ MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(FilterNodeDiscreteTransferSoftware, MOZ_OVERRIDE)
virtual const char* GetName() MOZ_OVERRIDE { return "DiscreteTransfer"; }
using FilterNodeComponentTransferSoftware::SetAttribute;
virtual void SetAttribute(uint32_t aIndex, const Float* aFloat, uint32_t aSize) MOZ_OVERRIDE;
protected:
virtual void FillLookupTable(ptrdiff_t aComponent, uint8_t aTable[256]) MOZ_OVERRIDE;
private:
@@ -397,17 +397,17 @@ private:
std::vector<Float> mTableG;
std::vector<Float> mTableB;
std::vector<Float> mTableA;
};
class FilterNodeLinearTransferSoftware : public FilterNodeComponentTransferSoftware
{
public:
- MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(FilterNodeLinearTransformSoftware)
+ MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(FilterNodeLinearTransformSoftware, MOZ_OVERRIDE)
FilterNodeLinearTransferSoftware();
virtual const char* GetName() MOZ_OVERRIDE { return "LinearTransfer"; }
using FilterNodeComponentTransferSoftware::SetAttribute;
virtual void SetAttribute(uint32_t aIndex, Float aValue) MOZ_OVERRIDE;
protected:
virtual void FillLookupTable(ptrdiff_t aComponent, uint8_t aTable[256]) MOZ_OVERRIDE;
@@ -422,17 +422,17 @@ private:
Float mInterceptG;
Float mInterceptB;
Float mInterceptA;
};
class FilterNodeGammaTransferSoftware : public FilterNodeComponentTransferSoftware
{
public:
- MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(FilterNodeGammaTransferSoftware)
+ MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(FilterNodeGammaTransferSoftware, MOZ_OVERRIDE)
FilterNodeGammaTransferSoftware();
virtual const char* GetName() MOZ_OVERRIDE { return "GammaTransfer"; }
using FilterNodeComponentTransferSoftware::SetAttribute;
virtual void SetAttribute(uint32_t aIndex, Float aValue) MOZ_OVERRIDE;
protected:
virtual void FillLookupTable(ptrdiff_t aComponent, uint8_t aTable[256]) MOZ_OVERRIDE;
@@ -451,17 +451,17 @@ private:
Float mOffsetG;
Float mOffsetB;
Float mOffsetA;
};
class FilterNodeConvolveMatrixSoftware : public FilterNodeSoftware
{
public:
- MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(FilterNodeConvolveMatrixSoftware)
+ MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(FilterNodeConvolveMatrixSoftware, MOZ_OVERRIDE)
FilterNodeConvolveMatrixSoftware();
virtual const char* GetName() MOZ_OVERRIDE { return "ConvolveMatrix"; }
using FilterNodeSoftware::SetAttribute;
virtual void SetAttribute(uint32_t aIndex, const IntSize &aKernelSize) MOZ_OVERRIDE;
virtual void SetAttribute(uint32_t aIndex, const Float* aMatrix, uint32_t aSize) MOZ_OVERRIDE;
virtual void SetAttribute(uint32_t aIndex, Float aValue) MOZ_OVERRIDE;
virtual void SetAttribute(uint32_t aIndex, const Size &aKernelUnitLength) MOZ_OVERRIDE;
virtual void SetAttribute(uint32_t aIndex, const IntRect &aSourceRect) MOZ_OVERRIDE;
@@ -493,17 +493,17 @@ private:
ConvolveMatrixEdgeMode mEdgeMode;
Size mKernelUnitLength;
bool mPreserveAlpha;
};
class FilterNodeDisplacementMapSoftware : public FilterNodeSoftware
{
public:
- MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(FilterNodeDisplacementMapSoftware)
+ MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(FilterNodeDisplacementMapSoftware, MOZ_OVERRIDE)
FilterNodeDisplacementMapSoftware();
virtual const char* GetName() MOZ_OVERRIDE { return "DisplacementMap"; }
using FilterNodeSoftware::SetAttribute;
virtual void SetAttribute(uint32_t aIndex, Float aScale) MOZ_OVERRIDE;
virtual void SetAttribute(uint32_t aIndex, uint32_t aValue) MOZ_OVERRIDE;
protected:
virtual TemporaryRef<DataSourceSurface> Render(const IntRect& aRect) MOZ_OVERRIDE;
@@ -517,17 +517,17 @@ private:
Float mScale;
ColorChannel mChannelX;
ColorChannel mChannelY;
};
class FilterNodeTurbulenceSoftware : public FilterNodeSoftware
{
public:
- MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(FilterNodeTurbulenceSoftware)
+ MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(FilterNodeTurbulenceSoftware, MOZ_OVERRIDE)
FilterNodeTurbulenceSoftware();
virtual const char* GetName() MOZ_OVERRIDE { return "Turbulence"; }
using FilterNodeSoftware::SetAttribute;
virtual void SetAttribute(uint32_t aIndex, const Size &aSize) MOZ_OVERRIDE;
virtual void SetAttribute(uint32_t aIndex, const IntRect &aRenderRect) MOZ_OVERRIDE;
virtual void SetAttribute(uint32_t aIndex, bool aStitchable) MOZ_OVERRIDE;
virtual void SetAttribute(uint32_t aIndex, uint32_t aValue) MOZ_OVERRIDE;
@@ -543,17 +543,17 @@ private:
uint32_t mSeed;
bool mStitchable;
TurbulenceType mType;
};
class FilterNodeArithmeticCombineSoftware : public FilterNodeSoftware
{
public:
- MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(FilterNodeArithmeticCombineSoftware)
+ MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(FilterNodeArithmeticCombineSoftware, MOZ_OVERRIDE)
FilterNodeArithmeticCombineSoftware();
virtual const char* GetName() MOZ_OVERRIDE { return "ArithmeticCombine"; }
using FilterNodeSoftware::SetAttribute;
virtual void SetAttribute(uint32_t aIndex, const Float* aFloat, uint32_t aSize) MOZ_OVERRIDE;
protected:
virtual TemporaryRef<DataSourceSurface> Render(const IntRect& aRect) MOZ_OVERRIDE;
virtual IntRect GetOutputRectInRect(const IntRect& aRect) MOZ_OVERRIDE;
@@ -565,17 +565,17 @@ private:
Float mK2;
Float mK3;
Float mK4;
};
class FilterNodeCompositeSoftware : public FilterNodeSoftware
{
public:
- MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(FilterNodeCompositeSoftware)
+ MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(FilterNodeCompositeSoftware, MOZ_OVERRIDE)
FilterNodeCompositeSoftware();
virtual const char* GetName() MOZ_OVERRIDE { return "Composite"; }
using FilterNodeSoftware::SetAttribute;
virtual void SetAttribute(uint32_t aIndex, uint32_t aOperator) MOZ_OVERRIDE;
protected:
virtual TemporaryRef<DataSourceSurface> Render(const IntRect& aRect) MOZ_OVERRIDE;
virtual IntRect GetOutputRectInRect(const IntRect& aRect) MOZ_OVERRIDE;
@@ -586,48 +586,48 @@ private:
CompositeOperator mOperator;
};
// Base class for FilterNodeGaussianBlurSoftware and
// FilterNodeDirectionalBlurSoftware.
class FilterNodeBlurXYSoftware : public FilterNodeSoftware
{
public:
- MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(FilterNodeBlurXYSoftware)
+ MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(FilterNodeBlurXYSoftware, MOZ_OVERRIDE)
protected:
virtual TemporaryRef<DataSourceSurface> Render(const IntRect& aRect) MOZ_OVERRIDE;
virtual IntRect GetOutputRectInRect(const IntRect& aRect) MOZ_OVERRIDE;
virtual int32_t InputIndex(uint32_t aInputEnumIndex) MOZ_OVERRIDE;
IntRect InflatedSourceOrDestRect(const IntRect &aDestRect);
virtual void RequestFromInputsForRect(const IntRect &aRect) MOZ_OVERRIDE;
// Implemented by subclasses.
virtual Size StdDeviationXY() = 0;
};
class FilterNodeGaussianBlurSoftware : public FilterNodeBlurXYSoftware
{
public:
- MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(FilterNodeGaussianBlurSoftware)
+ MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(FilterNodeGaussianBlurSoftware, MOZ_OVERRIDE)
FilterNodeGaussianBlurSoftware();
virtual const char* GetName() MOZ_OVERRIDE { return "GaussianBlur"; }
using FilterNodeSoftware::SetAttribute;
virtual void SetAttribute(uint32_t aIndex, Float aStdDeviation) MOZ_OVERRIDE;
protected:
virtual Size StdDeviationXY() MOZ_OVERRIDE;
private:
Float mStdDeviation;
};
class FilterNodeDirectionalBlurSoftware : public FilterNodeBlurXYSoftware
{
public:
- MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(FilterNodeDirectionalBlurSoftware)
+ MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(FilterNodeDirectionalBlurSoftware, MOZ_OVERRIDE)
FilterNodeDirectionalBlurSoftware();
virtual const char* GetName() MOZ_OVERRIDE { return "DirectionalBlur"; }
using FilterNodeSoftware::SetAttribute;
virtual void SetAttribute(uint32_t aIndex, Float aStdDeviation) MOZ_OVERRIDE;
virtual void SetAttribute(uint32_t aIndex, uint32_t aBlurDirection) MOZ_OVERRIDE;
protected:
virtual Size StdDeviationXY() MOZ_OVERRIDE;
@@ -635,17 +635,17 @@ protected:
private:
Float mStdDeviation;
BlurDirection mBlurDirection;
};
class FilterNodeCropSoftware : public FilterNodeSoftware
{
public:
- MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(FilterNodeCropSoftware)
+ MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(FilterNodeCropSoftware, MOZ_OVERRIDE)
virtual const char* GetName() MOZ_OVERRIDE { return "Crop"; }
using FilterNodeSoftware::SetAttribute;
virtual void SetAttribute(uint32_t aIndex, const Rect &aSourceRect) MOZ_OVERRIDE;
protected:
virtual TemporaryRef<DataSourceSurface> Render(const IntRect& aRect) MOZ_OVERRIDE;
virtual IntRect GetOutputRectInRect(const IntRect& aRect) MOZ_OVERRIDE;
virtual int32_t InputIndex(uint32_t aInputEnumIndex) MOZ_OVERRIDE;
@@ -653,29 +653,29 @@ protected:
private:
IntRect mCropRect;
};
class FilterNodePremultiplySoftware : public FilterNodeSoftware
{
public:
- MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(FilterNodePremultiplySoftware)
+ MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(FilterNodePremultiplySoftware, MOZ_OVERRIDE)
virtual const char* GetName() MOZ_OVERRIDE { return "Premultiply"; }
protected:
virtual TemporaryRef<DataSourceSurface> Render(const IntRect& aRect) MOZ_OVERRIDE;
virtual IntRect GetOutputRectInRect(const IntRect& aRect) MOZ_OVERRIDE;
virtual int32_t InputIndex(uint32_t aInputEnumIndex) MOZ_OVERRIDE;
virtual void RequestFromInputsForRect(const IntRect &aRect) MOZ_OVERRIDE;
};
class FilterNodeUnpremultiplySoftware : public FilterNodeSoftware
{
public:
- MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(FilterNodeUnpremultiplySoftware)
+ MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(FilterNodeUnpremultiplySoftware, MOZ_OVERRIDE)
virtual const char* GetName() MOZ_OVERRIDE { return "Unpremultiply"; }
protected:
virtual TemporaryRef<DataSourceSurface> Render(const IntRect& aRect) MOZ_OVERRIDE;
virtual IntRect GetOutputRectInRect(const IntRect& aRect) MOZ_OVERRIDE;
virtual int32_t InputIndex(uint32_t aInputEnumIndex) MOZ_OVERRIDE;
virtual void RequestFromInputsForRect(const IntRect &aRect) MOZ_OVERRIDE;
};
--- a/gfx/gl/GLContextCGL.h
+++ b/gfx/gl/GLContextCGL.h
@@ -22,17 +22,17 @@ namespace gl {
class GLContextCGL : public GLContext
{
friend class GLContextProviderCGL;
NSOpenGLContext *mContext;
public:
- MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(GLContextCGL)
+ MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(GLContextCGL, MOZ_OVERRIDE)
GLContextCGL(const SurfaceCaps& caps,
GLContext *shareContext,
NSOpenGLContext *context,
bool isOffscreen = false);
~GLContextCGL();
virtual GLContextType GetContextType() const MOZ_OVERRIDE { return GLContextType::CGL; }
--- a/gfx/gl/GLContextEGL.h
+++ b/gfx/gl/GLContextEGL.h
@@ -24,17 +24,17 @@ class GLContextEGL : public GLContext
static already_AddRefed<GLContextEGL>
CreateGLContext(const SurfaceCaps& caps,
GLContextEGL *shareContext,
bool isOffscreen,
EGLConfig config,
EGLSurface surface);
public:
- MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(GLContextEGL)
+ MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(GLContextEGL, MOZ_OVERRIDE)
GLContextEGL(const SurfaceCaps& caps,
GLContext* shareContext,
bool isOffscreen,
EGLConfig config,
EGLSurface surface,
EGLContext context);
~GLContextEGL();
--- a/gfx/gl/GfxTexturesReporter.h
+++ b/gfx/gl/GfxTexturesReporter.h
@@ -44,17 +44,17 @@ public:
static void UpdateAmount(MemoryUse action, GLenum format, GLenum type,
int32_t tileWidth, int32_t tileHeight);
static void UpdateWasteAmount(int32_t delta) {
sTileWasteAmount += delta;
}
NS_IMETHOD CollectReports(nsIHandleReportCallback* aHandleReport,
- nsISupports* aData, bool aAnonymize)
+ nsISupports* aData, bool aAnonymize) MOZ_OVERRIDE
{
MOZ_COLLECT_REPORT("gfx-tiles-waste", KIND_OTHER, UNITS_BYTES,
sTileWasteAmount,
"Memory lost due to tiles extending past content boundaries");
return MOZ_COLLECT_REPORT(
"gfx-textures", KIND_OTHER, UNITS_BYTES, sAmount,
"Memory used for storing GL textures.");
}
--- a/gfx/skia/trunk/include/effects/SkLayerRasterizer.h
+++ b/gfx/skia/trunk/include/effects/SkLayerRasterizer.h
@@ -70,17 +70,17 @@ protected:
SkLayerRasterizer();
SkLayerRasterizer(SkDeque* layers);
SkLayerRasterizer(SkReadBuffer&);
virtual void flatten(SkWriteBuffer&) const SK_OVERRIDE;
// override from SkRasterizer
virtual bool onRasterize(const SkPath& path, const SkMatrix& matrix,
const SkIRect* clipBounds,
- SkMask* mask, SkMask::CreateMode mode) const;
+ SkMask* mask, SkMask::CreateMode mode) const SK_OVERRIDE;
private:
const SkDeque* const fLayers;
static SkDeque* ReadLayers(SkReadBuffer& buffer);
friend class LayerRasterizerTester;
--- a/gfx/skia/trunk/include/gpu/SkGpuDevice.h
+++ b/gfx/skia/trunk/include/gpu/SkGpuDevice.h
@@ -92,17 +92,17 @@ public:
bool pathIsMutable) SK_OVERRIDE;
virtual void drawBitmap(const SkDraw&, const SkBitmap& bitmap,
const SkMatrix&, const SkPaint&) SK_OVERRIDE;
virtual void drawBitmapRect(const SkDraw&, const SkBitmap&,
const SkRect* srcOrNull, const SkRect& dst,
const SkPaint& paint,
SkCanvas::DrawBitmapRectFlags flags) SK_OVERRIDE;
virtual void drawSprite(const SkDraw&, const SkBitmap& bitmap,
- int x, int y, const SkPaint& paint);
+ int x, int y, const SkPaint& paint) SK_OVERRIDE;
virtual void drawText(const SkDraw&, const void* text, size_t len,
SkScalar x, SkScalar y, const SkPaint&) SK_OVERRIDE;
virtual void drawPosText(const SkDraw&, const void* text, size_t len,
const SkScalar pos[], SkScalar constY,
int scalarsPerPos, const SkPaint&) SK_OVERRIDE;
virtual void drawTextOnPath(const SkDraw&, const void* text, size_t len,
const SkPath& path, const SkMatrix* matrix,
const SkPaint&) SK_OVERRIDE;
--- a/gfx/thebes/gfxASurface.cpp
+++ b/gfx/thebes/gfxASurface.cpp
@@ -583,17 +583,17 @@ static int64_t gSurfaceMemoryUsed[size_t
class SurfaceMemoryReporter MOZ_FINAL : public nsIMemoryReporter
{
~SurfaceMemoryReporter() {}
public:
NS_DECL_ISUPPORTS
NS_IMETHOD CollectReports(nsIMemoryReporterCallback *aCb,
- nsISupports *aClosure, bool aAnonymize)
+ nsISupports *aClosure, bool aAnonymize) MOZ_OVERRIDE
{
const size_t len = ArrayLength(sSurfaceMemoryReporterAttrs);
for (size_t i = 0; i < len; i++) {
int64_t amount = gSurfaceMemoryUsed[i];
if (amount != 0) {
const char *path = sSurfaceMemoryReporterAttrs[i].path;
const char *desc = sSurfaceMemoryReporterAttrs[i].description;
--- a/gfx/thebes/gfxFontInfoLoader.cpp
+++ b/gfx/thebes/gfxFontInfoLoader.cpp
@@ -30,33 +30,33 @@ class FontInfoLoadCompleteEvent : public
virtual ~FontInfoLoadCompleteEvent() {}
NS_DECL_ISUPPORTS_INHERITED
explicit FontInfoLoadCompleteEvent(FontInfoData *aFontInfo) :
mFontInfo(aFontInfo)
{}
- NS_IMETHOD Run();
+ NS_IMETHOD Run() MOZ_OVERRIDE;
nsRefPtr<FontInfoData> mFontInfo;
};
class AsyncFontInfoLoader : public nsRunnable {
virtual ~AsyncFontInfoLoader() {}
NS_DECL_ISUPPORTS_INHERITED
explicit AsyncFontInfoLoader(FontInfoData *aFontInfo) :
mFontInfo(aFontInfo)
{
mCompleteEvent = new FontInfoLoadCompleteEvent(aFontInfo);
}
- NS_IMETHOD Run();
+ NS_IMETHOD Run() MOZ_OVERRIDE;
nsRefPtr<FontInfoData> mFontInfo;
nsRefPtr<FontInfoLoadCompleteEvent> mCompleteEvent;
};
// runs on main thread after async font info loading is done
nsresult
FontInfoLoadCompleteEvent::Run()
--- a/gfx/thebes/gfxImageSurface.h
+++ b/gfx/thebes/gfxImageSurface.h
@@ -71,17 +71,17 @@ public:
explicit gfxImageSurface(cairo_surface_t *csurf);
virtual ~gfxImageSurface();
// ImageSurface methods
gfxImageFormat Format() const { return mFormat; }
- virtual const gfxIntSize GetSize() const { return mSize; }
+ virtual const gfxIntSize GetSize() const MOZ_OVERRIDE { return mSize; }
int32_t Width() const { return mSize.width; }
int32_t Height() const { return mSize.height; }
/**
* Distance in bytes between the start of a line and the start of the
* next line.
*/
int32_t Stride() const { return mStride; }
@@ -116,17 +116,17 @@ public:
*/
virtual mozilla::TemporaryRef<mozilla::gfx::DataSourceSurface> CopyToB8G8R8A8DataSourceSurface();
/* return new Subimage with pointing to original image starting from aRect.pos
* and size of aRect.size. New subimage keeping current image reference
*/
already_AddRefed<gfxSubimageSurface> GetSubimage(const gfxRect& aRect);
- virtual already_AddRefed<gfxImageSurface> GetAsImageSurface();
+ virtual already_AddRefed<gfxImageSurface> GetAsImageSurface() MOZ_OVERRIDE;
/** See gfxASurface.h. */
static long ComputeStride(const gfxIntSize&, gfxImageFormat);
virtual size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
MOZ_OVERRIDE;
virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
MOZ_OVERRIDE;
--- a/gfx/thebes/gfxMacFont.h
+++ b/gfx/thebes/gfxMacFont.h
@@ -50,19 +50,19 @@ public:
virtual mozilla::TemporaryRef<mozilla::gfx::ScaledFont>
GetScaledFont(mozilla::gfx::DrawTarget *aTarget) MOZ_OVERRIDE;
virtual mozilla::TemporaryRef<mozilla::gfx::GlyphRenderingOptions>
GetGlyphRenderingOptions(const TextRunDrawParams* aRunParams = nullptr) MOZ_OVERRIDE;
virtual void AddSizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf,
- FontCacheSizes* aSizes) const;
+ FontCacheSizes* aSizes) const MOZ_OVERRIDE;
virtual void AddSizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf,
- FontCacheSizes* aSizes) const;
+ FontCacheSizes* aSizes) const MOZ_OVERRIDE;
virtual FontType GetType() const MOZ_OVERRIDE { return FONT_TYPE_MAC; }
protected:
virtual const Metrics& GetHorizontalMetrics() MOZ_OVERRIDE {
return mMetrics;
}
--- a/gfx/thebes/gfxMacPlatformFontList.h
+++ b/gfx/thebes/gfxMacPlatformFontList.h
@@ -41,28 +41,28 @@ public:
virtual CGFontRef GetFontRef();
// override gfxFontEntry table access function to bypass table cache,
// use CGFontRef API to get direct access to system font data
virtual hb_blob_t *GetFontTable(uint32_t aTag) MOZ_OVERRIDE;
virtual void AddSizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf,
- FontListSizes* aSizes) const;
+ FontListSizes* aSizes) const MOZ_OVERRIDE;
- nsresult ReadCMAP(FontInfoData *aFontInfoData = nullptr);
+ nsresult ReadCMAP(FontInfoData *aFontInfoData = nullptr) MOZ_OVERRIDE;
bool RequiresAATLayout() const { return mRequiresAAT; }
bool IsCFF();
protected:
- virtual gfxFont* CreateFontInstance(const gfxFontStyle *aFontStyle, bool aNeedsBold);
+ virtual gfxFont* CreateFontInstance(const gfxFontStyle *aFontStyle, bool aNeedsBold) MOZ_OVERRIDE;
- virtual bool HasFontTable(uint32_t aTableTag);
+ virtual bool HasFontTable(uint32_t aTableTag) MOZ_OVERRIDE;
static void DestroyBlobFunc(void* aUserData);
CGFontRef mFontRef; // owning reference to the CGFont, released on destruction
bool mFontRefInitialized;
bool mRequiresAAT;
bool mIsCFF;
--- a/gfx/thebes/gfxPlatformMac.h
+++ b/gfx/thebes/gfxPlatformMac.h
@@ -25,64 +25,64 @@ public:
return (gfxPlatformMac*) gfxPlatform::GetPlatform();
}
virtual already_AddRefed<gfxASurface>
CreateOffscreenSurface(const IntSize& size,
gfxContentType contentType) MOZ_OVERRIDE;
mozilla::TemporaryRef<mozilla::gfx::ScaledFont>
- GetScaledFontForFont(mozilla::gfx::DrawTarget* aTarget, gfxFont *aFont);
+ GetScaledFontForFont(mozilla::gfx::DrawTarget* aTarget, gfxFont *aFont) MOZ_OVERRIDE;
- nsresult GetStandardFamilyName(const nsAString& aFontName, nsAString& aFamilyName);
+ nsresult GetStandardFamilyName(const nsAString& aFontName, nsAString& aFamilyName) MOZ_OVERRIDE;
gfxFontGroup*
CreateFontGroup(const mozilla::FontFamilyList& aFontFamilyList,
const gfxFontStyle *aStyle,
- gfxUserFontSet *aUserFontSet);
+ gfxUserFontSet *aUserFontSet) MOZ_OVERRIDE;
virtual gfxFontEntry* LookupLocalFont(const nsAString& aFontName,
uint16_t aWeight,
int16_t aStretch,
- bool aItalic);
+ bool aItalic) MOZ_OVERRIDE;
- virtual gfxPlatformFontList* CreatePlatformFontList();
+ virtual gfxPlatformFontList* CreatePlatformFontList() MOZ_OVERRIDE;
virtual gfxFontEntry* MakePlatformFont(const nsAString& aFontName,
uint16_t aWeight,
int16_t aStretch,
bool aItalic,
const uint8_t* aFontData,
- uint32_t aLength);
+ uint32_t aLength) MOZ_OVERRIDE;
- bool IsFontFormatSupported(nsIURI *aFontURI, uint32_t aFormatFlags);
+ bool IsFontFormatSupported(nsIURI *aFontURI, uint32_t aFormatFlags) MOZ_OVERRIDE;
nsresult GetFontList(nsIAtom *aLangGroup,
const nsACString& aGenericFamily,
- nsTArray<nsString>& aListOfFonts);
- nsresult UpdateFontList();
+ nsTArray<nsString>& aListOfFonts) MOZ_OVERRIDE;
+ nsresult UpdateFontList() MOZ_OVERRIDE;
virtual void GetCommonFallbackFonts(uint32_t aCh, uint32_t aNextCh,
int32_t aRunScript,
- nsTArray<const char*>& aFontList);
+ nsTArray<const char*>& aFontList) MOZ_OVERRIDE;
virtual bool CanRenderContentToDataSurface() const MOZ_OVERRIDE {
return true;
}
bool UseAcceleratedCanvas();
virtual bool UseProgressivePaint() MOZ_OVERRIDE;
virtual already_AddRefed<mozilla::gfx::VsyncSource> CreateHardwareVsyncSource() MOZ_OVERRIDE;
// lower threshold on font anti-aliasing
uint32_t GetAntiAliasingThreshold() { return mFontAntiAliasingThreshold; }
private:
- virtual void GetPlatformCMSOutputProfile(void* &mem, size_t &size);
+ virtual void GetPlatformCMSOutputProfile(void* &mem, size_t &size) MOZ_OVERRIDE;
// read in the pref value for the lower threshold on font anti-aliasing
static uint32_t ReadAntiAliasingThreshold();
uint32_t mFontAntiAliasingThreshold;
};
#endif /* GFX_PLATFORM_MAC_H */
--- a/gfx/thebes/gfxReusableImageSurfaceWrapper.h
+++ b/gfx/thebes/gfxReusableImageSurfaceWrapper.h
@@ -21,17 +21,17 @@ protected:
public:
const unsigned char* GetReadOnlyData() const MOZ_OVERRIDE;
gfxImageFormat Format() MOZ_OVERRIDE;
gfxReusableSurfaceWrapper* GetWritable(gfxImageSurface** aSurface) MOZ_OVERRIDE;
void ReadLock() MOZ_OVERRIDE;
void ReadUnlock() MOZ_OVERRIDE;
- Type GetType()
+ Type GetType() MOZ_OVERRIDE
{
return TYPE_IMAGE;
}
private:
nsRefPtr<gfxImageSurface> mSurface;
};
--- a/gfx/thebes/gfxReusableSharedImageSurfaceWrapper.h
+++ b/gfx/thebes/gfxReusableSharedImageSurfaceWrapper.h
@@ -32,17 +32,17 @@ protected:
public:
const unsigned char* GetReadOnlyData() const MOZ_OVERRIDE;
gfxImageFormat Format() MOZ_OVERRIDE;
gfxReusableSurfaceWrapper* GetWritable(gfxImageSurface** aSurface) MOZ_OVERRIDE;
void ReadLock() MOZ_OVERRIDE;
void ReadUnlock() MOZ_OVERRIDE;
- Type GetType()
+ Type GetType() MOZ_OVERRIDE
{
return TYPE_SHARED_IMAGE;
}
/**
* Returns the shared memory segment that backs the shared image surface.
*/
mozilla::ipc::Shmem& GetShmem();
--- a/gfx/thebes/gfxVR.cpp
+++ b/gfx/thebes/gfxVR.cpp
@@ -190,45 +190,45 @@ class FakeScreen : public nsIScreen
{
public:
explicit FakeScreen(const IntRect& aScreenRect)
: mScreenRect(aScreenRect)
{ }
NS_DECL_ISUPPORTS
- NS_IMETHOD GetRect(int32_t *l, int32_t *t, int32_t *w, int32_t *h) {
+ NS_IMETHOD GetRect(int32_t *l, int32_t *t, int32_t *w, int32_t *h) MOZ_OVERRIDE {
*l = mScreenRect.x;
*t = mScreenRect.y;
*w = mScreenRect.width;
*h = mScreenRect.height;
return NS_OK;
}
- NS_IMETHOD GetAvailRect(int32_t *l, int32_t *t, int32_t *w, int32_t *h) {
+ NS_IMETHOD GetAvailRect(int32_t *l, int32_t *t, int32_t *w, int32_t *h) MOZ_OVERRIDE {
return GetRect(l, t, w, h);
}
- NS_IMETHOD GetRectDisplayPix(int32_t *l, int32_t *t, int32_t *w, int32_t *h) {
+ NS_IMETHOD GetRectDisplayPix(int32_t *l, int32_t *t, int32_t *w, int32_t *h) MOZ_OVERRIDE {
return GetRect(l, t, w, h);
}
- NS_IMETHOD GetAvailRectDisplayPix(int32_t *l, int32_t *t, int32_t *w, int32_t *h) {
+ NS_IMETHOD GetAvailRectDisplayPix(int32_t *l, int32_t *t, int32_t *w, int32_t *h) MOZ_OVERRIDE {
return GetAvailRect(l, t, w, h);
}
- NS_IMETHOD GetId(uint32_t* aId) { *aId = (uint32_t)-1; return NS_OK; }
- NS_IMETHOD GetPixelDepth(int32_t* aPixelDepth) { *aPixelDepth = 24; return NS_OK; }
- NS_IMETHOD GetColorDepth(int32_t* aColorDepth) { *aColorDepth = 24; return NS_OK; }
+ NS_IMETHOD GetId(uint32_t* aId) MOZ_OVERRIDE { *aId = (uint32_t)-1; return NS_OK; }
+ NS_IMETHOD GetPixelDepth(int32_t* aPixelDepth) MOZ_OVERRIDE { *aPixelDepth = 24; return NS_OK; }
+ NS_IMETHOD GetColorDepth(int32_t* aColorDepth) MOZ_OVERRIDE { *aColorDepth = 24; return NS_OK; }
- NS_IMETHOD LockMinimumBrightness(uint32_t aBrightness) { return NS_ERROR_NOT_AVAILABLE; }
- NS_IMETHOD UnlockMinimumBrightness(uint32_t aBrightness) { return NS_ERROR_NOT_AVAILABLE; }
- NS_IMETHOD GetRotation(uint32_t* aRotation) {
+ NS_IMETHOD LockMinimumBrightness(uint32_t aBrightness) MOZ_OVERRIDE { return NS_ERROR_NOT_AVAILABLE; }
+ NS_IMETHOD UnlockMinimumBrightness(uint32_t aBrightness) MOZ_OVERRIDE { return NS_ERROR_NOT_AVAILABLE; }
+ NS_IMETHOD GetRotation(uint32_t* aRotation) MOZ_OVERRIDE {
*aRotation = nsIScreen::ROTATION_0_DEG;
return NS_OK;
}
- NS_IMETHOD SetRotation(uint32_t aRotation) { return NS_ERROR_NOT_AVAILABLE; }
- NS_IMETHOD GetContentsScaleFactor(double* aContentsScaleFactor) {
+ NS_IMETHOD SetRotation(uint32_t aRotation) MOZ_OVERRIDE { return NS_ERROR_NOT_AVAILABLE; }
+ NS_IMETHOD GetContentsScaleFactor(double* aContentsScaleFactor) MOZ_OVERRIDE {
*aContentsScaleFactor = 1.0;
return NS_OK;
}
protected:
virtual ~FakeScreen() {}
IntRect mScreenRect;