Bug 1453795 - GFX - Initialize member fields in classes/ structures. r=nical
authorAndi-Bogdan Postelnicu <bpostelnicu@mozilla.com>
Sat, 16 Jun 2018 17:42:33 +0300
changeset 485356 ba5c08f10923c181c30ef42b371ed9009974911d
parent 485355 7d15ad797aea871ad2f1599bef6efe7d4f274940
child 485357 96a7f93d60a9fe1b3a929810d3d8d7a8f8bde00e
push id9719
push userffxbld-merge
push dateFri, 24 Aug 2018 17:49:46 +0000
treeherdermozilla-beta@719ec98fba77 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersnical
bugs1453795
milestone63.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1453795 - GFX - Initialize member fields in classes/ structures. r=nical
gfx/2d/2D.h
gfx/2d/Blur.cpp
gfx/2d/DrawTargetCairo.cpp
gfx/2d/DrawTargetSkia.cpp
gfx/2d/FilterNodeSoftware.cpp
gfx/2d/ImageScaling.h
gfx/2d/RecordedEventImpl.h
gfx/2d/SVGTurbulenceRenderer-inl.h
gfx/2d/SourceSurfaceSkia.cpp
gfx/2d/Tools.h
gfx/layers/AnimationHelper.h
gfx/layers/AtomicRefCountedWithFinalize.h
gfx/layers/LayerTreeInvalidation.cpp
gfx/layers/SourceSurfaceSharedData.h
gfx/layers/apz/src/KeyboardMap.cpp
gfx/layers/basic/BasicLayerManager.cpp
gfx/layers/client/ClientLayerManager.cpp
gfx/layers/composite/TextureHost.h
gfx/layers/ipc/CompositorBridgeParent.cpp
gfx/layers/ipc/LayerTransactionParent.cpp
gfx/layers/ipc/ShadowLayers.cpp
gfx/layers/mlgpu/ContainerLayerMLGPU.cpp
gfx/layers/mlgpu/LayerMLGPU.cpp
gfx/layers/mlgpu/MLGDevice.cpp
gfx/layers/mlgpu/RenderPassMLGPU.cpp
gfx/layers/mlgpu/SharedBufferMLGPU.cpp
gfx/layers/mlgpu/TexturedLayerMLGPU.cpp
gfx/layers/opengl/CompositingRenderTargetOGL.h
gfx/layers/opengl/CompositorOGL.cpp
gfx/layers/opengl/TextureHostOGL.h
gfx/layers/wr/WebRenderCommandBuilder.cpp
gfx/src/nsDeviceContext.cpp
gfx/src/nsRegion.h
gfx/thebes/PrintTargetSkPDF.cpp
gfx/thebes/gfxContext.h
gfx/thebes/gfxFont.cpp
gfx/thebes/gfxFontEntry.cpp
gfx/thebes/gfxFontFamilyList.h
gfx/thebes/gfxFontInfoLoader.h
gfx/thebes/gfxGlyphExtents.h
gfx/thebes/gfxGraphiteShaper.cpp
gfx/thebes/gfxHarfBuzzShaper.cpp
gfx/thebes/gfxImageSurface.cpp
gfx/thebes/gfxMacPlatformFontList.mm
gfx/thebes/gfxMathTable.cpp
gfx/thebes/gfxPlatform.cpp
gfx/thebes/gfxSkipChars.h
gfx/thebes/gfxUserFontSet.cpp
gfx/webrender_bindings/RenderBufferTextureHost.cpp
gfx/webrender_bindings/RenderSharedSurfaceTextureHost.cpp
--- a/gfx/2d/2D.h
+++ b/gfx/2d/2D.h
@@ -946,17 +946,21 @@ class DrawTargetCapture;
  * factory and accepts drawing commands. The results of drawing to a target
  * may be used either through a Snapshot or by flushing the target and directly
  * accessing the backing store a DrawTarget was created with.
  */
 class DrawTarget : public external::AtomicRefCounted<DrawTarget>
 {
 public:
   MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(DrawTarget)
-  DrawTarget() : mTransformDirty(false), mPermitSubpixelAA(false) {}
+  DrawTarget()
+    : mTransformDirty(false)
+    , mPermitSubpixelAA(false)
+    , mFormat(SurfaceFormat::UNKNOWN)
+  {}
   virtual ~DrawTarget() {}
 
   virtual bool IsValid() const { return true; };
   virtual DrawTargetType GetType() const = 0;
 
   virtual BackendType GetBackendType() const = 0;
 
   virtual bool IsRecording() const { return false; }
--- a/gfx/2d/Blur.cpp
+++ b/gfx/2d/Blur.cpp
@@ -434,23 +434,26 @@ AlphaBoxBlur::RoundUpToMultipleOf4(int32
   return val;
 }
 
 AlphaBoxBlur::AlphaBoxBlur(const Rect& aRect,
                            const IntSize& aSpreadRadius,
                            const IntSize& aBlurRadius,
                            const Rect* aDirtyRect,
                            const Rect* aSkipRect)
-  : mSurfaceAllocationSize(0)
+  : mStride(0),
+    mSurfaceAllocationSize(0)
 {
   Init(aRect, aSpreadRadius, aBlurRadius, aDirtyRect, aSkipRect);
 }
 
 AlphaBoxBlur::AlphaBoxBlur()
-  : mSurfaceAllocationSize(0)
+  : mStride(0),
+    mSurfaceAllocationSize(0),
+    mHasDirtyRect(false)
 {
 }
 
 void
 AlphaBoxBlur::Init(const Rect& aRect,
                    const IntSize& aSpreadRadius,
                    const IntSize& aBlurRadius,
                    const Rect* aDirtyRect,
@@ -512,17 +515,18 @@ AlphaBoxBlur::Init(const Rect& aRect,
 AlphaBoxBlur::AlphaBoxBlur(const Rect& aRect,
                            int32_t aStride,
                            float aSigmaX,
                            float aSigmaY)
   : mRect(TruncatedToInt(aRect)),
     mSpreadRadius(),
     mBlurRadius(CalculateBlurRadius(Point(aSigmaX, aSigmaY))),
     mStride(aStride),
-    mSurfaceAllocationSize(0)
+    mSurfaceAllocationSize(0),
+    mHasDirtyRect(false)
 {
   IntRect intRect;
   if (aRect.ToIntRect(&intRect)) {
     size_t minDataSize = BufferSizeFromStrideAndHeight(intRect.Width(), intRect.Height());
     if (minDataSize != 0) {
       mSurfaceAllocationSize = minDataSize;
     }
   }
--- a/gfx/2d/DrawTargetCairo.cpp
+++ b/gfx/2d/DrawTargetCairo.cpp
@@ -432,16 +432,18 @@ public:
     , mX(0)
     , mY(0)
   {
     Init(aSurface);
   }
 
   explicit AutoClearDeviceOffset(const Pattern& aPattern)
     : mSurface(nullptr)
+    , mX(0.0)
+    , mY(0.0)
   {
     if (aPattern.GetType() == PatternType::SURFACE) {
       const SurfacePattern& pattern = static_cast<const SurfacePattern&>(aPattern);
       Init(pattern.mSurface);
     }
   }
 
   ~AutoClearDeviceOffset()
--- a/gfx/2d/DrawTargetSkia.cpp
+++ b/gfx/2d/DrawTargetSkia.cpp
@@ -270,17 +270,18 @@ GetSkImageForSurface(SourceSurface* aSur
   // Skia doesn't support RGBX surfaces so ensure that the alpha value is opaque white.
   MOZ_ASSERT(VerifyRGBXCorners(surf->GetData(), surf->GetSize(),
                                surf->Stride(), surf->GetFormat(),
                                aBounds, aMatrix));
   return image;
 }
 
 DrawTargetSkia::DrawTargetSkia()
-  : mSnapshot(nullptr)
+  : mCanvas(nullptr)
+  , mSnapshot(nullptr)
   , mSnapshotLock{"DrawTargetSkia::mSnapshotLock"}
 #ifdef MOZ_WIDGET_COCOA
   , mCG(nullptr)
   , mColorSpace(nullptr)
   , mCanvasData(nullptr)
   , mCGSize(0, 0)
   , mNeedLayer(false)
 #endif
--- a/gfx/2d/FilterNodeSoftware.cpp
+++ b/gfx/2d/FilterNodeSoftware.cpp
@@ -2124,16 +2124,20 @@ FilterNodeGammaTransferSoftware::FilterN
  : mAmplitudeR(0)
  , mAmplitudeG(0)
  , mAmplitudeB(0)
  , mAmplitudeA(0)
  , mExponentR(0)
  , mExponentG(0)
  , mExponentB(0)
  , mExponentA(0)
+ , mOffsetR(0.0)
+ , mOffsetG(0.0)
+ , mOffsetB(0.0)
+ , mOffsetA(0.0)
 {}
 
 void
 FilterNodeGammaTransferSoftware::SetAttribute(uint32_t aIndex,
                                               Float aValue)
 {
   switch (aIndex) {
     case ATT_GAMMA_TRANSFER_AMPLITUDE_R:
@@ -3111,17 +3115,18 @@ FilterNodeGaussianBlurSoftware::SetAttri
 
 Size
 FilterNodeGaussianBlurSoftware::StdDeviationXY()
 {
   return Size(mStdDeviation, mStdDeviation);
 }
 
 FilterNodeDirectionalBlurSoftware::FilterNodeDirectionalBlurSoftware()
- : mBlurDirection(BLUR_DIRECTION_X)
+  : mStdDeviation(0.0)
+  , mBlurDirection(BLUR_DIRECTION_X)
 {}
 
 void
 FilterNodeDirectionalBlurSoftware::SetAttribute(uint32_t aIndex,
                                                 Float aStdDeviation)
 {
   switch (aIndex) {
     case ATT_DIRECTIONAL_BLUR_STD_DEVIATION:
--- a/gfx/2d/ImageScaling.h
+++ b/gfx/2d/ImageScaling.h
@@ -16,16 +16,18 @@ namespace mozilla {
 namespace gfx {
 
 class ImageHalfScaler
 {
 public:
   ImageHalfScaler(uint8_t *aData, int32_t aStride, const IntSize &aSize)
     : mOrigData(aData), mOrigStride(aStride), mOrigSize(aSize)
     , mDataStorage(nullptr)
+    , mData(nullptr)
+    , mStride(0)
   {
   }
 
   ~ImageHalfScaler()
   {
     delete [] mDataStorage;
   }
 
--- a/gfx/2d/RecordedEventImpl.h
+++ b/gfx/2d/RecordedEventImpl.h
@@ -90,17 +90,18 @@ private:
 
   template<class S>
   MOZ_IMPLICIT RecordedDrawTargetCreation(S &aStream);
 };
 
 class RecordedDrawTargetDestruction : public RecordedEventDerived<RecordedDrawTargetDestruction> {
 public:
   MOZ_IMPLICIT RecordedDrawTargetDestruction(ReferencePtr aRefPtr)
-    : RecordedEventDerived(DRAWTARGETDESTRUCTION), mRefPtr(aRefPtr)
+    : RecordedEventDerived(DRAWTARGETDESTRUCTION), mRefPtr(aRefPtr),
+      mBackendType(BackendType::NONE)
   {}
 
   virtual bool PlayEvent(Translator *aTranslator) const override;
 
   template<class S>
   void Record(S &aStream) const;
   virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const override;
 
@@ -176,17 +177,18 @@ private:
 
   template<class S>
   MOZ_IMPLICIT RecordedCreateClippedDrawTarget(S &aStream);
 };
 
 class RecordedFillRect : public RecordedDrawingEvent<RecordedFillRect> {
 public:
   RecordedFillRect(DrawTarget *aDT, const Rect &aRect, const Pattern &aPattern, const DrawOptions &aOptions)
-    : RecordedDrawingEvent(FILLRECT, aDT), mRect(aRect), mOptions(aOptions)
+    : RecordedDrawingEvent(FILLRECT, aDT), mRect(aRect),
+      mPattern(), mOptions(aOptions)
   {
     StorePattern(mPattern, aPattern);
   }
 
   virtual bool PlayEvent(Translator *aTranslator) const override;
 
   template<class S>
   void Record(S &aStream) const;
@@ -205,17 +207,18 @@ private:
   DrawOptions mOptions;
 };
 
 class RecordedStrokeRect : public RecordedDrawingEvent<RecordedStrokeRect> {
 public:
   RecordedStrokeRect(DrawTarget *aDT, const Rect &aRect, const Pattern &aPattern,
                      const StrokeOptions &aStrokeOptions, const DrawOptions &aOptions)
     : RecordedDrawingEvent(STROKERECT, aDT), mRect(aRect),
-      mStrokeOptions(aStrokeOptions), mOptions(aOptions)
+      mPattern(), mStrokeOptions(aStrokeOptions),
+      mOptions(aOptions)
   {
     StorePattern(mPattern, aPattern);
   }
 
   virtual bool PlayEvent(Translator *aTranslator) const override;
 
   template<class S>
   void Record(S &aStream) const;
@@ -236,17 +239,17 @@ private:
 };
 
 class RecordedStrokeLine : public RecordedDrawingEvent<RecordedStrokeLine> {
 public:
   RecordedStrokeLine(DrawTarget *aDT, const Point &aBegin, const Point &aEnd,
                      const Pattern &aPattern, const StrokeOptions &aStrokeOptions,
                      const DrawOptions &aOptions)
     : RecordedDrawingEvent(STROKELINE, aDT), mBegin(aBegin), mEnd(aEnd),
-      mStrokeOptions(aStrokeOptions), mOptions(aOptions)
+      mPattern(), mStrokeOptions(aStrokeOptions), mOptions(aOptions)
   {
     StorePattern(mPattern, aPattern);
   }
 
   virtual bool PlayEvent(Translator *aTranslator) const override;
 
   template<class S>
   void Record(S &aStream) const;
@@ -265,17 +268,18 @@ private:
   PatternStorage mPattern;
   StrokeOptions mStrokeOptions;
   DrawOptions mOptions;
 };
 
 class RecordedFill : public RecordedDrawingEvent<RecordedFill> {
 public:
   RecordedFill(DrawTarget *aDT, ReferencePtr aPath, const Pattern &aPattern, const DrawOptions &aOptions)
-    : RecordedDrawingEvent(FILL, aDT), mPath(aPath), mOptions(aOptions)
+    : RecordedDrawingEvent(FILL, aDT), mPath(aPath),
+      mPattern(), mOptions(aOptions)
   {
     StorePattern(mPattern, aPattern);
   }
 
   virtual bool PlayEvent(Translator *aTranslator) const override;
 
   template<class S> void Record(S &aStream) const;
   virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const override;
@@ -292,17 +296,18 @@ private:
   PatternStorage mPattern;
   DrawOptions mOptions;
 };
 
 class RecordedFillGlyphs : public RecordedDrawingEvent<RecordedFillGlyphs> {
 public:
   RecordedFillGlyphs(DrawTarget *aDT, ReferencePtr aScaledFont, const Pattern &aPattern, const DrawOptions &aOptions,
                      const Glyph *aGlyphs, uint32_t aNumGlyphs)
-    : RecordedDrawingEvent(FILLGLYPHS, aDT), mScaledFont(aScaledFont), mOptions(aOptions)
+    : RecordedDrawingEvent(FILLGLYPHS, aDT), mScaledFont(aScaledFont),
+      mPattern(), mOptions(aOptions)
   {
     StorePattern(mPattern, aPattern);
     mNumGlyphs = aNumGlyphs;
     mGlyphs = new Glyph[aNumGlyphs];
     memcpy(mGlyphs, aGlyphs, sizeof(Glyph) * aNumGlyphs);
   }
   virtual ~RecordedFillGlyphs();
 
@@ -324,17 +329,17 @@ private:
   DrawOptions mOptions;
   Glyph *mGlyphs;
   uint32_t mNumGlyphs;
 };
 
 class RecordedMask : public RecordedDrawingEvent<RecordedMask> {
 public:
   RecordedMask(DrawTarget *aDT, const Pattern &aSource, const Pattern &aMask, const DrawOptions &aOptions)
-    : RecordedDrawingEvent(MASK, aDT), mOptions(aOptions)
+    : RecordedDrawingEvent(MASK, aDT), mSource(), mMask(), mOptions(aOptions)
   {
     StorePattern(mSource, aSource);
     StorePattern(mMask, aMask);
   }
 
   virtual bool PlayEvent(Translator *aTranslator) const override;
 
   template<class S> void Record(S &aStream) const;
@@ -352,17 +357,17 @@ private:
   PatternStorage mMask;
   DrawOptions mOptions;
 };
 
 class RecordedStroke : public RecordedDrawingEvent<RecordedStroke> {
 public:
   RecordedStroke(DrawTarget *aDT, ReferencePtr aPath, const Pattern &aPattern,
                      const StrokeOptions &aStrokeOptions, const DrawOptions &aOptions)
-    : RecordedDrawingEvent(STROKE, aDT), mPath(aPath),
+    : RecordedDrawingEvent(STROKE, aDT), mPath(aPath), mPattern(),
       mStrokeOptions(aStrokeOptions), mOptions(aOptions)
   {
     StorePattern(mPattern, aPattern);
   }
 
   virtual bool PlayEvent(Translator *aTranslator) const override;
 
   template<class S> void Record(S &aStream) const;
@@ -1003,16 +1008,17 @@ public:
     auto recordedFontData = static_cast<RecordedFontData*>(aBaton);
     recordedFontData->SetFontData(aData, aSize, aIndex);
   }
 
   explicit RecordedFontData(UnscaledFont *aUnscaledFont)
     : RecordedEventDerived(FONTDATA)
     , mType(aUnscaledFont->GetType())
     , mData(nullptr)
+    , mFontDetails()
   {
     mGetFontFileDataSucceeded = aUnscaledFont->GetFontFileData(&FontDataProc, this) && mData;
   }
 
   ~RecordedFontData();
 
   bool IsValid() const { return mGetFontFileDataSucceeded; }
 
@@ -1264,18 +1270,18 @@ private:
   template<class S>
   MOZ_IMPLICIT RecordedScaledFontDestruction(S &aStream);
 };
 
 class RecordedMaskSurface : public RecordedDrawingEvent<RecordedMaskSurface> {
 public:
   RecordedMaskSurface(DrawTarget *aDT, const Pattern &aPattern, ReferencePtr aRefMask,
                       const Point &aOffset, const DrawOptions &aOptions)
-    : RecordedDrawingEvent(MASKSURFACE, aDT), mRefMask(aRefMask), mOffset(aOffset)
-    , mOptions(aOptions)
+    : RecordedDrawingEvent(MASKSURFACE, aDT), mPattern(), mRefMask(aRefMask),
+      mOffset(aOffset), mOptions(aOptions)
   {
     StorePattern(mPattern, aPattern);
   }
 
   virtual bool PlayEvent(Translator *aTranslator) const override;
 
   template<class S> void Record(S &aStream) const;
   virtual void OutputSimpleEventInfo(std::stringstream &aStringStream) const override;
--- a/gfx/2d/SVGTurbulenceRenderer-inl.h
+++ b/gfx/2d/SVGTurbulenceRenderer-inl.h
@@ -96,16 +96,19 @@ private:
 
 } // unnamed namespace
 
 template<TurbulenceType Type, bool Stitch, typename f32x4_t, typename i32x4_t, typename u8x16_t>
 SVGTurbulenceRenderer<Type,Stitch,f32x4_t,i32x4_t,u8x16_t>::SVGTurbulenceRenderer(const Size &aBaseFrequency, int32_t aSeed,
                                                             int aNumOctaves, const Rect &aTileRect)
  : mBaseFrequency(aBaseFrequency)
  , mNumOctaves(aNumOctaves)
+ , mStitchInfo()
+ , mStitchable(false)
+ , mType(TURBULENCE_TYPE_TURBULENCE)
 {
   InitFromSeed(aSeed);
   if (Stitch) {
     AdjustBaseFrequencyForStitch(aTileRect);
     mStitchInfo = CreateStitchInfo(aTileRect);
   }
 }
 
--- a/gfx/2d/SourceSurfaceSkia.cpp
+++ b/gfx/2d/SourceSurfaceSkia.cpp
@@ -14,17 +14,19 @@
 #include "mozilla/CheckedInt.h"
 
 using namespace std;
 
 namespace mozilla {
 namespace gfx {
 
 SourceSurfaceSkia::SourceSurfaceSkia()
-  : mDrawTarget(nullptr)
+  : mFormat(SurfaceFormat::UNKNOWN)
+  , mStride(0)
+  , mDrawTarget(nullptr)
   , mChangeMutex("SourceSurfaceSkia::mChangeMutex")
 {
 }
 
 SourceSurfaceSkia::~SourceSurfaceSkia()
 {
 }
 
--- a/gfx/2d/Tools.h
+++ b/gfx/2d/Tools.h
@@ -141,21 +141,23 @@ IsOpaqueFormat(SurfaceFormat aFormat) {
 template<typename T, int alignment = 16>
 struct AlignedArray
 {
   typedef T value_type;
 
   AlignedArray()
     : mPtr(nullptr)
     , mStorage(nullptr)
+    , mCount(0)
   {
   }
 
   explicit MOZ_ALWAYS_INLINE AlignedArray(size_t aCount, bool aZero = false)
-    : mStorage(nullptr)
+    : mPtr(nullptr)
+    , mStorage(nullptr)
     , mCount(0)
   {
     Realloc(aCount, aZero);
   }
 
   MOZ_ALWAYS_INLINE ~AlignedArray()
   {
     Dealloc();
--- a/gfx/layers/AnimationHelper.h
+++ b/gfx/layers/AnimationHelper.h
@@ -62,16 +62,17 @@ struct AnimatedValue {
     AnimationTransform mTransform;
     float mOpacity;
   };
 
   AnimatedValue(gfx::Matrix4x4&& aTransformInDevSpace,
                 gfx::Matrix4x4&& aFrameTransform,
                 const TransformData& aData)
     : mType(AnimatedValue::TRANSFORM)
+    , mOpacity(0.0)
   {
     mTransform.mTransformInDevSpace = std::move(aTransformInDevSpace);
     mTransform.mFrameTransform = std::move(aFrameTransform);
     mTransform.mData = aData;
   }
 
   explicit AnimatedValue(const float& aValue)
     : mType(AnimatedValue::OPACITY)
--- a/gfx/layers/AtomicRefCountedWithFinalize.h
+++ b/gfx/layers/AtomicRefCountedWithFinalize.h
@@ -31,16 +31,17 @@ class RefQueue;
 } // namespace gl
 
 template<typename T>
 class AtomicRefCountedWithFinalize
 {
 protected:
     explicit AtomicRefCountedWithFinalize(const char* aName)
       : mRecycleCallback(nullptr)
+      , mClosure(nullptr)
       , mRefCount(0)
 #ifdef DEBUG
       , mSpew(false)
       , mManualAddRefs(0)
       , mManualReleases(0)
 #endif
 #ifdef NS_BUILD_REFCNT_LOGGING
       , mName(aName)
--- a/gfx/layers/LayerTreeInvalidation.cpp
+++ b/gfx/layers/LayerTreeInvalidation.cpp
@@ -166,16 +166,20 @@ struct LayerPropertiesBase : public Laye
     if (mUseClipRect) {
       mClipRect = *aLayer->GetLocalClipRect();
     }
     mTransform = GetTransformForInvalidation(aLayer);
   }
   LayerPropertiesBase()
     : mLayer(nullptr)
     , mMaskLayer(nullptr)
+    , mPostXScale(0.0)
+    , mPostYScale(0.0)
+    , mOpacity(0.0)
+    , mUseClipRect(false)
   {
     MOZ_COUNT_CTOR(LayerPropertiesBase);
   }
   ~LayerPropertiesBase() override
   {
     MOZ_COUNT_DTOR(LayerPropertiesBase);
   }
 
--- a/gfx/layers/SourceSurfaceSharedData.h
+++ b/gfx/layers/SourceSurfaceSharedData.h
@@ -37,16 +37,17 @@ class SourceSurfaceSharedDataWrapper fin
 
 public:
   MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(SourceSurfaceSharedDataWrapper, override)
 
   SourceSurfaceSharedDataWrapper()
     : mStride(0)
     , mConsumers(0)
     , mFormat(SurfaceFormat::UNKNOWN)
+    , mCreatorPid(0)
   { }
 
   bool Init(const IntSize& aSize,
             int32_t aStride,
             SurfaceFormat aFormat,
             const SharedMemoryBasic::Handle& aHandle,
             base::ProcessId aCreatorPid);
 
--- a/gfx/layers/apz/src/KeyboardMap.cpp
+++ b/gfx/layers/apz/src/KeyboardMap.cpp
@@ -6,17 +6,25 @@
 
 #include "mozilla/layers/KeyboardMap.h"
 
 #include "mozilla/TextEvents.h" // for IgnoreModifierState, ShortcutKeyCandidate
 
 namespace mozilla {
 namespace layers {
 
-KeyboardShortcut::KeyboardShortcut() = default;
+KeyboardShortcut::KeyboardShortcut()
+  : mKeyCode(0)
+  , mCharCode(0)
+  , mModifiers(0)
+  , mModifiersMask(0)
+  , mEventType(KeyboardInput::KeyboardEventType::KEY_OTHER)
+  , mDispatchToContent(false)
+{
+}
 
 KeyboardShortcut::KeyboardShortcut(KeyboardInput::KeyboardEventType aEventType,
                                    uint32_t aKeyCode,
                                    uint32_t aCharCode,
                                    Modifiers aModifiers,
                                    Modifiers aModifiersMask,
                                    const KeyboardScrollAction& aAction)
   : mAction(aAction)
--- a/gfx/layers/basic/BasicLayerManager.cpp
+++ b/gfx/layers/basic/BasicLayerManager.cpp
@@ -309,16 +309,17 @@ BasicLayerManager::BasicLayerManager(nsI
 
 BasicLayerManager::BasicLayerManager(BasicLayerManagerType aType)
   : mPhase(PHASE_NONE)
   , mWidget(nullptr)
   , mDoubleBuffering(BufferMode::BUFFER_NONE)
   , mType(aType)
   , mUsingDefaultTarget(false)
   , mTransactionIncomplete(false)
+  , mCompositorMightResample(false)
 {
   MOZ_COUNT_CTOR(BasicLayerManager);
   MOZ_ASSERT(mType != BLM_WIDGET);
 }
 
 BasicLayerManager::~BasicLayerManager()
 {
   NS_ASSERTION(!InTransaction(), "Died during transaction?");
--- a/gfx/layers/client/ClientLayerManager.cpp
+++ b/gfx/layers/client/ClientLayerManager.cpp
@@ -89,16 +89,18 @@ ClientLayerManager::MemoryPressureObserv
   }
 }
 
 NS_IMPL_ISUPPORTS(ClientLayerManager::MemoryPressureObserver, nsIObserver)
 
 ClientLayerManager::ClientLayerManager(nsIWidget* aWidget)
   : mPhase(PHASE_NONE)
   , mWidget(aWidget)
+  , mPaintedLayerCallback(nullptr)
+  , mPaintedLayerCallbackData(nullptr)
   , mLatestTransactionId{0}
   , mLastPaintTime(TimeDuration::Forever())
   , mTargetRotation(ROTATION_0)
   , mRepeatTransaction(false)
   , mIsRepeatTransaction(false)
   , mTransactionIncomplete(false)
   , mCompositorMightResample(false)
   , mNeedsComposite(false)
--- a/gfx/layers/composite/TextureHost.h
+++ b/gfx/layers/composite/TextureHost.h
@@ -930,17 +930,20 @@ private:
  */
 class CompositingRenderTarget: public TextureSource
 {
 public:
 
   explicit CompositingRenderTarget(const gfx::IntPoint& aOrigin)
     : mClearOnBind(false)
     , mOrigin(aOrigin)
+    , mZNear(0)
+    , mZFar(0)
     , mHasComplexProjection(false)
+    , mEnableDepthBuffer(false)
   {}
   virtual ~CompositingRenderTarget() {}
 
   virtual const char* Name() const override { return "CompositingRenderTarget"; }
 
 #ifdef MOZ_DUMP_PAINTING
   virtual already_AddRefed<gfx::DataSourceSurface> Dump(Compositor* aCompositor) { return nullptr; }
 #endif
--- a/gfx/layers/ipc/CompositorBridgeParent.cpp
+++ b/gfx/layers/ipc/CompositorBridgeParent.cpp
@@ -353,16 +353,17 @@ CompositorBridgeParent::CompositorBridge
   , mVsyncRate(aVsyncRate)
   , mPendingTransaction{0}
   , mPaused(false)
   , mUseExternalSurfaceSize(aUseExternalSurfaceSize)
   , mEGLSurfaceSize(aSurfaceSize)
   , mOptions(aOptions)
   , mPauseCompositionMonitor("PauseCompositionMonitor")
   , mResumeCompositionMonitor("ResumeCompositionMonitor")
+  , mCompositorBridgeID(0)
   , mRootLayerTreeID{0}
   , mOverrideComposeReadiness(false)
   , mForceCompositionTask(nullptr)
   , mCompositorScheduler(nullptr)
   , mAnimationStorage(nullptr)
   , mPaintTime(TimeDuration::Forever())
 #if defined(XP_WIN) || defined(MOZ_WIDGET_GTK)
   , mLastPluginUpdateLayerTreeId{0}
--- a/gfx/layers/ipc/LayerTransactionParent.cpp
+++ b/gfx/layers/ipc/LayerTransactionParent.cpp
@@ -56,16 +56,17 @@ LayerTransactionParent::LayerTransaction
   , mAnimStorage(aAnimStorage)
   , mId(aId)
   , mChildEpoch{0}
   , mParentEpoch{0}
   , mVsyncRate(aVsyncRate)
   , mPendingTransaction{0}
   , mDestroyed(false)
   , mIPCOpen(false)
+  , mUpdateHitTestingTree(false)
 {
   MOZ_ASSERT(mId.IsValid());
 }
 
 LayerTransactionParent::~LayerTransactionParent()
 {
 }
 
--- a/gfx/layers/ipc/ShadowLayers.cpp
+++ b/gfx/layers/ipc/ShadowLayers.cpp
@@ -60,16 +60,17 @@ typedef nsTArray<Edit> EditVector;
 typedef nsTHashtable<nsPtrHashKey<ShadowableLayer>> ShadowableLayerSet;
 typedef nsTArray<OpDestroy> OpDestroyVector;
 
 class Transaction
 {
 public:
   Transaction()
     : mTargetRotation(ROTATION_0)
+    , mTargetOrientation(dom::eScreenOrientation_None)
     , mOpen(false)
     , mRotationChanged(false)
   {}
 
   void Begin(const gfx::IntRect& aTargetBounds, ScreenRotation aRotation,
              dom::ScreenOrientationInternal aOrientation)
   {
     mOpen = true;
--- a/gfx/layers/mlgpu/ContainerLayerMLGPU.cpp
+++ b/gfx/layers/mlgpu/ContainerLayerMLGPU.cpp
@@ -18,17 +18,18 @@ namespace mozilla {
 namespace layers {
 
 using namespace gfx;
 
 ContainerLayerMLGPU::ContainerLayerMLGPU(LayerManagerMLGPU* aManager)
  : ContainerLayer(aManager, nullptr),
    LayerMLGPU(aManager),
    mInvalidateEntireSurface(false),
-   mSurfaceCopyNeeded(false)
+   mSurfaceCopyNeeded(false),
+   mView(nullptr)
 {
 }
 
 ContainerLayerMLGPU::~ContainerLayerMLGPU()
 {
   while (mFirstChild) {
     RemoveChild(mFirstChild);
   }
--- a/gfx/layers/mlgpu/LayerMLGPU.cpp
+++ b/gfx/layers/mlgpu/LayerMLGPU.cpp
@@ -15,16 +15,17 @@ namespace layers {
 
 using namespace gfx;
 
 uint64_t LayerMLGPU::sFrameKey = 0;
 
 LayerMLGPU::LayerMLGPU(LayerManagerMLGPU* aManager)
  : HostLayer(aManager),
    mFrameKey(0),
+   mComputedOpacity(0.0),
    mPrepared(false)
 {
 }
 
 /* static */ void
 LayerMLGPU::BeginFrame()
 {
   sFrameKey++;
--- a/gfx/layers/mlgpu/MLGDevice.cpp
+++ b/gfx/layers/mlgpu/MLGDevice.cpp
@@ -63,16 +63,17 @@ MLGSwapChain::ApplyNewInvalidRegion(nsIn
     mFrontBufferInvalid.OrWith(invalid);
     AL_LOG("Frontbuffer invalid region: %s\n", Stringify(mFrontBufferInvalid).c_str());
   }
   return true;
 }
 
 MLGDevice::MLGDevice()
  : mTopology(MLGPrimitiveTopology::Unknown),
+   mInitialized(false),
    mIsValid(false),
    mCanUseClearView(false),
    mCanUseConstantBufferOffsetBinding(false),
    mMaxConstantBufferBindSize(0)
 {
 }
 
 MLGDevice::~MLGDevice()
--- a/gfx/layers/mlgpu/RenderPassMLGPU.cpp
+++ b/gfx/layers/mlgpu/RenderPassMLGPU.cpp
@@ -564,16 +564,17 @@ TexturedRenderPass::AddClippedItem(Txn& 
       }
     }
   }
   return true;
 }
 
 SingleTexturePass::SingleTexturePass(FrameBuilder* aBuilder, const ItemInfo& aItem)
  : TexturedRenderPass(aBuilder, aItem),
+   mSamplerMode(SamplerMode::LinearClamp),
    mOpacity(1.0f)
 {
   SetDefaultGeometry(aItem);
 }
 
 bool
 SingleTexturePass::AddToPass(LayerMLGPU* aLayer, ItemInfo& aItem)
 {
@@ -672,17 +673,18 @@ SingleTexturePass::SetupPipeline()
       else
         mDevice->SetPixelShader(PixelShaderID::TexturedVertexRGB);
       break;
   }
 }
 
 ComponentAlphaPass::ComponentAlphaPass(FrameBuilder* aBuilder, const ItemInfo& aItem)
  : TexturedRenderPass(aBuilder, aItem),
-   mOpacity(1.0f)
+   mOpacity(1.0f),
+   mSamplerMode(SamplerMode::LinearClamp)
 {
   SetDefaultGeometry(aItem);
 }
 
 bool
 ComponentAlphaPass::AddToPass(LayerMLGPU* aLayer, ItemInfo& aItem)
 {
   PaintedLayerMLGPU* layer = aLayer->AsPaintedLayerMLGPU();
@@ -696,17 +698,17 @@ ComponentAlphaPass::AddToPass(LayerMLGPU
     {
       return false;
     }
   } else {
     mOpacity = layer->GetComputedOpacity();
     mSamplerMode = layer->GetSamplerMode();
     mTextureOnBlack = layer->GetTexture();
     mTextureOnWhite = layer->GetTextureOnWhite();
-  } 
+  }
 
   Txn txn(this);
 
   Info info(aItem, layer);
   if (!AddItems(txn, info, layer->GetDrawRects())) {
     return false;
   }
   return txn.Commit();
@@ -737,16 +739,17 @@ ComponentAlphaPass::SetupPipeline()
   }
 
   mDevice->SetSamplerMode(kDefaultSamplerSlot, mSamplerMode);
   mDevice->SetPSTextures(0, 2, textures);
 }
 
 VideoRenderPass::VideoRenderPass(FrameBuilder* aBuilder, const ItemInfo& aItem)
  : TexturedRenderPass(aBuilder, aItem),
+   mSamplerMode(SamplerMode::LinearClamp),
    mOpacity(1.0f)
 {
   SetDefaultGeometry(aItem);
 }
 
 bool
 VideoRenderPass::AddToPass(LayerMLGPU* aLayer, ItemInfo& aItem)
 {
--- a/gfx/layers/mlgpu/SharedBufferMLGPU.cpp
+++ b/gfx/layers/mlgpu/SharedBufferMLGPU.cpp
@@ -15,16 +15,17 @@ namespace layers {
 
 SharedBufferMLGPU::SharedBufferMLGPU(MLGDevice* aDevice, MLGBufferType aType, size_t aDefaultSize)
  : mDevice(aDevice),
    mType(aType),
    mDefaultSize(aDefaultSize),
    mCanUseOffsetAllocation(true),
    mCurrentPosition(0),
    mMaxSize(0),
+   mMap(),
    mMapped(false),
    mBytesUsedThisFrame(0),
    mNumSmallFrames(0)
 {
   MOZ_COUNT_CTOR(SharedBufferMLGPU);
 }
 
 SharedBufferMLGPU::~SharedBufferMLGPU()
@@ -188,17 +189,19 @@ VertexBufferSection::Init(MLGBuffer* aBu
 {
   mBuffer = aBuffer;
   mOffset = aOffset;
   mNumVertices = aNumVertices;
   mStride = aStride;
 }
 
 ConstantBufferSection::ConstantBufferSection()
- : mOffset(-1)
+ : mOffset(-1),
+   mNumBytes(0),
+   mNumItems(0)
 {}
 
 void
 ConstantBufferSection::Init(MLGBuffer* aBuffer, ptrdiff_t aOffset, size_t aBytes, size_t aNumItems)
 {
   mBuffer = aBuffer;
   mOffset = aOffset;
   mNumBytes = aBytes;
--- a/gfx/layers/mlgpu/TexturedLayerMLGPU.cpp
+++ b/gfx/layers/mlgpu/TexturedLayerMLGPU.cpp
@@ -166,17 +166,19 @@ TexturedLayerMLGPU::AssignBigImage(Frame
     // Since the layer tree is not holding this alive, we have to ask the
     // FrameBuilder to do it for us.
     aBuilder->RetainTemporaryLayer(item);
   } while (aIter->NextTile());
 }
 
 TempImageLayerMLGPU::TempImageLayerMLGPU(LayerManagerMLGPU* aManager)
  : ImageLayer(aManager, static_cast<HostLayer*>(this)),
-   TexturedLayerMLGPU(aManager)
+   TexturedLayerMLGPU(aManager),
+   mFilter(gfx::SamplingFilter::GOOD),
+   mIsOpaque(false)
 {
 }
 
 TempImageLayerMLGPU::~TempImageLayerMLGPU()
 {
 }
 
 void
--- a/gfx/layers/opengl/CompositingRenderTargetOGL.h
+++ b/gfx/layers/opengl/CompositingRenderTargetOGL.h
@@ -40,17 +40,21 @@ class CompositingRenderTargetOGL : publi
 {
   typedef mozilla::gl::GLContext GLContext;
 
   friend class CompositorOGL;
 
   // For lazy initialisation of the GL stuff
   struct InitParams
   {
-    InitParams() : mStatus(NO_PARAMS) {}
+    InitParams()
+      : mStatus(NO_PARAMS)
+      , mFBOTextureTarget(0)
+      , mInit(INIT_MODE_NONE)
+    {}
     InitParams(const gfx::IntSize& aSize,
                const gfx::IntSize& aPhySize,
                GLenum aFBOTextureTarget,
                SurfaceInitMode aInit)
       : mStatus(READY)
       , mSize(aSize)
       , mPhySize(aPhySize)
       , mFBOTextureTarget(aFBOTextureTarget)
--- a/gfx/layers/opengl/CompositorOGL.cpp
+++ b/gfx/layers/opengl/CompositorOGL.cpp
@@ -91,16 +91,17 @@ private:
   GLContext* mGL;
   GLuint mBufferHandle;
 };
 
 AsyncReadbackBufferOGL::AsyncReadbackBufferOGL(GLContext* aGL,
                                                const IntSize& aSize)
   : AsyncReadbackBuffer(aSize)
   , mGL(aGL)
+  , mBufferHandle(0)
 {
   size_t bufferByteCount = mSize.width * mSize.height * 4;
   mGL->fGenBuffers(1, &mBufferHandle);
 
   ScopedPackState scopedPackState(mGL);
   Bind();
   mGL->fBufferData(LOCAL_GL_PIXEL_PACK_BUFFER, bufferByteCount, nullptr,
                    LOCAL_GL_STREAM_READ);
@@ -175,16 +176,20 @@ CompositorOGL::BindBackdrop(ShaderProgra
 
 CompositorOGL::CompositorOGL(CompositorBridgeParent* aParent,
                              widget::CompositorWidget* aWidget,
                              int aSurfaceWidth, int aSurfaceHeight,
                              bool aUseExternalSurfaceSize)
   : Compositor(aWidget, aParent)
   , mWidgetSize(-1, -1)
   , mSurfaceSize(aSurfaceWidth, aSurfaceHeight)
+  , mFBOTextureTarget(0)
+  , mWindowRenderTarget(nullptr)
+  , mQuadVBO(0)
+  , mTriangleVBO(0)
   , mHasBGRA(0)
   , mUseExternalSurfaceSize(aUseExternalSurfaceSize)
   , mFrameInProgress(false)
   , mDestroyed(false)
   , mViewportSize(0, 0)
   , mCurrentProgram(nullptr)
 {
 #ifdef XP_DARWIN
--- a/gfx/layers/opengl/TextureHostOGL.h
+++ b/gfx/layers/opengl/TextureHostOGL.h
@@ -78,17 +78,18 @@ inline void ApplySamplingFilterToBoundTe
 /**
  * TextureSourceOGL provides the necessary API for CompositorOGL to composite
  * a TextureSource.
  */
 class TextureSourceOGL
 {
 public:
   TextureSourceOGL()
-    : mHasCachedSamplingFilter(false)
+    : mCachedSamplingFilter(gfx::SamplingFilter::GOOD)
+    , mHasCachedSamplingFilter(false)
   {}
 
   virtual bool IsValid() const = 0;
 
   virtual void BindTexture(GLenum aTextureUnit,
                            gfx::SamplingFilter aSamplingFilter) = 0;
 
   virtual gfx::IntSize GetSize() const = 0;
--- a/gfx/layers/wr/WebRenderCommandBuilder.cpp
+++ b/gfx/layers/wr/WebRenderCommandBuilder.cpp
@@ -112,17 +112,19 @@ struct BlobItemData
   Matrix mMatrix; // updated to track the current transform to device space
   Matrix4x4Flagged mTransform; // only used with nsDisplayTransform items to detect transform changes
   float mOpacity; // only used with nsDisplayOpacity items to detect change to opacity
 
   IntRect mImageRect;
   LayerIntPoint mGroupOffset;
 
   BlobItemData(DIGroup* aGroup, nsDisplayItem *aItem)
-    : mGroup(aGroup)
+    : mUsed(false)
+    , mGroup(aGroup)
+    , mOpacity(0.0)
   {
     mInvalid = false;
     mEmpty = false;
     mDisplayItemKey = aItem->GetPerFrameKey();
     AddFrame(aItem->Frame());
   }
 
 private:
@@ -216,17 +218,19 @@ TakeExternalSurfaces(WebRenderDrawEventR
     SharedSurfacesChild::Share(sharedSurface, aManager, aResources, key);
   }
 }
 
 struct DIGroup;
 struct Grouper
 {
   explicit Grouper(ClipManager& aClipManager)
-   : mClipManager(aClipManager)
+   : mAppUnitsPerDevPixel(0)
+   , mDisplayListBuilder(nullptr)
+   , mClipManager(aClipManager)
   {}
 
   int32_t mAppUnitsPerDevPixel;
   std::vector<nsDisplayItem*> mItemStack;
   nsDisplayListBuilder* mDisplayListBuilder;
   ClipManager& mClipManager;
   Matrix mTransform;
 
--- a/gfx/src/nsDeviceContext.cpp
+++ b/gfx/src/nsDeviceContext.cpp
@@ -42,17 +42,17 @@
 using namespace mozilla;
 using namespace mozilla::gfx;
 using mozilla::services::GetObserverService;
 using mozilla::widget::ScreenManager;
 
 class nsFontCache final : public nsIObserver
 {
 public:
-    nsFontCache() {}
+    nsFontCache(): mContext(nullptr) {}
 
     NS_DECL_ISUPPORTS
     NS_DECL_NSIOBSERVER
 
     void Init(nsDeviceContext* aContext);
     void Destroy();
 
     already_AddRefed<nsFontMetrics> GetMetricsFor(
--- a/gfx/src/nsRegion.h
+++ b/gfx/src/nsRegion.h
@@ -2176,16 +2176,19 @@ public:
     const nsRegion& mRegion;
     typename BandArray::const_iterator mCurrentBand;
     typename StripArray::const_iterator mCurrentStrip;
 
   public:
     explicit RectIterator(const nsRegion& aRegion)
       : mRegion(aRegion)
       , mCurrentBand(aRegion.mBands.begin())
+#ifndef DEBUG
+      , mCurrentStrip(nullptr)
+#endif
     {
       mIsDone = mRegion.mBounds.IsEmpty();
       if (mCurrentBand != aRegion.mBands.end()) {
         mCurrentStrip = mCurrentBand->mStrips.begin();
       }
     }
 
     bool Done() const { return mIsDone; }
--- a/gfx/thebes/PrintTargetSkPDF.cpp
+++ b/gfx/thebes/PrintTargetSkPDF.cpp
@@ -12,16 +12,17 @@
 namespace mozilla {
 namespace gfx {
 
 PrintTargetSkPDF::PrintTargetSkPDF(const IntSize& aSize,
                                    UniquePtr<SkWStream> aStream)
   : PrintTarget(/* not using cairo_surface_t */ nullptr, aSize)
   , mOStream(std::move(aStream))
   , mPageCanvas(nullptr)
+  , mRefCanvas(nullptr)
 {
 }
 
 PrintTargetSkPDF::~PrintTargetSkPDF()
 {
   Finish(); // ensure stream is flushed
 
   // Make sure mPDFDoc and mRefPDFDoc are destroyed before our member streams
--- a/gfx/thebes/gfxContext.h
+++ b/gfx/thebes/gfxContext.h
@@ -627,17 +627,18 @@ private:
     mozilla::gfx::Matrix mMatrix;
 };
 
 
 class DrawTargetAutoDisableSubpixelAntialiasing {
 public:
     typedef mozilla::gfx::DrawTarget DrawTarget;
 
-    DrawTargetAutoDisableSubpixelAntialiasing(DrawTarget *aDT, bool aDisable)
+    DrawTargetAutoDisableSubpixelAntialiasing(DrawTarget* aDT, bool aDisable) :
+      mSubpixelAntialiasingEnabled(false)
     {
         if (aDisable) {
             mDT = aDT;
             mSubpixelAntialiasingEnabled = mDT->GetPermitSubpixelAA();
             mDT->SetPermitSubpixelAA(false);
         }
     }
     ~DrawTargetAutoDisableSubpixelAntialiasing()
--- a/gfx/thebes/gfxFont.cpp
+++ b/gfx/thebes/gfxFont.cpp
@@ -816,16 +816,17 @@ gfxFont::gfxFont(const RefPtr<UnscaledFo
     mFontEntry(aFontEntry),
     mUnscaledFont(aUnscaledFont),
     mStyle(*aFontStyle),
     mAdjustedSize(0.0),
     mFUnitsConvFactor(-1.0f), // negative to indicate "not yet initialized"
     mAntialiasOption(anAAOption),
     mIsValid(true),
     mApplySyntheticBold(false),
+    mKerningEnabled(false),
     mMathInitialized(false)
 {
 #ifdef DEBUG_TEXT_RUN_STORAGE_METRICS
     ++gFontCount;
 #endif
     mKerningSet = HasFeatureSet(HB_TAG('k','e','r','n'), mKerningEnabled);
 }
 
--- a/gfx/thebes/gfxFontEntry.cpp
+++ b/gfx/thebes/gfxFontEntry.cpp
@@ -72,16 +72,17 @@ gfxFontEntry::gfxFontEntry() :
     mHasSpaceFeatures(false),
     mHasSpaceFeaturesKerning(false),
     mHasSpaceFeaturesNonKerning(false),
     mSkipDefaultFeatureSpaceCheck(false),
     mGraphiteSpaceContextualsInitialized(false),
     mHasGraphiteSpaceContextuals(false),
     mSpaceGlyphIsInvisible(false),
     mSpaceGlyphIsInvisibleInitialized(false),
+    mHasGraphiteTables(false),
     mCheckedForGraphiteTables(false),
     mHasCmapTable(false),
     mGrFaceInitialized(false),
     mCheckedForColorGlyph(false),
     mCheckedForVariationAxes(false)
 {
     memset(&mDefaultSubSpaceFeatures, 0, sizeof(mDefaultSubSpaceFeatures));
     memset(&mNonDefaultSubSpaceFeatures, 0, sizeof(mNonDefaultSubSpaceFeatures));
@@ -102,16 +103,17 @@ gfxFontEntry::gfxFontEntry(const nsAStri
     mHasSpaceFeatures(false),
     mHasSpaceFeaturesKerning(false),
     mHasSpaceFeaturesNonKerning(false),
     mSkipDefaultFeatureSpaceCheck(false),
     mGraphiteSpaceContextualsInitialized(false),
     mHasGraphiteSpaceContextuals(false),
     mSpaceGlyphIsInvisible(false),
     mSpaceGlyphIsInvisibleInitialized(false),
+    mHasGraphiteTables(false),
     mCheckedForGraphiteTables(false),
     mHasCmapTable(false),
     mGrFaceInitialized(false),
     mCheckedForColorGlyph(false),
     mCheckedForVariationAxes(false)
 {
     memset(&mDefaultSubSpaceFeatures, 0, sizeof(mDefaultSubSpaceFeatures));
     memset(&mNonDefaultSubSpaceFeatures, 0, sizeof(mNonDefaultSubSpaceFeatures));
--- a/gfx/thebes/gfxFontFamilyList.h
+++ b/gfx/thebes/gfxFontFamilyList.h
@@ -277,16 +277,17 @@ public:
     explicit FontFamilyList(const FontFamilyName& aName)
         : mFontlist(MakeNotNull<SharedFontList*>(aName))
         , mDefaultFontType(eFamily_none)
     {
     }
 
     explicit FontFamilyList(nsTArray<FontFamilyName>&& aNames)
         : mFontlist(MakeNotNull<SharedFontList*>(std::move(aNames)))
+        , mDefaultFontType(eFamily_none)
     {
     }
 
     FontFamilyList(const FontFamilyList& aOther)
         : mFontlist(aOther.mFontlist)
         , mDefaultFontType(aOther.mDefaultFontType)
     {
     }
--- a/gfx/thebes/gfxFontInfoLoader.h
+++ b/gfx/thebes/gfxFontInfoLoader.h
@@ -46,16 +46,17 @@ struct FontFaceData {
 class FontInfoData {
 public:
     NS_INLINE_DECL_THREADSAFE_REFCOUNTING(FontInfoData)
 
     FontInfoData(bool aLoadOtherNames,
                  bool aLoadFaceNames,
                  bool aLoadCmaps) :
         mCanceled(false),
+        mLoadStats(),
         mLoadOtherNames(aLoadOtherNames),
         mLoadFaceNames(aLoadFaceNames),
         mLoadCmaps(aLoadCmaps)
     {
         MOZ_COUNT_CTOR(FontInfoData);
     }
 
 protected:
--- a/gfx/thebes/gfxGlyphExtents.h
+++ b/gfx/thebes/gfxGlyphExtents.h
@@ -83,19 +83,28 @@ public:
     size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
     size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
 
 private:
     class HashEntry : public nsUint32HashKey {
     public:
         // When constructing a new entry in the hashtable, we'll leave this
         // blank. The caller of Put() will fill this in.
-        explicit HashEntry(KeyTypePointer aPtr) : nsUint32HashKey(aPtr) {}
-        HashEntry(const HashEntry& toCopy) : nsUint32HashKey(toCopy) {
-          x = toCopy.x; y = toCopy.y; width = toCopy.width; height = toCopy.height;
+        explicit HashEntry(KeyTypePointer aPtr)
+          : nsUint32HashKey(aPtr)
+          , x(0.0)
+          , y(0.0)
+          , width(0.0)
+          , height(0.0) {}
+        HashEntry(const HashEntry& toCopy)
+          : nsUint32HashKey(toCopy) {
+            x = toCopy.x;
+            y = toCopy.y;
+            width = toCopy.width;
+            height = toCopy.height;
         }
 
         float x, y, width, height;
     };
 
     enum { BLOCK_SIZE_BITS = 7, BLOCK_SIZE = 1 << BLOCK_SIZE_BITS }; // 128-glyph blocks
 
     class GlyphWidths {
--- a/gfx/thebes/gfxGraphiteShaper.cpp
+++ b/gfx/thebes/gfxGraphiteShaper.cpp
@@ -28,16 +28,17 @@ using namespace mozilla; // for AutoSwap
  * Creation and destruction; on deletion, release any font tables we're holding
  */
 
 gfxGraphiteShaper::gfxGraphiteShaper(gfxFont *aFont)
     : gfxFontShaper(aFont),
       mGrFace(mFont->GetFontEntry()->GetGrFace()),
       mGrFont(nullptr), mFallbackToSmallCaps(false)
 {
+    mCallbackData.mDrawTarget = nullptr;
     mCallbackData.mFont = aFont;
 }
 
 gfxGraphiteShaper::~gfxGraphiteShaper()
 {
     if (mGrFont) {
         gr_font_destroy(mGrFont);
     }
--- a/gfx/thebes/gfxHarfBuzzShaper.cpp
+++ b/gfx/thebes/gfxHarfBuzzShaper.cpp
@@ -38,16 +38,17 @@ using namespace mozilla::unicode; // for
  * Creation and destruction; on deletion, release any font tables we're holding
  */
 
 gfxHarfBuzzShaper::gfxHarfBuzzShaper(gfxFont *aFont)
     : gfxFontShaper(aFont),
       mHBFace(aFont->GetFontEntry()->GetHBFace()),
       mHBFont(nullptr),
       mBuffer(nullptr),
+      mCallbackData(),
       mKernTable(nullptr),
       mHmtxTable(nullptr),
       mVmtxTable(nullptr),
       mVORGTable(nullptr),
       mLocaTable(nullptr),
       mGlyfTable(nullptr),
       mCmapTable(nullptr),
       mCmapFormat(-1),
@@ -55,16 +56,17 @@ gfxHarfBuzzShaper::gfxHarfBuzzShaper(gfx
       mUVSTableOffset(0),
       mNumLongHMetrics(0),
       mNumLongVMetrics(0),
       mDefaultVOrg(-1.0),
       mUseFontGetGlyph(aFont->ProvidesGetGlyph()),
       mUseFontGlyphWidths(aFont->ProvidesGlyphWidths()),
       mInitialized(false),
       mVerticalInitialized(false),
+      mUseVerticalPresentationForms(false),
       mLoadedLocaGlyf(false),
       mLocaLongOffsets(false)
 {
 }
 
 gfxHarfBuzzShaper::~gfxHarfBuzzShaper()
 {
     if (mCmapTable) {
--- a/gfx/thebes/gfxImageSurface.cpp
+++ b/gfx/thebes/gfxImageSurface.cpp
@@ -17,16 +17,17 @@
 #include <algorithm>
 
 using namespace mozilla;
 using namespace mozilla::gfx;
 
 gfxImageSurface::gfxImageSurface()
   : mSize(0, 0),
     mOwnsData(false),
+    mData(nullptr),
     mFormat(SurfaceFormat::UNKNOWN),
     mStride(0)
 {
 }
 
 void
 gfxImageSurface::InitFromSurface(cairo_surface_t *csurf)
 {
--- a/gfx/thebes/gfxMacPlatformFontList.mm
+++ b/gfx/thebes/gfxMacPlatformFontList.mm
@@ -379,17 +379,18 @@ MacOSFontEntry::MacOSFontEntry(const nsA
       mHasVariations(false),
       mHasVariationsInitialized(false),
       mHasAATSmallCaps(false),
       mHasAATSmallCapsInitialized(false),
       mCheckedForTracking(false),
       mCheckedForOpszAxis(false),
       mTrakTable(nullptr),
       mTrakValues(nullptr),
-      mTrakSizeTable(nullptr)
+      mTrakSizeTable(nullptr),
+      mNumTrakSizes(0)
 {
     mWeightRange = aWeight;
 }
 
 MacOSFontEntry::MacOSFontEntry(const nsAString& aPostscriptName,
                                CGFontRef aFontRef,
                                WeightRange aWeight,
                                StretchRange aStretch,
@@ -406,17 +407,18 @@ MacOSFontEntry::MacOSFontEntry(const nsA
       mHasVariations(false),
       mHasVariationsInitialized(false),
       mHasAATSmallCaps(false),
       mHasAATSmallCapsInitialized(false),
       mCheckedForTracking(false),
       mCheckedForOpszAxis(false),
       mTrakTable(nullptr),
       mTrakValues(nullptr),
-      mTrakSizeTable(nullptr)
+      mTrakSizeTable(nullptr),
+      mNumTrakSizes(0)
 {
     mFontRef = aFontRef;
     mFontRefInitialized = true;
     ::CFRetain(mFontRef);
 
     mWeightRange = aWeight;
     mStretchRange = aStretch;
     mFixedPitch = false; // xxx - do we need this for downloaded fonts?
--- a/gfx/thebes/gfxMathTable.cpp
+++ b/gfx/thebes/gfxMathTable.cpp
@@ -9,16 +9,17 @@
 
 #define FloatToFixed(f) (65536 * (f))
 #define FixedToFloat(f) ((f) * (1.0 / 65536.0))
 
 using namespace mozilla;
 
 gfxMathTable::gfxMathTable(hb_face_t *aFace, gfxFloat aSize)
 {
+  mMathVariantCache.vertical = false;
   mHBFont = hb_font_create(aFace);
   if (mHBFont) {
     hb_font_set_ppem(mHBFont, aSize, aSize);
     uint32_t scale = FloatToFixed(aSize);
     hb_font_set_scale(mHBFont, scale, scale);
   }
 
   mMathVariantCache.glyphID = 0;
--- a/gfx/thebes/gfxPlatform.cpp
+++ b/gfx/thebes/gfxPlatform.cpp
@@ -482,17 +482,18 @@ MemoryPressureObserver::Observe(nsISuppo
     gfxGradientCache::PurgeAllCaches();
 
     gfxPlatform::PurgeSkiaFontCache();
     gfxPlatform::GetPlatform()->PurgeSkiaGPUCache();
     return NS_OK;
 }
 
 gfxPlatform::gfxPlatform()
-  : mAzureCanvasBackendCollector(this, &gfxPlatform::GetAzureBackendInfo)
+  : mHasVariationFontSupport(false)
+  , mAzureCanvasBackendCollector(this, &gfxPlatform::GetAzureBackendInfo)
   , mApzSupportCollector(this, &gfxPlatform::GetApzSupportInfo)
   , mTilesInfoCollector(this, &gfxPlatform::GetTilesSupportInfo)
   , mCompositorBackend(layers::LayersBackend::LAYERS_NONE)
   , mScreenDepth(0)
 {
     mAllowDownloadableFonts = UNINITIALIZED_VALUE;
     mFallbackUsesCmaps = UNINITIALIZED_VALUE;
 
--- a/gfx/thebes/gfxSkipChars.h
+++ b/gfx/thebes/gfxSkipChars.h
@@ -199,17 +199,21 @@ public:
           mCurrentRangeIndex(aIterator.mCurrentRangeIndex),
           mOriginalStringToSkipCharsOffset(aIterator.mOriginalStringToSkipCharsOffset)
     { }
 
     /**
      * The empty constructor creates an object that is useless until it is assigned.
      */
     gfxSkipCharsIterator()
-        : mSkipChars(nullptr)
+        : mSkipChars(nullptr),
+          mOriginalStringOffset(0),
+          mSkippedStringOffset(0),
+          mCurrentRangeIndex(0),
+          mOriginalStringToSkipCharsOffset(0)
     { }
 
     /**
      * Return true if this iterator is properly initialized and usable.
      */
     bool IsInitialized()
     {
         return mSkipChars != nullptr;
--- a/gfx/thebes/gfxUserFontSet.cpp
+++ b/gfx/thebes/gfxUserFontSet.cpp
@@ -915,16 +915,17 @@ void
 gfxUserFontEntry::GetUserFontSets(nsTArray<gfxUserFontSet*>& aResult)
 {
     aResult.Clear();
     aResult.AppendElement(mFontSet);
 }
 
 gfxUserFontSet::gfxUserFontSet()
     : mFontFamilies(4),
+      mRebuildGeneration(0),
       mLocalRulesUsed(false),
       mRebuildLocalRules(false),
       mDownloadCount(0),
       mDownloadSize(0)
 {
     IncrementGeneration(true);
     gfxPlatformFontList* fp = gfxPlatformFontList::PlatformFontList();
     if (fp) {
--- a/gfx/webrender_bindings/RenderBufferTextureHost.cpp
+++ b/gfx/webrender_bindings/RenderBufferTextureHost.cpp
@@ -11,16 +11,20 @@
 
 namespace mozilla {
 namespace wr {
 
 RenderBufferTextureHost::RenderBufferTextureHost(uint8_t* aBuffer,
                                                  const layers::BufferDescriptor& aDescriptor)
   : mBuffer(aBuffer)
   , mDescriptor(aDescriptor)
+  , mMap()
+  , mYMap()
+  , mCbMap()
+  , mCrMap()
   , mLocked(false)
 {
   MOZ_COUNT_CTOR_INHERITED(RenderBufferTextureHost, RenderTextureHost);
 
   switch (mDescriptor.type()) {
     case layers::BufferDescriptor::TYCbCrDescriptor: {
       const layers::YCbCrDescriptor& ycbcr = mDescriptor.get_YCbCrDescriptor();
       mSize = ycbcr.ySize();
--- a/gfx/webrender_bindings/RenderSharedSurfaceTextureHost.cpp
+++ b/gfx/webrender_bindings/RenderSharedSurfaceTextureHost.cpp
@@ -10,16 +10,17 @@
 #include "mozilla/layers/ImageDataSerializer.h"
 #include "mozilla/layers/SourceSurfaceSharedData.h"
 
 namespace mozilla {
 namespace wr {
 
 RenderSharedSurfaceTextureHost::RenderSharedSurfaceTextureHost(gfx::SourceSurfaceSharedDataWrapper* aSurface)
   : mSurface(aSurface)
+  , mMap()
   , mLocked(false)
 {
   MOZ_COUNT_CTOR_INHERITED(RenderSharedSurfaceTextureHost, RenderTextureHost);
   MOZ_ASSERT(aSurface);
 }
 
 RenderSharedSurfaceTextureHost::~RenderSharedSurfaceTextureHost()
 {