# HG changeset patch

# Parent  45a1eadbae67aa05c6fa271d3dec5ac1cb0cfae8

@@ -2039,18 +2039,16 @@ name = "glsl-to-cxx"

 version = "0.1.0"

 dependencies = [

  "glsl",

 ]

 [[package]]

 name = "goblin"

 version = "0.1.3"

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

@@ -78,16 +78,17 @@ opt-level = 2

 opt-level = 2

 [patch.crates-io]

 chardetng = { git = "https://github.com/hsivonen/chardetng", rev="302c995f91f44cf26e77dc4758ad56c3ff0153ad" }

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

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

 packed_simd = { git = "https://github.com/hsivonen/packed_simd", rev="6a16f954950401b92b4e220fbf2dfaf6f00e1fb2" }

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

 # The following overrides point to dummy projects, as a temporary measure until this is resolved:

 # https://github.com/rust-lang/cargo/issues/6179

 js-sys = { git = "https://github.com/kvark/dummy-web" }

 slotmap = { git = "https://github.com/kvark/dummy-web" }

 wasm-bindgen = { git = "https://github.com/kvark/dummy-web" }

 web-sys = { git = "https://github.com/kvark/dummy-web" }

@@ -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);

 #endif // SkEncodedOrigin_DEFINED

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

             return kTexture2DSampler_GrSLType;

         case GrTextureType::kRectangle:

             return kTexture2DRectSampler_GrSLType;

         case GrTextureType::kExternal:

             return kTextureExternalSampler_GrSLType;

  *  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;

     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;

  * 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

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

         case SkCubicType::kLocalCusp:

         case SkCubicType::kCuspAtInfinity:

             return false;

         case SkCubicType::kQuadratic:

         case SkCubicType::kLineOrPoint:

     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";

     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.

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

 }

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

     sk_free(p);

 }

     return p;

 }

 SkTextBlobRunIterator::SkTextBlobRunIterator(const SkTextBlob* blob)

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

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

     SkASSERT(cache != nullptr);

     fCache = cache;

     fStrikeCache = strikeCache;

 }

     return false;

 }

 void SkScalerContextProxy::generateMetrics(SkGlyph* glyph) {

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

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

             , fGlyphCount{glyphCount}

             , fIsLogging{isLogging}

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

     SkFontID remoteTypefaceID() const {return fFontId;}

     int glyphCount() const {return fGlyphCount;}

         *familyName = "";

         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.");

     }

     }

     int onCountGlyphs() const override {

         return this->glyphCount();

     }

     const SkFontID                                  fFontId;

     const int                                       fGlyphCount;

     const bool                                      fIsLogging;

     sk_sp<SkStrikeClient::DiscardableHandleManager> fDiscardableManager;

@@ -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:

 // 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

@@ -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());

 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();

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

 }

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

     SK_ABORT("Not implemented");

 }

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

 }

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

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

@@ -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);

     switch (type) {

         case SkImage::kETC1_CompressionType:

             int numBlocksWidth = num_ETC1_blocks_w(width);

 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);

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

                                                    const Args&... samps) {

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

     }

     inline static const TextureSampler& IthTextureSampler(int i);

         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. */

@@ -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) {

                     0xffff,

                     GrUserStencilTest::kAlwaysIfInClip,

                     0xffff,

                     GrUserStencilOp::kIncWrap,

                     GrUserStencilOp::kIncWrap,

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

                 return 1;

             case kTranslate_PathTransformType:

                 return 2;

             case kAffine_PathTransformType:

                 return 6;

     // No native support for inverse at this time

     enum FillType {

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

             edge crossings

         */

@@ -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);

@@ -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()));

     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()));

     SkIRect window;

     if (!elementIsAA) {

         elementInteriorRect.round(&window);

     } else {

         elementInteriorRect.roundIn(&window);

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

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

 GrScratchKey::ResourceType GrScratchKey::GenerateResourceType() {

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