Backed out 2 changesets (bug 1435938) for rusttest failures on linux. CLOSED TREE
authorCsoregi Natalia <ncsoregi@mozilla.com>
Fri, 09 Feb 2018 18:21:54 +0200
changeset 403191 05855884fc04
parent 403190 55d20d1f137a
child 403192 a96699a3f15a
push id33416
push userarchaeopteryx@coole-files.de
push dateFri, 09 Feb 2018 22:32:39 +0000
treeherdermozilla-central@c2cddb0cbb20 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
bugs1435938
milestone60.0a1
backs outb24907f82186
db4018b4b695
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
Backed out 2 changesets (bug 1435938) for rusttest failures on linux. CLOSED TREE Backed out changeset b24907f82186 (bug 1435938) Backed out changeset db4018b4b695 (bug 1435938)
gfx/2d/2D.h
gfx/2d/CaptureCommandList.h
gfx/2d/DrawCommand.h
gfx/2d/DrawCommands.h
gfx/2d/DrawTargetCapture.cpp
gfx/2d/DrawTargetCapture.h
gfx/2d/Logging.h
gfx/layers/PaintThread.cpp
gfx/thebes/gfxPrefs.h
modules/libpref/init/all.js
--- a/gfx/2d/2D.h
+++ b/gfx/2d/2D.h
@@ -1442,18 +1442,16 @@ protected:
   SurfaceFormat mFormat;
 };
 
 class DrawTargetCapture : public DrawTarget
 {
 public:
   virtual bool IsCaptureDT() const override { return true; }
 
-  virtual void Dump() = 0;
-
   /**
    * Returns true if the recording only contains FillGlyph calls with
    * a single font and color. Returns the list of Glyphs along with
    * the font and color as outparams if so.
    */
   virtual bool ContainsOnlyColoredGlyphs(RefPtr<ScaledFont>& aScaledFont,
                                          Color& aColor,
                                          std::vector<Glyph>& aGlyphs) = 0;
--- a/gfx/2d/CaptureCommandList.h
+++ b/gfx/2d/CaptureCommandList.h
@@ -7,17 +7,16 @@
 #ifndef mozilla_gfx_2d_CaptureCommandList_h
 #define mozilla_gfx_2d_CaptureCommandList_h
 
 #include "mozilla/Move.h"
 #include "mozilla/PodOperations.h"
 #include <vector>
 
 #include "DrawCommand.h"
-#include "Logging.h"
 
 namespace mozilla {
 namespace gfx {
 
 class CaptureCommandList
 {
 public:
   CaptureCommandList()
@@ -83,25 +82,16 @@ public:
     }
 
   private:
     CaptureCommandList& mParent;
     uint8_t* mCurrent;
     uint8_t* mEnd;
   };
 
-  void Log(TreeLog& aStream)
-  {
-    for (iterator iter(*this); !iter.Done(); iter.Next()) {
-      DrawingCommand* cmd = iter.Get();
-      cmd->Log(aStream);
-      aStream << "\n";
-    }
-  }
-
 private:
   CaptureCommandList(const CaptureCommandList& aOther) = delete;
   void operator =(const CaptureCommandList& aOther) = delete;
 
 private:
   std::vector<uint8_t> mStorage;
   DrawingCommand* mLastCommand;
 };
--- a/gfx/2d/DrawCommand.h
+++ b/gfx/2d/DrawCommand.h
@@ -9,17 +9,16 @@
 
 #include <math.h>
 
 #include "2D.h"
 #include "Blur.h"
 #include "Filters.h"
 #include <vector>
 #include "FilterNodeCapture.h"
-#include "Logging.h"
 
 namespace mozilla {
 namespace gfx {
 
 class CaptureCommandList;
 
 enum class CommandType : int8_t {
   DRAWSURFACE = 0,
@@ -51,17 +50,16 @@ enum class CommandType : int8_t {
 class DrawingCommand
 {
 public:
   virtual ~DrawingCommand() {}
 
   virtual void ExecuteOnDT(DrawTarget* aDT, const Matrix* aTransform = nullptr) const = 0;
   virtual bool GetAffectedRect(Rect& aDeviceRect, const Matrix& aTransform) const { return false; }
   virtual void CloneInto(CaptureCommandList* aList) = 0;
-  virtual void Log(TreeLog& aLog) const = 0;
 
   CommandType GetType() { return mType; }
 
 protected:
   explicit DrawingCommand(CommandType aType)
     : mType(aType)
   {
   }
--- a/gfx/2d/DrawCommands.h
+++ b/gfx/2d/DrawCommands.h
@@ -11,17 +11,16 @@
 
 #include "2D.h"
 #include "Blur.h"
 #include "Filters.h"
 #include <vector>
 #include "CaptureCommandList.h"
 #include "DrawCommand.h"
 #include "FilterNodeCapture.h"
-#include "Logging.h"
 
 namespace mozilla {
 namespace gfx {
 
 #define CLONE_INTO(Type) new (aList->Append<Type>()) Type
 
 class StrokeOptionsCommand : public DrawingCommand
 {
@@ -77,26 +76,16 @@ public:
     }
   }
 
   ~StoredPattern()
   {
     reinterpret_cast<Pattern*>(mPattern)->~Pattern();
   }
 
-  Pattern* Get()
-  {
-    return reinterpret_cast<Pattern*>(mPattern);
-  }
-
-  const Pattern* Get() const
-  {
-    return reinterpret_cast<const Pattern*>(mPattern);
-  }
-
   operator Pattern&()
   {
     return *reinterpret_cast<Pattern*>(mPattern);
   }
 
   operator const Pattern&() const
   {
     return *reinterpret_cast<const Pattern*>(mPattern);
@@ -141,26 +130,16 @@ public:
     CLONE_INTO(DrawSurfaceCommand)(mSurface, mDest, mSource, mSurfOptions, mOptions);
   }
 
   virtual void ExecuteOnDT(DrawTarget* aDT, const Matrix*) const override
   {
     aDT->DrawSurface(mSurface, mDest, mSource, mSurfOptions, mOptions);
   }
 
-  void Log(TreeLog& aStream) const override
-  {
-    aStream << "[DrawSurface surf=" << mSurface;
-    aStream << " dest=" << mDest;
-    aStream << " src=" << mSource;
-    aStream << " surfOpt=" << mSurfOptions;
-    aStream << " opt=" << mOptions;
-    aStream << "]";
-  }
-
   static const bool AffectsSnapshot = true;
   static const CommandType Type = CommandType::DRAWSURFACE;
 
 private:
   RefPtr<SourceSurface> mSurface;
   Rect mDest;
   Rect mSource;
   DrawSurfaceOptions mSurfOptions;
@@ -191,27 +170,16 @@ public:
     CLONE_INTO(DrawSurfaceWithShadowCommand)(mSurface, mDest, mColor, mOffset, mSigma, mOperator);
   }
 
   virtual void ExecuteOnDT(DrawTarget* aDT, const Matrix*) const override
   {
     aDT->DrawSurfaceWithShadow(mSurface, mDest, mColor, mOffset, mSigma, mOperator);
   }
 
-  void Log(TreeLog& aStream) const override
-  {
-    aStream << "[DrawSurfaceWithShadow surf=" << mSurface;
-    aStream << " dest=" << mDest;
-    aStream << " color=" << mColor;
-    aStream << " offset=" << mOffset;
-    aStream << " sigma=" << mSigma;
-    aStream << " op=" << mOperator;
-    aStream << "]";
-  }
-
   static const bool AffectsSnapshot = true;
   static const CommandType Type = CommandType::DRAWSURFACEWITHSHADOW;
 
 private:
   RefPtr<SourceSurface> mSurface;
   Point mDest;
   Color mColor;
   Point mOffset;
@@ -239,25 +207,16 @@ public:
   {
     RefPtr<FilterNode> filter = mFilter;
     if (mFilter->GetBackendType() == FilterBackend::FILTER_BACKEND_CAPTURE) {
       filter = static_cast<FilterNodeCapture*>(filter.get())->Validate(aDT);
     }
     aDT->DrawFilter(filter, mSourceRect, mDestPoint, mOptions);
   }
 
-  void Log(TreeLog& aStream) const override
-  {
-    aStream << "[DrawFilter surf=" << mFilter;
-    aStream << " src=" << mSourceRect;
-    aStream << " dest=" << mDestPoint;
-    aStream << " opt=" << mOptions;
-    aStream << "]";
-  }
-
   static const bool AffectsSnapshot = true;
   static const CommandType Type = CommandType::DRAWFILTER;
 
 private:
   RefPtr<FilterNode> mFilter;
   Rect mSourceRect;
   Point mDestPoint;
   DrawOptions mOptions;
@@ -277,21 +236,16 @@ public:
     CLONE_INTO(ClearRectCommand)(mRect);
   }
 
   virtual void ExecuteOnDT(DrawTarget* aDT, const Matrix*) const override
   {
     aDT->ClearRect(mRect);
   }
 
-  void Log(TreeLog& aStream) const override
-  {
-    aStream << "[ClearRect rect=" << mRect << "]";
-  }
-
   static const bool AffectsSnapshot = true;
   static const CommandType Type = CommandType::CLEARRECT;
 
 private:
   Rect mRect;
 };
 
 class CopySurfaceCommand : public DrawingCommand
@@ -317,24 +271,16 @@ public:
     MOZ_ASSERT(!aTransform || !aTransform->HasNonIntegerTranslation());
     Point dest(Float(mDestination.x), Float(mDestination.y));
     if (aTransform) {
       dest = aTransform->TransformPoint(dest);
     }
     aDT->CopySurface(mSurface, mSourceRect, IntPoint(uint32_t(dest.x), uint32_t(dest.y)));
   }
 
-  void Log(TreeLog& aStream) const override
-  {
-    aStream << "[CopySurface surf=" << mSurface;
-    aStream << " src=" << mSourceRect;
-    aStream << " dest=" << mDestination;
-    aStream << "]";
-  }
-
   static const bool AffectsSnapshot = true;
   static const CommandType Type = CommandType::COPYSURFACE;
 
 private:
   RefPtr<SourceSurface> mSurface;
   IntRect mSourceRect;
   IntPoint mDestination;
 };
@@ -363,24 +309,16 @@ public:
   }
 
   bool GetAffectedRect(Rect& aDeviceRect, const Matrix& aTransform) const override
   {
     aDeviceRect = aTransform.TransformBounds(mRect);
     return true;
   }
 
-  void Log(TreeLog& aStream) const override
-  {
-    aStream << "[FillRect rect=" << mRect;
-    aStream << " pattern=" << mPattern.Get();
-    aStream << " opt=" << mOptions;
-    aStream << "]";
-  }
-
   static const bool AffectsSnapshot = true;
   static const CommandType Type = CommandType::FILLRECT;
 
 private:
   Rect mRect;
   StoredPattern mPattern;
   DrawOptions mOptions;
 };
@@ -404,24 +342,16 @@ public:
     CLONE_INTO(StrokeRectCommand)(mRect, mPattern, mStrokeOptions, mOptions);
   }
 
   virtual void ExecuteOnDT(DrawTarget* aDT, const Matrix*) const override
   {
     aDT->StrokeRect(mRect, mPattern, mStrokeOptions, mOptions);
   }
 
-  void Log(TreeLog& aStream) const override
-  {
-    aStream << "[StrokeRect rect=" << mRect;
-    aStream << " pattern=" << mPattern.Get();
-    aStream << " opt=" << mOptions;
-    aStream << "]";
-  }
-
   static const bool AffectsSnapshot = true;
   static const CommandType Type = CommandType::STROKERECT;
 
 private:
   Rect mRect;
   StoredPattern mPattern;
   DrawOptions mOptions;
 };
@@ -447,25 +377,16 @@ public:
     CLONE_INTO(StrokeLineCommand)(mStart, mEnd, mPattern, mStrokeOptions, mOptions);
   }
 
   virtual void ExecuteOnDT(DrawTarget* aDT, const Matrix*) const override
   {
     aDT->StrokeLine(mStart, mEnd, mPattern, mStrokeOptions, mOptions);
   }
 
-  void Log(TreeLog& aStream) const override
-  {
-    aStream << "[StrokeLine start=" << mStart;
-    aStream << " end=" << mEnd;
-    aStream << " pattern=" << mPattern.Get();
-    aStream << " opt=" << mOptions;
-    aStream << "]";
-  }
-
   static const bool AffectsSnapshot = true;
   static const CommandType Type = CommandType::STROKELINE;
 
 private:
   Point mStart;
   Point mEnd;
   StoredPattern mPattern;
   DrawOptions mOptions;
@@ -495,24 +416,16 @@ public:
   }
 
   bool GetAffectedRect(Rect& aDeviceRect, const Matrix& aTransform) const override
   {
     aDeviceRect = mPath->GetBounds(aTransform);
     return true;
   }
 
-  void Log(TreeLog& aStream) const override
-  {
-    aStream << "[FillCommand path=" << mPath;
-    aStream << " pattern=" << mPattern.Get();
-    aStream << " opt=" << mOptions;
-    aStream << "]";
-  }
-
   static const bool AffectsSnapshot = true;
   static const CommandType Type = CommandType::FILL;
 
 private:
   RefPtr<Path> mPath;
   StoredPattern mPattern;
   DrawOptions mOptions;
 };
@@ -583,24 +496,16 @@ public:
   }
 
   bool GetAffectedRect(Rect& aDeviceRect, const Matrix& aTransform) const override
   {
     aDeviceRect = PathExtentsToMaxStrokeExtents(mStrokeOptions, mPath->GetBounds(aTransform), aTransform);
     return true;
   }
 
-  void Log(TreeLog& aStream) const override
-  {
-    aStream << "[Stroke path=" << mPath;
-    aStream << " pattern=" << mPattern.Get();
-    aStream << " opt=" << mOptions;
-    aStream << "]";
-  }
-
   static const bool AffectsSnapshot = true;
   static const CommandType Type = CommandType::STROKE;
 
 private:
   RefPtr<Path> mPath;
   StoredPattern mPattern;
   DrawOptions mOptions;
 };
@@ -634,25 +539,16 @@ public:
   virtual void ExecuteOnDT(DrawTarget* aDT, const Matrix*) const override
   {
     GlyphBuffer buf;
     buf.mNumGlyphs = mGlyphs.size();
     buf.mGlyphs = &mGlyphs.front();
     aDT->FillGlyphs(mFont, buf, mPattern, mOptions);
   }
 
-  void Log(TreeLog& aStream) const override
-  {
-    aStream << "[FillGlyphs font=" << mFont;
-    aStream << " glyphCount=" << mGlyphs.size();
-    aStream << " pattern=" << mPattern.Get();
-    aStream << " opt=" << mOptions;
-    aStream << "]";
-  }
-
   static const bool AffectsSnapshot = true;
   static const CommandType Type = CommandType::FILLGLYPHS;
 
 private:
   RefPtr<ScaledFont> mFont;
   std::vector<Glyph> mGlyphs;
   StoredPattern mPattern;
   DrawOptions mOptions;
@@ -688,25 +584,16 @@ public:
   virtual void ExecuteOnDT(DrawTarget* aDT, const Matrix*) const override
   {
     GlyphBuffer buf;
     buf.mNumGlyphs = mGlyphs.size();
     buf.mGlyphs = &mGlyphs.front();
     aDT->StrokeGlyphs(mFont, buf, mPattern, mStrokeOptions, mOptions);
   }
 
-  void Log(TreeLog& aStream) const override
-  {
-    aStream << "[StrokeGlyphs font=" << mFont;
-    aStream << " glyphCount=" << mGlyphs.size();
-    aStream << " pattern=" << mPattern.Get();
-    aStream << " opt=" << mOptions;
-    aStream << "]";
-  }
-
   static const bool AffectsSnapshot = true;
   static const CommandType Type = CommandType::STROKEGLYPHS;
 
 private:
   RefPtr<ScaledFont> mFont;
   std::vector<Glyph> mGlyphs;
   StoredPattern mPattern;
   DrawOptions mOptions;
@@ -730,24 +617,16 @@ public:
     CLONE_INTO(MaskCommand)(mSource, mMask, mOptions);
   }
 
   virtual void ExecuteOnDT(DrawTarget* aDT, const Matrix*) const override
   {
     aDT->Mask(mSource, mMask, mOptions);
   }
 
-  void Log(TreeLog& aStream) const override
-  {
-    aStream << "[Mask source=" << mSource.Get();
-    aStream << " mask=" << mMask.Get();
-    aStream << " opt=" << mOptions;
-    aStream << "]";
-  }
-
   static const bool AffectsSnapshot = true;
   static const CommandType Type = CommandType::MASK;
 
 private:
   StoredPattern mSource;
   StoredPattern mMask;
   DrawOptions mOptions;
 };
@@ -772,25 +651,16 @@ public:
     CLONE_INTO(MaskSurfaceCommand)(mSource, mMask, mOffset, mOptions);
   }
 
   virtual void ExecuteOnDT(DrawTarget* aDT, const Matrix*) const override
   {
     aDT->MaskSurface(mSource, mMask, mOffset, mOptions);
   }
 
-  void Log(TreeLog& aStream) const override
-  {
-    aStream << "[Mask source=" << mSource.Get();
-    aStream << " mask=" << mMask;
-    aStream << " offset=" << &mOffset;
-    aStream << " opt=" << mOptions;
-    aStream << "]";
-  }
-
   static const bool AffectsSnapshot = true;
   static const CommandType Type = CommandType::MASKSURFACE;
 
 private:
   StoredPattern mSource;
   RefPtr<SourceSurface> mMask;
   Point mOffset;
   DrawOptions mOptions;
@@ -810,21 +680,16 @@ public:
     CLONE_INTO(PushClipCommand)(mPath);
   }
 
   virtual void ExecuteOnDT(DrawTarget* aDT, const Matrix*) const override
   {
     aDT->PushClip(mPath);
   }
 
-  void Log(TreeLog& aStream) const override
-  {
-    aStream << "[PushClip path=" << mPath << "]";
-  }
-
   static const bool AffectsSnapshot = false;
   static const CommandType Type = CommandType::PUSHCLIP;
 
 private:
   RefPtr<Path> mPath;
 };
 
 class PushClipRectCommand : public DrawingCommand
@@ -841,21 +706,16 @@ public:
     CLONE_INTO(PushClipRectCommand)(mRect);
   }
 
   virtual void ExecuteOnDT(DrawTarget* aDT, const Matrix*) const override
   {
     aDT->PushClipRect(mRect);
   }
 
-  void Log(TreeLog& aStream) const override
-  {
-    aStream << "[PushClipRect rect=" << mRect << "]";
-  }
-
   static const bool AffectsSnapshot = false;
   static const CommandType Type = CommandType::PUSHCLIPRECT;
 
 private:
   Rect mRect;
 };
 
 class PushLayerCommand : public DrawingCommand
@@ -883,27 +743,16 @@ public:
   }
 
   virtual void ExecuteOnDT(DrawTarget* aDT, const Matrix*) const override
   {
     aDT->PushLayer(mOpaque, mOpacity, mMask,
                    mMaskTransform, mBounds, mCopyBackground);
   }
 
-  void Log(TreeLog& aStream) const override
-  {
-    aStream << "[PushLayer opaque=" << mOpaque;
-    aStream << " opacity=" << mOpacity;
-    aStream << " mask=" << mMask;
-    aStream << " maskTransform=" << mMaskTransform;
-    aStream << " bounds=" << mBounds;
-    aStream << " copyBackground=" << mCopyBackground;
-    aStream << "]";
-  }
-
   static const bool AffectsSnapshot = false;
   static const CommandType Type = CommandType::PUSHLAYER;
 
 private:
   bool mOpaque;
   float mOpacity;
   RefPtr<SourceSurface> mMask;
   Matrix mMaskTransform;
@@ -924,21 +773,16 @@ public:
     CLONE_INTO(PopClipCommand)();
   }
 
   virtual void ExecuteOnDT(DrawTarget* aDT, const Matrix*) const override
   {
     aDT->PopClip();
   }
 
-  void Log(TreeLog& aStream) const override
-  {
-    aStream << "[PopClip]";
-  }
-
   static const bool AffectsSnapshot = false;
   static const CommandType Type = CommandType::POPCLIP;
 };
 
 class PopLayerCommand : public DrawingCommand
 {
 public:
   PopLayerCommand()
@@ -951,21 +795,16 @@ public:
     CLONE_INTO(PopLayerCommand)();
   }
 
   virtual void ExecuteOnDT(DrawTarget* aDT, const Matrix*) const override
   {
     aDT->PopLayer();
   }
 
-  void Log(TreeLog& aStream) const override
-  {
-    aStream << "[PopLayer]";
-  }
-
   static const bool AffectsSnapshot = true;
   static const CommandType Type = CommandType::POPLAYER;
 };
 
 class SetTransformCommand : public DrawingCommand
 {
   friend class DrawTargetCaptureImpl;
 public:
@@ -984,21 +823,16 @@ public:
   {
     if (aMatrix) {
       aDT->SetTransform(mTransform * (*aMatrix));
     } else {
       aDT->SetTransform(mTransform);
     }
   }
 
-  void Log(TreeLog& aStream) const override
-  {
-    aStream << "[SetTransform transform=" << mTransform << "]";
-  }
-
   static const bool AffectsSnapshot = false;
   static const CommandType Type = CommandType::SETTRANSFORM;
 
 private:
   Matrix mTransform;
 };
 
 class SetPermitSubpixelAACommand : public DrawingCommand
@@ -1016,21 +850,16 @@ public:
     CLONE_INTO(SetPermitSubpixelAACommand)(mPermitSubpixelAA);
   }
 
   virtual void ExecuteOnDT(DrawTarget* aDT, const Matrix* aMatrix) const override
   {
     aDT->SetPermitSubpixelAA(mPermitSubpixelAA);
   }
 
-  void Log(TreeLog& aStream) const override
-  {
-    aStream << "[SetPermitSubpixelAA permitSubpixelAA=" << mPermitSubpixelAA << "]";
-  }
-
   static const bool AffectsSnapshot = false;
   static const CommandType Type = CommandType::SETPERMITSUBPIXELAA;
 
 private:
   bool mPermitSubpixelAA;
 };
 
 class FlushCommand : public DrawingCommand
@@ -1046,21 +875,16 @@ public:
     CLONE_INTO(FlushCommand)();
   }
 
   virtual void ExecuteOnDT(DrawTarget* aDT, const Matrix*) const override
   {
     aDT->Flush();
   }
 
-  void Log(TreeLog& aStream) const override
-  {
-    aStream << "[Flush]";
-  }
-
   static const bool AffectsSnapshot = false;
   static const CommandType Type = CommandType::FLUSH;
 };
 
 class BlurCommand : public DrawingCommand
 {
 public:
   explicit BlurCommand(const AlphaBoxBlur& aBlur)
@@ -1073,21 +897,16 @@ public:
     CLONE_INTO(BlurCommand)(mBlur);
   }
 
   virtual void ExecuteOnDT(DrawTarget* aDT, const Matrix*) const override
   {
     aDT->Blur(mBlur);
   }
 
-  void Log(TreeLog& aStream) const override
-  {
-    aStream << "[Blur]";
-  }
-
   static const bool AffectsSnapshot = true;
   static const CommandType Type = CommandType::BLUR;
 
 private:
   AlphaBoxBlur mBlur;
 };
 
 #undef CLONE_INTO
--- a/gfx/2d/DrawTargetCapture.cpp
+++ b/gfx/2d/DrawTargetCapture.cpp
@@ -438,20 +438,10 @@ DrawTargetCaptureImpl::CreateFilter(Filt
 {
   if (mRefDT->GetBackendType() == BackendType::DIRECT2D1_1) {
     return MakeRefPtr<FilterNodeCapture>(aType).forget();
   } else {
     return mRefDT->CreateFilter(aType);
   }
 }
 
-void
-DrawTargetCaptureImpl::Dump()
-{
-  TreeLog output;
-  output << "DrawTargetCapture(" << (void*)(this) << ")\n";
-  TreeAutoIndent indent(output);
-  mCommands.Log(output);
-  output << "\n";
-}
-
 } // namespace gfx
 } // namespace mozilla
--- a/gfx/2d/DrawTargetCapture.h
+++ b/gfx/2d/DrawTargetCapture.h
@@ -144,18 +144,16 @@ public:
     return mRefDT->CreateGradientStops(aStops, aNumStops, aExtendMode);
   }
   virtual already_AddRefed<FilterNode> CreateFilter(FilterType aType) override;
 
   void ReplayToDrawTarget(DrawTarget* aDT, const Matrix& aTransform);
 
   bool ContainsOnlyColoredGlyphs(RefPtr<ScaledFont>& aScaledFont, Color& aColor, std::vector<Glyph>& aGlyphs) override;
 
-  void Dump() override;
-
 protected:
   virtual ~DrawTargetCaptureImpl();
 
   void MarkChanged();
 
 private:
   // This storage system was used to minimize the amount of heap allocations
   // that are required while recording. It should be noted there's no
--- a/gfx/2d/Logging.h
+++ b/gfx/2d/Logging.h
@@ -15,17 +15,16 @@
 #ifdef MOZ_LOGGING
 #include "mozilla/Logging.h"
 #endif
 #include "mozilla/Tuple.h"
 
 #if defined(MOZ_WIDGET_ANDROID)
 #include "nsDebug.h"
 #endif
-#include "2D.h"
 #include "Point.h"
 #include "BaseRect.h"
 #include "Matrix.h"
 #include "LoggingConstants.h"
 
 #if defined(MOZ_LOGGING)
 extern GFX2D_API mozilla::LogModule* GetGFX2DLog();
 #endif
@@ -353,22 +352,16 @@ public:
     return *this;
   }
   Log &operator <<(double aDouble) {
     if (MOZ_UNLIKELY(LogIt())) {
       mMessage << aDouble;
     }
     return *this;
   }
-  Log &operator <<(const Color& aColor) {
-    if (MOZ_UNLIKELY(LogIt())) {
-      mMessage << "Color(" << aColor.r << ", " << aColor.g << ", " << aColor.b << ", " << aColor.a << ")";
-    }
-    return *this;
-  }
   template <typename T, typename Sub, typename Coord>
   Log &operator <<(const BasePoint<T, Sub, Coord>& aPoint) {
     if (MOZ_UNLIKELY(LogIt())) {
       mMessage << "Point" << aPoint;
     }
     return *this;
   }
   template <typename T, typename Sub>
@@ -396,215 +389,16 @@ public:
     if (MOZ_UNLIKELY(LogIt())) {
       mMessage << std::showbase << std::hex
                << aHex.mVal
                << std::noshowbase << std::dec;
     }
     return *this;
   }
 
-  Log &operator<<(const SourceSurface* aSurface) {
-    if (MOZ_UNLIKELY(LogIt())) {
-      mMessage << "SourceSurface(" << (void*)(aSurface) << ")";
-    }
-    return *this;
-  }
-  Log &operator<<(const Path* aPath) {
-    if (MOZ_UNLIKELY(LogIt())) {
-      mMessage << "Path(" << (void*)(aPath) << ")";
-    }
-    return *this;
-  }
-  Log &operator<<(const Pattern* aPattern) {
-    if (MOZ_UNLIKELY(LogIt())) {
-      mMessage << "Pattern(" << (void*)(aPattern) << ")";
-    }
-    return *this;
-  }
-  Log &operator<<(const ScaledFont* aFont) {
-    if (MOZ_UNLIKELY(LogIt())) {
-      mMessage << "ScaledFont(" << (void*)(aFont) << ")";
-    }
-    return *this;
-  }
-  Log &operator<<(const FilterNode* aFilter) {
-    if (MOZ_UNLIKELY(LogIt())) {
-      mMessage << "FilterNode(" << (void*)(aFilter) << ")";
-    }
-    return *this;
-  }
-  Log &operator<<(const DrawOptions& aOptions) {
-    if (MOZ_UNLIKELY(LogIt())) {
-      mMessage << "DrawOptions(" << aOptions.mAlpha << ", ";
-      (*this) << aOptions.mCompositionOp;
-      mMessage << ", ";
-      (*this) << aOptions.mAntialiasMode;
-      mMessage << ")";
-    }
-    return *this;
-  }
-  Log &operator<<(const DrawSurfaceOptions& aOptions) {
-    if (MOZ_UNLIKELY(LogIt())) {
-      mMessage << "DrawSurfaceOptions(";
-      (*this) << aOptions.mSamplingFilter;
-      mMessage << ", ";
-      (*this) << aOptions.mSamplingBounds;
-      mMessage << ")";
-    }
-    return *this;
-  }
-
-  Log& operator<<(SamplingBounds aBounds) {
-    if (MOZ_UNLIKELY(LogIt())) {
-      switch(aBounds) {
-        case SamplingBounds::UNBOUNDED:
-          mMessage << "SamplingBounds::UNBOUNDED";
-          break;
-        case SamplingBounds::BOUNDED:
-          mMessage << "SamplingBounds::BOUNDED";
-          break;
-        default:
-          mMessage << "Invalid SamplingBounds (" << (int)aBounds << ")";
-          break;
-      }
-    }
-    return *this;
-  }
-  Log& operator<<(SamplingFilter aFilter) {
-    if (MOZ_UNLIKELY(LogIt())) {
-      switch(aFilter) {
-        case SamplingFilter::GOOD:
-          mMessage << "SamplingFilter::GOOD";
-          break;
-        case SamplingFilter::LINEAR:
-          mMessage << "SamplingFilter::LINEAR";
-          break;
-        case SamplingFilter::POINT:
-          mMessage << "SamplingFilter::POINT";
-          break;
-        default:
-          mMessage << "Invalid SamplingFilter (" << (int)aFilter << ")";
-          break;
-      }
-    }
-    return *this;
-  }
-  Log& operator<<(AntialiasMode aMode) {
-    if (MOZ_UNLIKELY(LogIt())) {
-      switch(aMode) {
-        case AntialiasMode::NONE:
-          mMessage << "AntialiasMode::NONE";
-          break;
-        case AntialiasMode::GRAY:
-          mMessage << "AntialiasMode::GRAY";
-          break;
-        case AntialiasMode::SUBPIXEL:
-          mMessage << "AntialiasMode::SUBPIXEL";
-          break;
-        case AntialiasMode::DEFAULT:
-          mMessage << "AntialiasMode::DEFAULT";
-          break;
-        default:
-          mMessage << "Invalid AntialiasMode (" << (int)aMode << ")";
-          break;
-      }
-    }
-    return *this;
-  }
-  Log& operator<<(CompositionOp aOp) {
-    if (MOZ_UNLIKELY(LogIt())) {
-      switch(aOp) {
-        case CompositionOp::OP_OVER:
-          mMessage << "CompositionOp::OP_OVER";
-          break;
-        case CompositionOp::OP_ADD:
-          mMessage << "CompositionOp::OP_ADD";
-          break;
-        case CompositionOp::OP_ATOP:
-          mMessage << "CompositionOp::OP_ATOP";
-          break;
-        case CompositionOp::OP_OUT:
-          mMessage << "CompositionOp::OP_OUT";
-          break;
-        case CompositionOp::OP_IN:
-          mMessage << "CompositionOp::OP_IN";
-          break;
-        case CompositionOp::OP_SOURCE:
-          mMessage << "CompositionOp::OP_SOURCE";
-          break;
-        case CompositionOp::OP_DEST_IN:
-          mMessage << "CompositionOp::OP_DEST_IN";
-          break;
-        case CompositionOp::OP_DEST_OUT:
-          mMessage << "CompositionOp::OP_DEST_OUT";
-          break;
-        case CompositionOp::OP_DEST_OVER:
-          mMessage << "CompositionOp::OP_DEST_OVER";
-          break;
-        case CompositionOp::OP_DEST_ATOP:
-          mMessage << "CompositionOp::OP_DEST_ATOP";
-          break;
-        case CompositionOp::OP_XOR:
-          mMessage << "CompositionOp::OP_XOR";
-          break;
-        case CompositionOp::OP_MULTIPLY:
-          mMessage << "CompositionOp::OP_MULTIPLY";
-          break;
-        case CompositionOp::OP_SCREEN:
-          mMessage << "CompositionOp::OP_SCREEN";
-          break;
-        case CompositionOp::OP_OVERLAY:
-          mMessage << "CompositionOp::OP_OVERLAY";
-          break;
-        case CompositionOp::OP_DARKEN:
-          mMessage << "CompositionOp::OP_DARKEN";
-          break;
-        case CompositionOp::OP_LIGHTEN:
-          mMessage << "CompositionOp::OP_LIGHTEN";
-          break;
-        case CompositionOp::OP_COLOR_DODGE:
-          mMessage << "CompositionOp::OP_COLOR_DODGE";
-          break;
-        case CompositionOp::OP_COLOR_BURN:
-          mMessage << "CompositionOp::OP_COLOR_BURN";
-          break;
-        case CompositionOp::OP_HARD_LIGHT:
-          mMessage << "CompositionOp::OP_HARD_LIGHT";
-          break;
-        case CompositionOp::OP_SOFT_LIGHT:
-          mMessage << "CompositionOp::OP_SOFT_LIGHT";
-          break;
-        case CompositionOp::OP_DIFFERENCE:
-          mMessage << "CompositionOp::OP_DIFFERENCE";
-          break;
-        case CompositionOp::OP_EXCLUSION:
-          mMessage << "CompositionOp::OP_EXCLUSION";
-          break;
-        case CompositionOp::OP_HUE:
-          mMessage << "CompositionOp::OP_HUE";
-          break;
-        case CompositionOp::OP_SATURATION:
-          mMessage << "CompositionOp::OP_SATURATION";
-          break;
-        case CompositionOp::OP_COLOR:
-          mMessage << "CompositionOp::OP_COLOR";
-          break;
-        case CompositionOp::OP_LUMINOSITY:
-          mMessage << "CompositionOp::OP_LUMINOSITY";
-          break;
-        case CompositionOp::OP_COUNT:
-          mMessage << "CompositionOp::OP_COUNT";
-          break;
-        default:
-          mMessage << "Invalid CompositionOp (" << (int)aOp << ")";
-          break;
-      }
-    }
-    return *this;
-  }
   Log& operator<<(SurfaceFormat aFormat) {
     if (MOZ_UNLIKELY(LogIt())) {
       switch(aFormat) {
         case SurfaceFormat::B8G8R8A8:
           mMessage << "SurfaceFormat::B8G8R8A8";
           break;
         case SurfaceFormat::B8G8R8X8:
           mMessage << "SurfaceFormat::B8G8R8X8";
@@ -838,20 +632,17 @@ public:
           mPrefFunction(nullptr) {}
 
   template <typename T>
   TreeLog& operator<<(const T& aObject) {
     if (mConditionedOnPref && !mPrefFunction()) {
       return *this;
     }
     if (mStartOfLine) {
-      if (!mPrefix.empty()) {
-        mLog << '[' << mPrefix << "] ";
-      }
-      mLog << std::string(mDepth * INDENT_PER_LEVEL, ' ');
+      mLog << '[' << mPrefix << "] " << std::string(mDepth * INDENT_PER_LEVEL, ' ');
       mStartOfLine = false;
     }
     mLog << aObject;
     if (EndsInNewline(aObject)) {
       // Don't indent right here as the user may change the indent
       // between now and the first output to the next line.
       mLog.Flush();
       mStartOfLine = true;
--- a/gfx/layers/PaintThread.cpp
+++ b/gfx/layers/PaintThread.cpp
@@ -286,20 +286,16 @@ PaintThread::AsyncPrepareBuffer(Composit
 
 void
 PaintThread::PaintContents(CapturedPaintState* aState,
                            PrepDrawTargetForPaintingCallback aCallback)
 {
   MOZ_ASSERT(NS_IsMainThread());
   MOZ_ASSERT(aState);
 
-  if (gfxPrefs::LayersOMTPDumpCapture() && aState->mCapture) {
-    aState->mCapture->Dump();
-  }
-
   RefPtr<CompositorBridgeChild> cbc(CompositorBridgeChild::Get());
   RefPtr<CapturedPaintState> state(aState);
 
   cbc->NotifyBeginAsyncPaint(state);
 
   RefPtr<PaintThread> self = this;
   RefPtr<Runnable> task = NS_NewRunnableFunction("PaintThread::PaintContents",
     [self, cbc, state, aCallback]() -> void
@@ -360,20 +356,16 @@ PaintThread::AsyncPaintContents(Composit
 }
 
 void
 PaintThread::PaintTiledContents(CapturedTiledPaintState* aState)
 {
   MOZ_ASSERT(NS_IsMainThread());
   MOZ_ASSERT(aState);
 
-  if (gfxPrefs::LayersOMTPDumpCapture() && aState->mCapture) {
-    aState->mCapture->Dump();
-  }
-
   RefPtr<CompositorBridgeChild> cbc(CompositorBridgeChild::Get());
   RefPtr<CapturedTiledPaintState> state(aState);
 
   cbc->NotifyBeginAsyncPaint(state);
 
   RefPtr<PaintThread> self = this;
   RefPtr<Runnable> task = NS_NewRunnableFunction("PaintThread::PaintTiledContents",
     [self, cbc, state]() -> void
--- a/gfx/thebes/gfxPrefs.h
+++ b/gfx/thebes/gfxPrefs.h
@@ -610,17 +610,16 @@ private:
   DECL_GFX_PREF(Once, "layers.mlgpu.enable-clear-view",        AdvancedLayersEnableClearView, bool, true);
   DECL_GFX_PREF(Once, "layers.mlgpu.enable-cpu-occlusion",     AdvancedLayersEnableCPUOcclusion, bool, true);
   DECL_GFX_PREF(Once, "layers.mlgpu.enable-depth-buffer",      AdvancedLayersEnableDepthBuffer, bool, false);
   DECL_GFX_PREF(Live, "layers.mlgpu.enable-invalidation",      AdvancedLayersUseInvalidation, bool, true);
   DECL_GFX_PREF(Once, "layers.mlgpu.enable-on-windows7",       AdvancedLayersEnableOnWindows7, bool, false);
   DECL_GFX_PREF(Once, "layers.mlgpu.enable-container-resizing", AdvancedLayersEnableContainerResizing, bool, true);
   DECL_GFX_PREF(Once, "layers.offmainthreadcomposition.force-disabled", LayersOffMainThreadCompositionForceDisabled, bool, false);
   DECL_GFX_PREF(Live, "layers.offmainthreadcomposition.frame-rate", LayersCompositionFrameRate, int32_t,-1);
-  DECL_GFX_PREF(Live, "layers.omtp.dump-capture",              LayersOMTPDumpCapture, bool, false);
   DECL_GFX_PREF(Live, "layers.omtp.paint-workers",             LayersOMTPPaintWorkers, int32_t, 1);
   DECL_GFX_PREF(Live, "layers.omtp.release-capture-on-main-thread", LayersOMTPReleaseCaptureOnMainThread, bool, false);
   DECL_GFX_PREF(Live, "layers.orientation.sync.timeout",       OrientationSyncMillis, uint32_t, (uint32_t)0);
   DECL_GFX_PREF(Once, "layers.prefer-opengl",                  LayersPreferOpenGL, bool, false);
   DECL_GFX_PREF(Live, "layers.progressive-paint",              ProgressivePaint, bool, false);
   DECL_GFX_PREF(Live, "layers.shared-buffer-provider.enabled", PersistentBufferProviderSharedEnabled, bool, false);
   DECL_GFX_PREF(Live, "layers.single-tile.enabled",            LayersSingleTileEnabled, bool, true);
   DECL_GFX_PREF(Live, "layers.force-synchronous-resize",       LayersForceSynchronousResize, bool, true);
--- a/modules/libpref/init/all.js
+++ b/modules/libpref/init/all.js
@@ -5949,9 +5949,8 @@ pref("layers.omtp.enabled", true);
 pref("layers.omtp.enabled", false);
 #endif
 #if defined(XP_MACOSX)
 pref("layers.omtp.paint-workers", -1);
 #else
 pref("layers.omtp.paint-workers", 1);
 #endif
 pref("layers.omtp.release-capture-on-main-thread", false);
-pref("layers.omtp.dump-capture", false);