# HG changeset patch

diff --git a/Cargo.lock b/Cargo.lock

--- a/Cargo.lock

+++ b/Cargo.lock

 version = "0.1.0"

 dependencies = [

  "glsl",

 ]

 [[package]]

 name = "glslopt"

 version = "0.1.9"

-source = "registry+https://github.com/rust-lang/crates.io-index"

-checksum = "74a3f5c04450dfdadb4b08f6e5ee6f5110f674de1acbd6199bfec68392a8cbaf"

 dependencies = [

  "cc",

 ]

 [[package]]

 name = "gluesmith"

 version = "0.1.0"

 dependencies = [

diff --git a/Cargo.toml b/Cargo.toml

--- a/Cargo.toml

+++ b/Cargo.toml

 chardetng = { git = "https://github.com/hsivonen/chardetng", rev="3484d3e3ebdc8931493aa5df4d7ee9360a90e76b" }

 chardetng_c = { git = "https://github.com/hsivonen/chardetng_c", rev="ed8a4c6f900a90d4dbc1d64b856e61490a1c3570" }

 coremidi = { git = "https://github.com/chris-zen/coremidi.git", rev="fc68464b5445caf111e41f643a2e69ccce0b4f83" }

 libudev-sys = { path = "dom/webauthn/libudev-sys" }

 packed_simd = { git = "https://github.com/hsivonen/packed_simd", rev="8b4bd7d8229660a749dbe419a57ea01df9de5453" }

 midir = { git = "https://github.com/mozilla/midir.git", rev = "4c11f0ffb5d6a10de4aff40a7b81218b33b94e6f" }

 minidump_writer_linux = { git = "https://github.com/msirringhaus/minidump_writer_linux.git", rev = "029ac0d54b237f27dc7d8d4e51bc0fb076e5e852" }

-

+glslopt = { path = "third_party/rust/glslopt/" }

 # Patch mio 0.6 to use winapi 0.3 and miow 0.3, getting rid of winapi 0.2.

 # There is not going to be new version of mio 0.6, mio now being >= 0.7.11.

 [patch.crates-io.mio]

 path = "third_party/rust/mio-0.6.23"

diff --git a/gfx/skia/skia/include/codec/SkEncodedOrigin.h b/gfx/skia/skia/include/codec/SkEncodedOrigin.h

--- a/gfx/skia/skia/include/codec/SkEncodedOrigin.h

+++ b/gfx/skia/skia/include/codec/SkEncodedOrigin.h

@@ -36,12 +36,13 @@ static inline SkMatrix SkEncodedOriginTo

         case kBottomRight_SkEncodedOrigin: return SkMatrix::MakeAll(-1,  0, w,  0, -1, h, 0, 0, 1);

         case  kBottomLeft_SkEncodedOrigin: return SkMatrix::MakeAll( 1,  0, 0,  0, -1, h, 0, 0, 1);

         case     kLeftTop_SkEncodedOrigin: return SkMatrix::MakeAll( 0,  1, 0,  1,  0, 0, 0, 0, 1);

         case    kRightTop_SkEncodedOrigin: return SkMatrix::MakeAll( 0, -1, h,  1,  0, 0, 0, 0, 1);

         case kRightBottom_SkEncodedOrigin: return SkMatrix::MakeAll( 0, -1, h, -1,  0, w, 0, 0, 1);

         case  kLeftBottom_SkEncodedOrigin: return SkMatrix::MakeAll( 0,  1, 0, -1,  0, w, 0, 0, 1);

     }

     SK_ABORT("Unexpected origin");

+    SkUNREACHABLE;

 }

 #endif // SkEncodedOrigin_DEFINED

diff --git a/gfx/skia/skia/include/private/GrTypesPriv.h b/gfx/skia/skia/include/private/GrTypesPriv.h

--- a/gfx/skia/skia/include/private/GrTypesPriv.h

+++ b/gfx/skia/skia/include/private/GrTypesPriv.h

@@ -535,32 +535,34 @@ static inline GrSLType GrSLCombinedSampl

             return kTexture2DSampler_GrSLType;

         case GrTextureType::kRectangle:

             return kTexture2DRectSampler_GrSLType;

         case GrTextureType::kExternal:

             return kTextureExternalSampler_GrSLType;

         default:

             SK_ABORT("Unexpected texture type");

     }

+    SkUNREACHABLE;

 }

 /** Rectangle and external textures only support the clamp wrap mode and do not support

  *  MIP maps.

  */

 static inline bool GrTextureTypeHasRestrictedSampling(GrTextureType type) {

     switch (type) {

         case GrTextureType::k2D:

             return false;

         case GrTextureType::kRectangle:

             return true;

         case GrTextureType::kExternal:

             return true;

         default:

             SK_ABORT("Unexpected texture type");

     }

+    SkUNREACHABLE;

 }

 static constexpr bool GrSLTypeIsCombinedSamplerType(GrSLType type) {

     switch (type) {

         case kTexture2DSampler_GrSLType:

         case kTextureExternalSampler_GrSLType:

         case kTexture2DRectSampler_GrSLType:

             return true;

@@ -853,16 +855,17 @@ static inline size_t GrCompressedFormatD

     switch (compressionType) {

         case SkImage::kETC1_CompressionType:

             SkASSERT((width & 3) == 0);

             SkASSERT((height & 3) == 0);

             return (width >> 2) * (height >> 2) * 8;

     }

     SK_ABORT("Invalid pixel config");

+    SkUNREACHABLE;

 }

 /**

  * Like SkColorType this describes a layout of pixel data in CPU memory. It specifies the channels,

  * their type, and width. This exists so that the GPU backend can have private types that have no

  * analog in the public facing SkColorType enum and omit types not implemented in the GPU backend.

  * It does not refer to a texture format and the mapping to texture formats may be many-to-many.

  * It does not specify the sRGB encoding of the stored values. The components are listed in order of

diff --git a/gfx/skia/skia/src/core/SkGeometry.h b/gfx/skia/skia/src/core/SkGeometry.h

--- a/gfx/skia/skia/src/core/SkGeometry.h

+++ b/gfx/skia/skia/src/core/SkGeometry.h

@@ -177,28 +177,30 @@ static inline bool SkCubicIsDegenerate(S

         case SkCubicType::kLocalCusp:

         case SkCubicType::kCuspAtInfinity:

             return false;

         case SkCubicType::kQuadratic:

         case SkCubicType::kLineOrPoint:

             return true;

     }

     SK_ABORT("Invalid SkCubicType");

+    SkUNREACHABLE;

 }

 static inline const char* SkCubicTypeName(SkCubicType type) {

     switch (type) {

         case SkCubicType::kSerpentine: return "kSerpentine";

         case SkCubicType::kLoop: return "kLoop";

         case SkCubicType::kLocalCusp: return "kLocalCusp";

         case SkCubicType::kCuspAtInfinity: return "kCuspAtInfinity";

         case SkCubicType::kQuadratic: return "kQuadratic";

         case SkCubicType::kLineOrPoint: return "kLineOrPoint";

     }

     SK_ABORT("Invalid SkCubicType");

+    SkUNREACHABLE;

 }

 /** Returns the cubic classification.

     t[],s[] are set to the two homogeneous parameter values at which points the lines L & M

     intersect with K, sorted from smallest to largest and oriented so positive values of the

     implicit are on the "left" side. For a serpentine curve they are the inflection points. For a

     loop they are the double point. For a local cusp, they are both equal and denote the cusp point.

diff --git a/gfx/skia/skia/src/core/SkTextBlob.cpp b/gfx/skia/skia/src/core/SkTextBlob.cpp

--- a/gfx/skia/skia/src/core/SkTextBlob.cpp

+++ b/gfx/skia/skia/src/core/SkTextBlob.cpp

@@ -196,16 +196,17 @@ unsigned SkTextBlob::ScalarsPerGlyph(Gly

 }

 void SkTextBlob::operator delete(void* p) {

     sk_free(p);

 }

 void* SkTextBlob::operator new(size_t) {

     SK_ABORT("All blobs are created by placement new.");

+    SkUNREACHABLE;

 }

 void* SkTextBlob::operator new(size_t, void* p) {

     return p;

 }

 SkTextBlobRunIterator::SkTextBlobRunIterator(const SkTextBlob* blob)

     : fCurrentRun(SkTextBlob::RunRecord::First(blob)) {

diff --git a/gfx/skia/skia/src/core/SkTypeface_remote.cpp b/gfx/skia/skia/src/core/SkTypeface_remote.cpp

--- a/gfx/skia/skia/src/core/SkTypeface_remote.cpp

+++ b/gfx/skia/skia/src/core/SkTypeface_remote.cpp

@@ -24,16 +24,17 @@ void SkScalerContextProxy::initCache(SkS

     SkASSERT(cache != nullptr);

     fCache = cache;

     fStrikeCache = strikeCache;

 }

 unsigned SkScalerContextProxy::generateGlyphCount()  {

     SK_ABORT("Should never be called.");

+    SkUNREACHABLE;

 }

 bool SkScalerContextProxy::generateAdvance(SkGlyph* glyph) {

     return false;

 }

 void SkScalerContextProxy::generateMetrics(SkGlyph* glyph) {

     TRACE_EVENT1("skia", "generateMetrics", "rec", TRACE_STR_COPY(this->getRec().dump().c_str()));

diff --git a/gfx/skia/skia/src/core/SkTypeface_remote.h b/gfx/skia/skia/src/core/SkTypeface_remote.h

--- a/gfx/skia/skia/src/core/SkTypeface_remote.h

+++ b/gfx/skia/skia/src/core/SkTypeface_remote.h

@@ -58,46 +58,54 @@ public:

             , fGlyphCount{glyphCount}

             , fIsLogging{isLogging}

             , fDiscardableManager{std::move(manager)} {}

     SkFontID remoteTypefaceID() const {return fFontId;}

     int glyphCount() const {return fGlyphCount;}

     bool isLogging() const {return fIsLogging;}

 protected:

-    int onGetUPEM() const override { SK_ABORT("Should never be called."); }

+    int onGetUPEM() const override { SK_ABORT("Should never be called."); SkUNREACHABLE; }

     std::unique_ptr<SkStreamAsset> onOpenStream(int* ttcIndex) const override {

         SK_ABORT("Should never be called.");

+	SkUNREACHABLE;

     }

     std::unique_ptr<SkFontData> onMakeFontData() const override {

         SK_ABORT("Should never be called.");

+	SkUNREACHABLE;

     }

     sk_sp<SkTypeface> onMakeClone(const SkFontArguments& args) const override {

         SK_ABORT("Should never be called.");

+	SkUNREACHABLE;

     }

     int onGetVariationDesignPosition(SkFontArguments::VariationPosition::Coordinate coordinates[],

                                      int coordinateCount) const override {

         SK_ABORT("Should never be called.");

+	SkUNREACHABLE;

     }

     int onGetVariationDesignParameters(SkFontParameters::Variation::Axis parameters[],

                                        int parameterCount) const override {

         SK_ABORT("Should never be called.");

+	SkUNREACHABLE;

     }

     void onGetFamilyName(SkString* familyName) const override {

         // Used by SkStrikeCache::DumpMemoryStatistics.

         *familyName = "";

     }

     SkTypeface::LocalizedStrings* onCreateFamilyNameIterator() const override {

         SK_ABORT("Should never be called.");

+	SkUNREACHABLE;

     }

     int onGetTableTags(SkFontTableTag tags[]) const override {

         SK_ABORT("Should never be called.");

+	SkUNREACHABLE;

     }

     size_t onGetTableData(SkFontTableTag, size_t offset, size_t length, void* data) const override {

         SK_ABORT("Should never be called.");

+	SkUNREACHABLE;

     }

     SkScalerContext* onCreateScalerContext(const SkScalerContextEffects& effects,

                                            const SkDescriptor* desc) const override {

         return new SkScalerContextProxy(sk_ref_sp(const_cast<SkTypefaceProxy*>(this)), effects,

                                         desc, fDiscardableManager);

     }

     void onFilterRec(SkScalerContextRec* rec) const override {

         // The rec filtering is already applied by the server when generating

@@ -111,26 +119,28 @@ protected:

     }

     void getPostScriptGlyphNames(SkString*) const override {

         SK_ABORT("Should never be called.");

     }

     std::unique_ptr<SkAdvancedTypefaceMetrics> onGetAdvancedMetrics() const override {

         SK_ABORT("Should never be called.");

+	SkUNREACHABLE;

     }

     void onCharsToGlyphs(const SkUnichar* chars, int count, SkGlyphID glyphs[]) const override {

         SK_ABORT("Should never be called.");

     }

     int onCountGlyphs() const override {

         return this->glyphCount();

     }

     void* onGetCTFontRef() const override {

         SK_ABORT("Should never be called.");

+	SkUNREACHABLE;

     }

 private:

     const SkFontID                                  fFontId;

     const int                                       fGlyphCount;

     const bool                                      fIsLogging;

     sk_sp<SkStrikeClient::DiscardableHandleManager> fDiscardableManager;

diff --git a/gfx/skia/skia/src/effects/imagefilters/SkBlurImageFilter.cpp b/gfx/skia/skia/src/effects/imagefilters/SkBlurImageFilter.cpp

--- a/gfx/skia/skia/src/effects/imagefilters/SkBlurImageFilter.cpp

+++ b/gfx/skia/skia/src/effects/imagefilters/SkBlurImageFilter.cpp

@@ -139,16 +139,17 @@ static GrTextureDomain::Mode to_texture_

         case SkTileMode::kDecal:

             return GrTextureDomain::kDecal_Mode;

         case SkTileMode::kMirror:

             // TODO (michaelludwig) - Support mirror mode, treat as repeat for now

         case SkTileMode::kRepeat:

             return GrTextureDomain::kRepeat_Mode;

         default:

             SK_ABORT("Unsupported tile mode.");

+	    SkUNREACHABLE;

     }

 }

 #endif

 // This is defined by the SVG spec:

 // https://drafts.fxtf.org/filter-effects/#feGaussianBlurElement

 static int calculate_window(double sigma) {

     // NB 136 is the largest sigma that will not cause a buffer full of 255 mask values to overflow

diff --git a/gfx/skia/skia/src/effects/imagefilters/SkLightingImageFilter.cpp b/gfx/skia/skia/src/effects/imagefilters/SkLightingImageFilter.cpp

--- a/gfx/skia/skia/src/effects/imagefilters/SkLightingImageFilter.cpp

+++ b/gfx/skia/skia/src/effects/imagefilters/SkLightingImageFilter.cpp

@@ -1696,16 +1696,17 @@ static SkImageFilterLight* create_random

             return new SkPointLight(random_point3(random), random->nextU());

         }

         case 2: {

             return new SkSpotLight(random_point3(random), random_point3(random),

                                    random->nextUScalar1(), random->nextUScalar1(), random->nextU());

         }

         default:

             SK_ABORT("Unexpected value.");

+	    SkUNREACHABLE;

     }

 }

 std::unique_ptr<GrFragmentProcessor> GrDiffuseLightingEffect::TestCreate(GrProcessorTestData* d) {

     int texIdx = d->fRandom->nextBool() ? GrProcessorUnitTest::kSkiaPMTextureIdx

                                         : GrProcessorUnitTest::kAlphaTextureIdx;

     sk_sp<GrTextureProxy> proxy = d->textureProxy(texIdx);

     SkScalar surfaceScale = d->fRandom->nextSScalar1();

diff --git a/gfx/skia/skia/src/fonts/SkFontMgr_indirect.cpp b/gfx/skia/skia/src/fonts/SkFontMgr_indirect.cpp

--- a/gfx/skia/skia/src/fonts/SkFontMgr_indirect.cpp

+++ b/gfx/skia/skia/src/fonts/SkFontMgr_indirect.cpp

@@ -64,16 +64,17 @@ int SkFontMgr_Indirect::onCountFamilies(

 }

 void SkFontMgr_Indirect::onGetFamilyName(int index, SkString* familyName) const {

     SK_ABORT("Not implemented");

 }

 SkFontStyleSet* SkFontMgr_Indirect::onCreateStyleSet(int index) const {

     SK_ABORT("Not implemented");

+    SkUNREACHABLE;

 }

 SkFontStyleSet* SkFontMgr_Indirect::onMatchFamily(const char familyName[]) const {

     return new SkStyleSet_Indirect(this, -1, fProxy->matchName(familyName));

 }

 SkTypeface* SkFontMgr_Indirect::createTypefaceFromFontId(const SkFontIdentity& id) const {

     if (id.fDataId == SkFontIdentity::kInvalidDataId) {

diff --git a/gfx/skia/skia/src/gpu/GrDataUtils.cpp b/gfx/skia/skia/src/gpu/GrDataUtils.cpp

--- a/gfx/skia/skia/src/gpu/GrDataUtils.cpp

+++ b/gfx/skia/skia/src/gpu/GrDataUtils.cpp

@@ -123,25 +123,27 @@ static int num_ETC1_blocks(int w, int h)

 size_t GrCompressedDataSize(SkImage::CompressionType type, int width, int height) {

     switch (type) {

         case SkImage::kETC1_CompressionType:

             int numBlocks = num_ETC1_blocks(width, height);

             return numBlocks * sizeof(ETC1Block);

     }

     SK_ABORT("Unexpected compression type");

+    SkUNREACHABLE;

 }

 size_t GrCompressedRowBytes(SkImage::CompressionType type, int width) {

     switch (type) {

         case SkImage::kETC1_CompressionType:

             int numBlocksWidth = num_ETC1_blocks_w(width);

             return numBlocksWidth * sizeof(ETC1Block);

     }

     SK_ABORT("Unexpected compression type");

+    SkUNREACHABLE;

 }

 // Fill in 'dest' with ETC1 blocks derived from 'colorf'

 static void fillin_ETC1_with_color(int width, int height, const SkColor4f& colorf, void* dest) {

     SkColor color = colorf.toSkColor();

     ETC1Block block;

     create_etc1_block(color, &block);

diff --git a/gfx/skia/skia/src/gpu/GrFragmentProcessor.h b/gfx/skia/skia/src/gpu/GrFragmentProcessor.h

--- a/gfx/skia/skia/src/gpu/GrFragmentProcessor.h

+++ b/gfx/skia/skia/src/gpu/GrFragmentProcessor.h

@@ -370,16 +370,17 @@ protected:

                                                    const Args&... samps) {

         return (0 == i) ? samp0 : IthTextureSampler(i - 1, samps...);

     }

     inline static const TextureSampler& IthTextureSampler(int i);

 private:

     virtual SkPMColor4f constantOutputForConstantInput(const SkPMColor4f& /* inputColor */) const {

         SK_ABORT("Subclass must override this if advertising this optimization.");

+	SkUNREACHABLE;

     }

     /** Returns a new instance of the appropriate *GL* implementation class

         for the given GrFragmentProcessor; caller is responsible for deleting

         the object. */

     virtual GrGLSLFragmentProcessor* onCreateGLSLInstance() const = 0;

     /** Implemented using GLFragmentProcessor::GenKey as described in this class's comment. */

diff --git a/gfx/skia/skia/src/gpu/GrPathRendering.cpp b/gfx/skia/skia/src/gpu/GrPathRendering.cpp

--- a/gfx/skia/skia/src/gpu/GrPathRendering.cpp

+++ b/gfx/skia/skia/src/gpu/GrPathRendering.cpp

@@ -14,16 +14,17 @@

 #include "src/gpu/GrPathRendering.h"

 #include "src/gpu/GrProgramInfo.h"

 #include "src/gpu/GrRenderTarget.h"

 const GrUserStencilSettings& GrPathRendering::GetStencilPassSettings(FillType fill) {

     switch (fill) {

         default:

             SK_ABORT("Unexpected path fill.");

+	    SkUNREACHABLE;

         case GrPathRendering::kWinding_FillType: {

             constexpr static GrUserStencilSettings kWindingStencilPass(

                 GrUserStencilSettings::StaticInit<

                     0xffff,

                     GrUserStencilTest::kAlwaysIfInClip,

                     0xffff,

                     GrUserStencilOp::kIncWrap,

                     GrUserStencilOp::kIncWrap,

diff --git a/gfx/skia/skia/src/gpu/GrPathRendering.h b/gfx/skia/skia/src/gpu/GrPathRendering.h

--- a/gfx/skia/skia/src/gpu/GrPathRendering.h

+++ b/gfx/skia/skia/src/gpu/GrPathRendering.h

@@ -58,16 +58,17 @@ public:

                 return 1;

             case kTranslate_PathTransformType:

                 return 2;

             case kAffine_PathTransformType:

                 return 6;

             default:

                 SK_ABORT("Unknown path transform type");

+		SkUNREACHABLE;

         }

     }

     // No native support for inverse at this time

     enum FillType {

         /** Specifies that "inside" is computed by a non-zero sum of signed

             edge crossings

         */

diff --git a/gfx/skia/skia/src/gpu/GrProcessorUnitTest.cpp b/gfx/skia/skia/src/gpu/GrProcessorUnitTest.cpp

--- a/gfx/skia/skia/src/gpu/GrProcessorUnitTest.cpp

+++ b/gfx/skia/skia/src/gpu/GrProcessorUnitTest.cpp

@@ -15,11 +15,12 @@ std::unique_ptr<GrFragmentProcessor> GrP

     std::unique_ptr<GrFragmentProcessor> fp;

     do {

         fp = GrFragmentProcessorTestFactory::Make(data);

         SkASSERT(fp);

     } while (fp->numChildProcessors() != 0);

     return fp;

 #else

     SK_ABORT("Should not be called if !SK_ALLOW_STATIC_GLOBAL_INITIALIZERS");

+    SkUNREACHABLE;

 #endif

 }

 #endif

diff --git a/gfx/skia/skia/src/gpu/GrReducedClip.cpp b/gfx/skia/skia/src/gpu/GrReducedClip.cpp

--- a/gfx/skia/skia/src/gpu/GrReducedClip.cpp

+++ b/gfx/skia/skia/src/gpu/GrReducedClip.cpp

@@ -520,16 +520,17 @@ GrReducedClip::ClipResult GrReducedClip:

                                        GrAA(element->isAA()));

         case Element::DeviceSpaceType::kPath:

             return this->addAnalyticFP(element->getDeviceSpacePath(),

                                        Invert(element->isInverseFilled()), GrAA(element->isAA()));

     }

     SK_ABORT("Unexpected DeviceSpaceType");

+    SkUNREACHABLE;

 }

 GrReducedClip::ClipResult GrReducedClip::clipOutsideElement(const Element* element) {

     switch (element->getDeviceSpaceType()) {

         case Element::DeviceSpaceType::kEmpty:

             return ClipResult::kMadeEmpty;

         case Element::DeviceSpaceType::kRect:

@@ -586,16 +587,17 @@ GrReducedClip::ClipResult GrReducedClip:

         }

         case Element::DeviceSpaceType::kPath:

             return this->addAnalyticFP(element->getDeviceSpacePath(),

                                        Invert(!element->isInverseFilled()), GrAA(element->isAA()));

     }

     SK_ABORT("Unexpected DeviceSpaceType");

+    SkUNREACHABLE;

 }

 inline void GrReducedClip::addWindowRectangle(const SkRect& elementInteriorRect, bool elementIsAA) {

     SkIRect window;

     if (!elementIsAA) {

         elementInteriorRect.round(&window);

     } else {

         elementInteriorRect.roundIn(&window);

diff --git a/gfx/skia/skia/src/gpu/GrResourceCache.cpp b/gfx/skia/skia/src/gpu/GrResourceCache.cpp

--- a/gfx/skia/skia/src/gpu/GrResourceCache.cpp

+++ b/gfx/skia/skia/src/gpu/GrResourceCache.cpp

@@ -35,27 +35,29 @@ DECLARE_SKMESSAGEBUS_MESSAGE(GrTextureFr

 //////////////////////////////////////////////////////////////////////////////

 GrScratchKey::ResourceType GrScratchKey::GenerateResourceType() {

     static std::atomic<int32_t> nextType{INHERITED::kInvalidDomain + 1};

     int32_t type = nextType++;

     if (type > SkTo<int32_t>(UINT16_MAX)) {

         SK_ABORT("Too many Resource Types");

+	SkUNREACHABLE;