diff --git a/gm/convexpolyeffect.cpp b/gm/convexpolyeffect.cpp
index 78dcfe1..41d53e6 100644
--- a/gm/convexpolyeffect.cpp
+++ b/gm/convexpolyeffect.cpp
@@ -80,7 +80,11 @@
 
         Color color(fColor);
         sk_sp<GrGeometryProcessor> gp(GrDefaultGeoProcFactory::Make(
-                color, Coverage::kSolid_Type, LocalCoords::kUnused_Type, SkMatrix::I()));
+                target->caps().shaderCaps(),
+                color,
+                Coverage::kSolid_Type,
+                LocalCoords::kUnused_Type,
+                SkMatrix::I()));
 
         SkASSERT(gp->debugOnly_vertexStride() == sizeof(SkPoint));
         QuadHelper helper;
diff --git a/gm/skinning.cpp b/gm/skinning.cpp
new file mode 100644
index 0000000..101522f
--- /dev/null
+++ b/gm/skinning.cpp
@@ -0,0 +1,228 @@
+/*
+ * Copyright 2018 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "gm.h"
+#include "SkCanvas.h"
+#include "SkVertices.h"
+#include "SkPoint.h"
+#include <iostream>
+#include <vector>
+
+using namespace skiagm;
+
+static const int kCellSize = 60;
+static const int kColumnSize = 36;
+
+static const int kBoneCount = 7;
+static const SkMatrix kBones[] = {
+    SkMatrix::I(),
+    SkMatrix::MakeTrans(10, 0),
+    SkMatrix::MakeTrans(0, 10),
+    SkMatrix::MakeTrans(-10, 0),
+    SkMatrix::MakeTrans(0, -10),
+    SkMatrix::MakeScale(0.5f),
+    SkMatrix::MakeScale(1.5f),
+};
+
+static const int kVertexCount = 4;
+static const SkPoint kPositions[] = {
+    { 0, 0 },
+    { 0, 30 },
+    { 30, 30 },
+    { 30, 0 },
+};
+static const SkColor kColors[] = {
+    0xFFFF0000,
+    0xFF00FF00,
+    0xFF0000FF,
+    0xFFFFFF00,
+};
+static const SkVertices::BoneIndices kBoneIndices[] = {
+    {{ 1, 0, 0, 0 }},
+    {{ 2, 1, 0, 0 }},
+    {{ 3, 2, 1, 0 }},
+    {{ 4, 3, 2, 1 }},
+};
+static const SkVertices::BoneWeights kBoneWeights[] = {
+    {{ 1.0f,  0.0f,  0.0f,  0.0f  }},
+    {{ 0.5f,  0.5f,  0.0f,  0.0f  }},
+    {{ 0.34f, 0.33f, 0.33f, 0.0f  }},
+    {{ 0.25f, 0.25f, 0.25f, 0.25f }},
+};
+
+static const int kIndexCount = 6;
+static const uint16_t kIndices[] = {
+    0, 1, 2,
+    2, 3, 0,
+};
+
+// Swap two SkMatrix pointers in place.
+static void swap(const SkMatrix** x, const SkMatrix** y) {
+    const SkMatrix* temp = *x;
+    *x = *y;
+    *y = temp;
+}
+
+class SkinningGM : public GM {
+
+public:
+    SkinningGM(bool deformUsingCPU)
+            : fPaint()
+            , fVertices(nullptr)
+            , fDeformUsingCPU(deformUsingCPU)
+    {}
+
+protected:
+    bool runAsBench() const override {
+        return true;
+    }
+
+    SkString onShortName() override {
+        SkString name("skinning");
+        if (fDeformUsingCPU) {
+            name.append("_cpu");
+        }
+        return name;
+    }
+
+    SkISize onISize() override {
+        return SkISize::Make(2400, 2400);
+    }
+
+    void onOnceBeforeDraw() override {
+        fVertices = SkVertices::MakeCopy(SkVertices::kTriangles_VertexMode,
+                                         kVertexCount,
+                                         kPositions,
+                                         nullptr,
+                                         kColors,
+                                         kBoneIndices,
+                                         kBoneWeights,
+                                         kIndexCount,
+                                         kIndices,
+                                         false); // Keep the vertices non-volatile.
+    }
+
+    void onDraw(SkCanvas* canvas) override {
+        // Set the initial position.
+        int xpos = kCellSize;
+        int ypos = kCellSize;
+
+        // Create the mutable set of bones.
+        const SkMatrix* bones[kBoneCount];
+        for (int i = 0; i < kBoneCount; i ++) {
+            bones[i] = &kBones[i];
+        }
+
+        // Draw the vertices.
+        drawPermutations(canvas, xpos, ypos, bones, 1);
+    }
+
+private:
+    void drawPermutations(SkCanvas* canvas,
+                          int& xpos,
+                          int& ypos,
+                          const SkMatrix** bones,
+                          int start) {
+        if (start == kBoneCount) {
+            // Reached the end of the permutations, so draw.
+            canvas->save();
+
+            // Copy the bones.
+            SkMatrix copiedBones[kBoneCount];
+            for (int i = 0; i < kBoneCount; i ++) {
+                copiedBones[i] = *bones[i];
+            }
+
+            // Set the position.
+            canvas->translate(xpos, ypos);
+
+            // Draw the vertices.
+            if (fDeformUsingCPU) {
+                // Deform with CPU.
+                std::vector<SkPoint> positions(kVertexCount);
+                for (int i = 0; i < kVertexCount; i ++) {
+                    const SkVertices::BoneIndices& indices = kBoneIndices[i];
+                    const SkVertices::BoneWeights& weights = kBoneWeights[i];
+
+                    // Apply deformations.
+                    SkPoint& result = positions[i];
+                    SkPoint transformed;
+                    for (uint32_t j = 0; j < 4; j ++) {
+                        // Get the bone attachment data.
+                        uint32_t index = indices.indices[j];
+                        float weight = weights.weights[j];
+
+                        // Skip the bone is there is no weight.
+                        if (weight == 0.0f) {
+                            continue;
+                        }
+                        SkASSERT(index != 0);
+
+                        // transformed = M * v
+                        copiedBones[index].mapPoints(&transformed, &kPositions[i], 1);
+
+                        // result += transformed * w
+                        result += transformed * weight;
+                    }
+                }
+
+                sk_sp<SkVertices> vertices = SkVertices::MakeCopy(SkVertices::kTriangles_VertexMode,
+                                                                  kVertexCount,
+                                                                  positions.data(),
+                                                                  nullptr,
+                                                                  kColors,
+                                                                  kIndexCount,
+                                                                  kIndices);
+                canvas->drawVertices(vertices.get(),
+                                     SkBlendMode::kSrc,
+                                     fPaint);
+            } else {
+                // Deform with GPU.
+                canvas->drawVertices(fVertices.get(),
+                                     copiedBones,
+                                     kBoneCount,
+                                     SkBlendMode::kSrc,
+                                     fPaint);
+            }
+
+            canvas->restore();
+
+            // Get a new position to draw the vertices.
+            xpos += kCellSize;
+            if (xpos > kCellSize * kColumnSize) {
+                xpos = kCellSize;
+                ypos += kCellSize;
+            }
+
+            return;
+        }
+
+        // Find all possible permutations within the given range.
+        for (int i = start; i < kBoneCount; i ++) {
+            // Swap the start and i-th elements.
+            swap(bones + start, bones + i);
+
+            // Find permutations of the sub array.
+            drawPermutations(canvas, xpos, ypos, bones, start + 1);
+
+            // Swap the elements back.
+            swap(bones + i, bones + start);
+        }
+    }
+
+private:
+    SkPaint fPaint;
+    sk_sp<SkVertices> fVertices;
+    bool fDeformUsingCPU;
+
+    typedef GM INHERITED;
+};
+
+/////////////////////////////////////////////////////////////////////////////////////
+
+DEF_GM(return new SkinningGM(true);)
+DEF_GM(return new SkinningGM(false);)
diff --git a/gn/gm.gni b/gn/gm.gni
index 1b60d5a..111d68d 100644
--- a/gn/gm.gni
+++ b/gn/gm.gni
@@ -285,6 +285,7 @@
   "$_gm/skbug_4868.cpp",
   "$_gm/skbug_5321.cpp",
   "$_gm/skbug1719.cpp",
+  "$_gm/skinning.cpp",
   "$_gm/smallarc.cpp",
   "$_gm/smallpaths.cpp",
   "$_gm/spritebitmap.cpp",
diff --git a/include/private/GrTypesPriv.h b/include/private/GrTypesPriv.h
index 1490574..ee6bfd8 100644
--- a/include/private/GrTypesPriv.h
+++ b/include/private/GrTypesPriv.h
@@ -289,6 +289,14 @@
 enum GrSLType {
     kVoid_GrSLType,
     kBool_GrSLType,
+    kByte_GrSLType,
+    kByte2_GrSLType,
+    kByte3_GrSLType,
+    kByte4_GrSLType,
+    kUByte_GrSLType,
+    kUByte2_GrSLType,
+    kUByte3_GrSLType,
+    kUByte4_GrSLType,
     kShort_GrSLType,
     kShort2_GrSLType,
     kShort3_GrSLType,
@@ -389,6 +397,14 @@
         case kTexture2DRectSampler_GrSLType:
         case kBufferSampler_GrSLType:
         case kBool_GrSLType:
+        case kByte_GrSLType:
+        case kByte2_GrSLType:
+        case kByte3_GrSLType:
+        case kByte4_GrSLType:
+        case kUByte_GrSLType:
+        case kUByte2_GrSLType:
+        case kUByte3_GrSLType:
+        case kUByte4_GrSLType:
         case kShort_GrSLType:
         case kShort2_GrSLType:
         case kShort3_GrSLType:
@@ -417,6 +433,8 @@
         case kFloat_GrSLType:
         case kHalf_GrSLType:
         case kBool_GrSLType:
+        case kByte_GrSLType:
+        case kUByte_GrSLType:
         case kShort_GrSLType:
         case kUShort_GrSLType:
         case kInt_GrSLType:
@@ -425,6 +443,8 @@
 
         case kFloat2_GrSLType:
         case kHalf2_GrSLType:
+        case kByte2_GrSLType:
+        case kUByte2_GrSLType:
         case kShort2_GrSLType:
         case kUShort2_GrSLType:
         case kInt2_GrSLType:
@@ -433,6 +453,8 @@
 
         case kFloat3_GrSLType:
         case kHalf3_GrSLType:
+        case kByte3_GrSLType:
+        case kUByte3_GrSLType:
         case kShort3_GrSLType:
         case kUShort3_GrSLType:
         case kInt3_GrSLType:
@@ -440,6 +462,8 @@
 
         case kFloat4_GrSLType:
         case kHalf4_GrSLType:
+        case kByte4_GrSLType:
+        case kUByte4_GrSLType:
         case kShort4_GrSLType:
         case kUShort4_GrSLType:
         case kInt4_GrSLType:
@@ -494,6 +518,14 @@
         case kUint2_GrSLType:
         case kBufferSampler_GrSLType:
         case kBool_GrSLType:
+        case kByte_GrSLType:
+        case kByte2_GrSLType:
+        case kByte3_GrSLType:
+        case kByte4_GrSLType:
+        case kUByte_GrSLType:
+        case kUByte2_GrSLType:
+        case kUByte3_GrSLType:
+        case kUByte4_GrSLType:
         case kShort_GrSLType:
         case kShort2_GrSLType:
         case kShort3_GrSLType:
@@ -540,6 +572,14 @@
         case kUint_GrSLType:
         case kUint2_GrSLType:
         case kBool_GrSLType:
+        case kByte_GrSLType:
+        case kByte2_GrSLType:
+        case kByte3_GrSLType:
+        case kByte4_GrSLType:
+        case kUByte_GrSLType:
+        case kUByte2_GrSLType:
+        case kUByte3_GrSLType:
+        case kUByte4_GrSLType:
         case kShort_GrSLType:
         case kShort2_GrSLType:
         case kShort3_GrSLType:
@@ -568,6 +608,14 @@
 
         case kVoid_GrSLType:
         case kBool_GrSLType:
+        case kByte_GrSLType:
+        case kByte2_GrSLType:
+        case kByte3_GrSLType:
+        case kByte4_GrSLType:
+        case kUByte_GrSLType:
+        case kUByte2_GrSLType:
+        case kUByte3_GrSLType:
+        case kUByte4_GrSLType:
         case kShort_GrSLType:
         case kShort2_GrSLType:
         case kShort3_GrSLType:
@@ -638,6 +686,14 @@
 
         case kVoid_GrSLType:
         case kBool_GrSLType:
+        case kByte_GrSLType:
+        case kByte2_GrSLType:
+        case kByte3_GrSLType:
+        case kByte4_GrSLType:
+        case kUByte_GrSLType:
+        case kUByte2_GrSLType:
+        case kUByte3_GrSLType:
+        case kUByte4_GrSLType:
         case kShort2_GrSLType:
         case kShort3_GrSLType:
         case kShort4_GrSLType:
@@ -669,6 +725,16 @@
     kInt3_GrVertexAttribType,   // vector of 3 32-bit ints
     kInt4_GrVertexAttribType,   // vector of 4 32-bit ints
 
+
+    kByte_GrVertexAttribType,  // signed byte
+    kByte2_GrVertexAttribType, // vector of 2 8-bit signed bytes
+    kByte3_GrVertexAttribType, // vector of 3 8-bit signed bytes
+    kByte4_GrVertexAttribType, // vector of 4 8-bit signed bytes
+    kUByte_GrVertexAttribType,  // unsigned byte
+    kUByte2_GrVertexAttribType, // vector of 2 8-bit unsigned bytes
+    kUByte3_GrVertexAttribType, // vector of 3 8-bit unsigned bytes
+    kUByte4_GrVertexAttribType, // vector of 4 8-bit unsigned bytes
+
     kUByte_norm_GrVertexAttribType,  // unsigned byte, e.g. coverage, 0 -> 0.0f, 255 -> 1.0f.
     kUByte4_norm_GrVertexAttribType, // vector of 4 unsigned bytes, e.g. colors, 0 -> 0.0f,
                                      // 255 -> 1.0f.
@@ -719,6 +785,22 @@
             return kInt3_GrSLType;
         case kInt4_GrVertexAttribType:
             return kInt4_GrSLType;
+        case kByte_GrVertexAttribType:
+            return kByte_GrSLType;
+        case kByte2_GrVertexAttribType:
+            return kByte_GrSLType;
+        case kByte3_GrVertexAttribType:
+            return kByte_GrSLType;
+        case kByte4_GrVertexAttribType:
+            return kByte4_GrSLType;
+        case kUByte_GrVertexAttribType:
+            return kUByte_GrSLType;
+        case kUByte2_GrVertexAttribType:
+            return kUByte_GrSLType;
+        case kUByte3_GrVertexAttribType:
+            return kUByte_GrSLType;
+        case kUByte4_GrVertexAttribType:
+            return kUByte4_GrSLType;
         case kInt_GrVertexAttribType:
             return kInt_GrSLType;
         case kUint_GrVertexAttribType:
diff --git a/src/core/SkCanvas.cpp b/src/core/SkCanvas.cpp
index c1f8118..cb98b09 100644
--- a/src/core/SkCanvas.cpp
+++ b/src/core/SkCanvas.cpp
@@ -1682,7 +1682,7 @@
                             SkBlendMode mode, const SkPaint& paint) {
     TRACE_EVENT0("skia", TRACE_FUNC);
     RETURN_ON_NULL(vertices);
-    SkASSERT(boneCount <= 100);
+    SkASSERT(boneCount <= 80);
     this->onDrawVerticesObject(vertices.get(), bones, boneCount, mode, paint);
 }
 
@@ -1690,7 +1690,7 @@
                             SkBlendMode mode, const SkPaint& paint) {
     TRACE_EVENT0("skia", TRACE_FUNC);
     RETURN_ON_NULL(vertices);
-    SkASSERT(boneCount <= 100);
+    SkASSERT(boneCount <= 80);
     this->onDrawVerticesObject(vertices, bones, boneCount, mode, paint);
 }
 
diff --git a/src/gpu/GrDefaultGeoProcFactory.cpp b/src/gpu/GrDefaultGeoProcFactory.cpp
index b1c423a..027296c 100644
--- a/src/gpu/GrDefaultGeoProcFactory.cpp
+++ b/src/gpu/GrDefaultGeoProcFactory.cpp
@@ -7,6 +7,7 @@
 
 #include "GrDefaultGeoProcFactory.h"
 
+#include "GrCaps.h"
 #include "SkRefCnt.h"
 #include "glsl/GrGLSLColorSpaceXformHelper.h"
 #include "glsl/GrGLSLFragmentShaderBuilder.h"
@@ -30,12 +31,13 @@
     kBonesAttribute_GPFlag          = 0x10,
 };
 
-static constexpr int kMaxBones = 100; // Due to GPU memory limitations, only up to 100 bone
-                                      // matrices are accepted.
+static constexpr int kMaxBones = 80; // Due to GPU memory limitations, only up to 80 bone
+                                     // matrices are accepted.
 
 class DefaultGeoProc : public GrGeometryProcessor {
 public:
-    static sk_sp<GrGeometryProcessor> Make(uint32_t gpTypeFlags,
+    static sk_sp<GrGeometryProcessor> Make(const GrShaderCaps* shaderCaps,
+                                           uint32_t gpTypeFlags,
                                            GrColor color,
                                            sk_sp<GrColorSpaceXform> colorSpaceXform,
                                            const SkMatrix& viewMatrix,
@@ -45,8 +47,8 @@
                                            const float* bones,
                                            int boneCount) {
         return sk_sp<GrGeometryProcessor>(new DefaultGeoProc(
-                gpTypeFlags, color, std::move(colorSpaceXform), viewMatrix, localMatrix, coverage,
-                localCoordsWillBeRead, bones, boneCount));
+                shaderCaps, gpTypeFlags, color, std::move(colorSpaceXform), viewMatrix, localMatrix,
+                coverage, localCoordsWillBeRead, bones, boneCount));
     }
 
     const char* name() const override { return "DefaultGeometryProcessor"; }
@@ -118,17 +120,26 @@
                                                                 kMaxBones,
                                                                 &vertBonesUniformName);
                 vertBuilder->codeAppendf(
-                        "float2 transformedPosition = (%s[0] * float3(%s, 1)).xy;"
-                        "float3x3 influence = float3x3(0);"
-                        "for (int i = 0; i < 4; i++) {"
-                        "   int index = %s[i];"
-                        "   float weight = %s[i];"
-                        "   influence += %s[index] * weight;"
-                        "}"
-                        "transformedPosition = (influence * float3(transformedPosition, 1)).xy;",
+                        "float3 originalPosition = %s[0] * float3(%s, 1);"
+                        "float2 transformedPosition = float2(0);"
+                        "for (int i = 0; i < 4; i++) {",
                         vertBonesUniformName,
-                        gp.fInPosition.name(),
-                        gp.fInBoneIndices.name(),
+                        gp.fInPosition.name());
+
+                if (args.fShaderCaps->unsignedSupport()) {
+                    vertBuilder->codeAppendf(
+                        "    byte index = %s[i];",
+                        gp.fInBoneIndices.name());
+                } else {
+                    vertBuilder->codeAppendf(
+                        "    byte index = byte(floor(%s[i] * 255 + 0.5));",
+                        gp.fInBoneIndices.name());
+                }
+
+                vertBuilder->codeAppendf(
+                        "    float weight = %s[i];"
+                        "    transformedPosition += (%s[index] * originalPosition * weight).xy;"
+                        "}",
                         gp.fInBoneWeights.name(),
                         vertBonesUniformName);
                 transformedPositionName = "transformedPosition";
@@ -243,7 +254,8 @@
     }
 
 private:
-    DefaultGeoProc(uint32_t gpTypeFlags,
+    DefaultGeoProc(const GrShaderCaps* shaderCaps,
+                   uint32_t gpTypeFlags,
                    GrColor color,
                    sk_sp<GrColorSpaceXform> colorSpaceXform,
                    const SkMatrix& viewMatrix,
@@ -278,9 +290,13 @@
         }
         if (fFlags & kBonesAttribute_GPFlag) {
             SkASSERT(bones && (boneCount > 0));
-            fInBoneIndices = {"inBoneIndices", kInt4_GrVertexAttribType};
+            // GLSL 1.10 and 1.20 don't support integer attributes.
+            GrVertexAttribType indicesAttribType =
+                    shaderCaps->unsignedSupport() ? kByte4_GrVertexAttribType :
+                                                    kUByte4_norm_GrVertexAttribType;
+            fInBoneIndices = {"inBoneIndices", indicesAttribType};
             ++cnt;
-            fInBoneWeights = {"inBoneWeights", kFloat4_GrVertexAttribType};
+            fInBoneWeights = {"inBoneWeights", kUByte4_norm_GrVertexAttribType};
             ++cnt;
         }
         this->setVertexAttributeCnt(cnt);
@@ -347,7 +363,8 @@
         flags |= kBonesAttribute_GPFlag;
     }
 
-    return DefaultGeoProc::Make(flags,
+    return DefaultGeoProc::Make(d->caps()->shaderCaps(),
+                                flags,
                                 GrRandomColor(d->fRandom),
                                 GrTest::TestColorXform(d->fRandom),
                                 GrTest::TestMatrix(d->fRandom),
@@ -359,7 +376,8 @@
 }
 #endif
 
-sk_sp<GrGeometryProcessor> GrDefaultGeoProcFactory::Make(const Color& color,
+sk_sp<GrGeometryProcessor> GrDefaultGeoProcFactory::Make(const GrShaderCaps* shaderCaps,
+                                                         const Color& color,
                                                          const Coverage& coverage,
                                                          const LocalCoords& localCoords,
                                                          const SkMatrix& viewMatrix) {
@@ -376,7 +394,8 @@
     bool localCoordsWillBeRead = localCoords.fType != LocalCoords::kUnused_Type;
 
     GrColor inColor = color.fColor;
-    return DefaultGeoProc::Make(flags,
+    return DefaultGeoProc::Make(shaderCaps,
+                                flags,
                                 inColor,
                                 color.fColorSpaceXform,
                                 viewMatrix,
@@ -388,6 +407,7 @@
 }
 
 sk_sp<GrGeometryProcessor> GrDefaultGeoProcFactory::MakeForDeviceSpace(
+                                                                     const GrShaderCaps* shaderCaps,
                                                                      const Color& color,
                                                                      const Coverage& coverage,
                                                                      const LocalCoords& localCoords,
@@ -405,10 +425,11 @@
     }
 
     LocalCoords inverted(LocalCoords::kUsePosition_Type, &invert);
-    return Make(color, coverage, inverted, SkMatrix::I());
+    return Make(shaderCaps, color, coverage, inverted, SkMatrix::I());
 }
 
-sk_sp<GrGeometryProcessor> GrDefaultGeoProcFactory::MakeWithBones(const Color& color,
+sk_sp<GrGeometryProcessor> GrDefaultGeoProcFactory::MakeWithBones(const GrShaderCaps* shaderCaps,
+                                                                  const Color& color,
                                                                   const Coverage& coverage,
                                                                   const LocalCoords& localCoords,
                                                                   const Bones& bones,
@@ -427,7 +448,8 @@
     bool localCoordsWillBeRead = localCoords.fType != LocalCoords::kUnused_Type;
 
     GrColor inColor = color.fColor;
-    return DefaultGeoProc::Make(flags,
+    return DefaultGeoProc::Make(shaderCaps,
+                                flags,
                                 inColor,
                                 color.fColorSpaceXform,
                                 viewMatrix,
diff --git a/src/gpu/GrDefaultGeoProcFactory.h b/src/gpu/GrDefaultGeoProcFactory.h
index 52db807..3c4bd8e 100644
--- a/src/gpu/GrDefaultGeoProcFactory.h
+++ b/src/gpu/GrDefaultGeoProcFactory.h
@@ -10,6 +10,7 @@
 
 #include "GrColorSpaceXform.h"
 #include "GrGeometryProcessor.h"
+#include "GrShaderCaps.h"
 
 /*
  * A factory for creating default Geometry Processors which simply multiply position by the uniform
@@ -127,7 +128,8 @@
         int fBoneCount;
     };
 
-    sk_sp<GrGeometryProcessor> Make(const Color&,
+    sk_sp<GrGeometryProcessor> Make(const GrShaderCaps*,
+                                    const Color&,
                                     const Coverage&,
                                     const LocalCoords&,
                                     const SkMatrix& viewMatrix);
@@ -137,7 +139,8 @@
      * attribute. The view matrix must still be provided to compute correctly transformed
      * coordinates for GrFragmentProcessors. It may fail if the view matrix is not invertible.
      */
-    sk_sp<GrGeometryProcessor> MakeForDeviceSpace(const Color&,
+    sk_sp<GrGeometryProcessor> MakeForDeviceSpace(const GrShaderCaps*,
+                                                  const Color&,
                                                   const Coverage&,
                                                   const LocalCoords&,
                                                   const SkMatrix& viewMatrix);
@@ -147,7 +150,8 @@
      * deformation of vertices using matrices that are passed in. This should only be called from
      * GrDrawVerticesOp.
      */
-    sk_sp<GrGeometryProcessor> MakeWithBones(const Color&,
+    sk_sp<GrGeometryProcessor> MakeWithBones(const GrShaderCaps*,
+                                             const Color&,
                                              const Coverage&,
                                              const LocalCoords&,
                                              const Bones&,
diff --git a/src/gpu/GrPrimitiveProcessor.h b/src/gpu/GrPrimitiveProcessor.h
index 6563ad9..e47d868 100644
--- a/src/gpu/GrPrimitiveProcessor.h
+++ b/src/gpu/GrPrimitiveProcessor.h
@@ -178,6 +178,22 @@
             return 3 * sizeof(int32_t);
         case kInt4_GrVertexAttribType:
             return 4 * sizeof(int32_t);
+        case kByte_GrVertexAttribType:
+            return 1 * sizeof(char);
+        case kByte2_GrVertexAttribType:
+            return 2 * sizeof(char);
+        case kByte3_GrVertexAttribType:
+            return 3 * sizeof(char);
+        case kByte4_GrVertexAttribType:
+            return 4 * sizeof(char);
+        case kUByte_GrVertexAttribType:
+            return 1 * sizeof(char);
+        case kUByte2_GrVertexAttribType:
+            return 2 * sizeof(char);
+        case kUByte3_GrVertexAttribType:
+            return 3 * sizeof(char);
+        case kUByte4_GrVertexAttribType:
+            return 4 * sizeof(char);
         case kUByte_norm_GrVertexAttribType:
             return 1 * sizeof(char);
         case kUByte4_norm_GrVertexAttribType:
diff --git a/src/gpu/GrShaderCaps.h b/src/gpu/GrShaderCaps.h
index ee3681a..a599f1d 100644
--- a/src/gpu/GrShaderCaps.h
+++ b/src/gpu/GrShaderCaps.h
@@ -84,6 +84,8 @@
 
     bool halfIs32Bits() const { return fHalfIs32Bits; }
 
+    bool unsignedSupport() const { return fUnsignedSupport; }
+
     AdvBlendEqInteraction advBlendEqInteraction() const { return fAdvBlendEqInteraction; }
 
     bool mustEnableAdvBlendEqs() const {
@@ -252,6 +254,7 @@
     bool fFPManipulationSupport             : 1;
     bool fFloatIs32Bits                     : 1;
     bool fHalfIs32Bits                      : 1;
+    bool fUnsignedSupport                   : 1;
 
     // Used for specific driver bug work arounds
     bool fCanUseAnyFunctionInShader                   : 1;
diff --git a/src/gpu/gl/GrGLCaps.cpp b/src/gpu/gl/GrGLCaps.cpp
index 1f208c8..5e34c7a 100644
--- a/src/gpu/gl/GrGLCaps.cpp
+++ b/src/gpu/gl/GrGLCaps.cpp
@@ -801,6 +801,9 @@
 
     shaderCaps->fFloatIs32Bits = is_float_fp32(ctxInfo, gli, GR_GL_HIGH_FLOAT);
     shaderCaps->fHalfIs32Bits = is_float_fp32(ctxInfo, gli, GR_GL_MEDIUM_FLOAT);
+
+    // Unsigned integers only supported in and after GLSL 1.30.
+    shaderCaps->fUnsignedSupport = ctxInfo.glslGeneration() >= k130_GrGLSLGeneration;
 }
 
 bool GrGLCaps::hasPathRenderingSupport(const GrGLContextInfo& ctxInfo, const GrGLInterface* gli) {
diff --git a/src/gpu/gl/GrGLVertexArray.cpp b/src/gpu/gl/GrGLVertexArray.cpp
index 68bcf21..deca17d 100644
--- a/src/gpu/gl/GrGLVertexArray.cpp
+++ b/src/gpu/gl/GrGLVertexArray.cpp
@@ -41,6 +41,22 @@
             return {false, 3, GR_GL_INT};
         case kInt4_GrVertexAttribType:
             return {false, 4, GR_GL_INT};
+        case kByte_GrVertexAttribType:
+            return {false, 1, GR_GL_BYTE};
+        case kByte2_GrVertexAttribType:
+            return {false, 2, GR_GL_BYTE};
+        case kByte3_GrVertexAttribType:
+            return {false, 3, GR_GL_BYTE};
+        case kByte4_GrVertexAttribType:
+            return {false, 4, GR_GL_BYTE};
+        case kUByte_GrVertexAttribType:
+            return {false, 1, GR_GL_UNSIGNED_BYTE};
+        case kUByte2_GrVertexAttribType:
+            return {false, 2, GR_GL_UNSIGNED_BYTE};
+        case kUByte3_GrVertexAttribType:
+            return {false, 3, GR_GL_UNSIGNED_BYTE};
+        case kUByte4_GrVertexAttribType:
+            return {false, 4, GR_GL_UNSIGNED_BYTE};
         case kUByte_norm_GrVertexAttribType:
             return {true, 1, GR_GL_UNSIGNED_BYTE};
         case kUByte4_norm_GrVertexAttribType:
@@ -85,6 +101,22 @@
             return true;
         case kInt4_GrVertexAttribType:
             return true;
+        case kByte_GrVertexAttribType:
+            return true;
+        case kByte2_GrVertexAttribType:
+            return true;
+        case kByte3_GrVertexAttribType:
+            return true;
+        case kByte4_GrVertexAttribType:
+            return true;
+        case kUByte_GrVertexAttribType:
+            return true;
+        case kUByte2_GrVertexAttribType:
+            return true;
+        case kUByte3_GrVertexAttribType:
+            return true;
+        case kUByte4_GrVertexAttribType:
+            return true;
         case kUByte_norm_GrVertexAttribType:
             return false;
         case kUByte4_norm_GrVertexAttribType:
diff --git a/src/gpu/glsl/GrGLSL.cpp b/src/gpu/glsl/GrGLSL.cpp
index 67fe299..807fe94 100644
--- a/src/gpu/glsl/GrGLSL.cpp
+++ b/src/gpu/glsl/GrGLSL.cpp
@@ -85,6 +85,22 @@
             return "ushort3";
         case kUShort4_GrSLType:
             return "ushort4";
+        case kByte_GrSLType:
+            return "byte";
+        case kByte2_GrSLType:
+            return "byte2";
+        case kByte3_GrSLType:
+            return "byte3";
+        case kByte4_GrSLType:
+            return "byte4";
+        case kUByte_GrSLType:
+            return "ubyte";
+        case kUByte2_GrSLType:
+            return "ubyte2";
+        case kUByte3_GrSLType:
+            return "ubyte3";
+        case kUByte4_GrSLType:
+            return "ubyte4";
         case kTexture2D_GrSLType:
             return "texture2D";
         case kSampler_GrSLType:
diff --git a/src/gpu/mtl/GrMtlCaps.mm b/src/gpu/mtl/GrMtlCaps.mm
index d3dc543..2527be9 100644
--- a/src/gpu/mtl/GrMtlCaps.mm
+++ b/src/gpu/mtl/GrMtlCaps.mm
@@ -242,6 +242,9 @@
     shaderCaps->fFloatIs32Bits = true;
     shaderCaps->fHalfIs32Bits = false;
 
+    // Metal supports unsigned integers.
+    shaderCaps->fUnsignedSupport = true;
+
     shaderCaps->fMaxVertexSamplers =
     shaderCaps->fMaxFragmentSamplers = 16;
     // For now just cap at the per stage max. If we hit this limit we can come back to adjust this
diff --git a/src/gpu/ops/GrAAConvexPathRenderer.cpp b/src/gpu/ops/GrAAConvexPathRenderer.cpp
index 7f54357..3d475b9 100644
--- a/src/gpu/ops/GrAAConvexPathRenderer.cpp
+++ b/src/gpu/ops/GrAAConvexPathRenderer.cpp
@@ -723,7 +723,8 @@
     }
 }
 
-static sk_sp<GrGeometryProcessor> make_lines_only_gp(bool tweakAlphaForCoverage,
+static sk_sp<GrGeometryProcessor> make_lines_only_gp(const GrShaderCaps* shaderCaps,
+                                                     bool tweakAlphaForCoverage,
                                                      const SkMatrix& viewMatrix,
                                                      bool usesLocalCoords) {
     using namespace GrDefaultGeoProcFactory;
@@ -736,7 +737,10 @@
     }
     LocalCoords::Type localCoordsType =
             usesLocalCoords ? LocalCoords::kUsePosition_Type : LocalCoords::kUnused_Type;
-    return MakeForDeviceSpace(Color::kPremulGrColorAttribute_Type, coverageType, localCoordsType,
+    return MakeForDeviceSpace(shaderCaps,
+                              Color::kPremulGrColorAttribute_Type,
+                              coverageType,
+                              localCoordsType,
                               viewMatrix);
 }
 
@@ -790,7 +794,8 @@
 private:
     void prepareLinesOnlyDraws(Target* target) {
         // Setup GrGeometryProcessor
-        sk_sp<GrGeometryProcessor> gp(make_lines_only_gp(fHelper.compatibleWithAlphaAsCoverage(),
+        sk_sp<GrGeometryProcessor> gp(make_lines_only_gp(target->caps().shaderCaps(),
+                                                         fHelper.compatibleWithAlphaAsCoverage(),
                                                          fPaths.back().fViewMatrix,
                                                          fHelper.usesLocalCoords()));
         if (!gp) {
diff --git a/src/gpu/ops/GrAAFillRectOp.cpp b/src/gpu/ops/GrAAFillRectOp.cpp
index 0d97de49..592c0b2 100644
--- a/src/gpu/ops/GrAAFillRectOp.cpp
+++ b/src/gpu/ops/GrAAFillRectOp.cpp
@@ -255,7 +255,8 @@
         }
 
         sk_sp<GrGeometryProcessor> gp =
-                GrDefaultGeoProcFactory::Make(color, coverageType, lc, SkMatrix::I());
+                GrDefaultGeoProcFactory::Make(target->caps().shaderCaps(), color, coverageType,
+                                              lc, SkMatrix::I());
         if (!gp) {
             SkDebugf("Couldn't create GrGeometryProcessor\n");
             return;
diff --git a/src/gpu/ops/GrAAHairLinePathRenderer.cpp b/src/gpu/ops/GrAAHairLinePathRenderer.cpp
index bed8cbf..d6f3c06 100644
--- a/src/gpu/ops/GrAAHairLinePathRenderer.cpp
+++ b/src/gpu/ops/GrAAHairLinePathRenderer.cpp
@@ -951,7 +951,8 @@
             LocalCoords localCoords(fHelper.usesLocalCoords() ? LocalCoords::kUsePosition_Type
                                                               : LocalCoords::kUnused_Type);
             localCoords.fMatrix = geometryProcessorLocalM;
-            lineGP = GrDefaultGeoProcFactory::Make(color, Coverage::kAttribute_Type, localCoords,
+            lineGP = GrDefaultGeoProcFactory::Make(target->caps().shaderCaps(),
+                                                   color, Coverage::kAttribute_Type, localCoords,
                                                    *geometryProcessorViewM);
         }
 
diff --git a/src/gpu/ops/GrAALinearizingConvexPathRenderer.cpp b/src/gpu/ops/GrAALinearizingConvexPathRenderer.cpp
index 958f0f9..75662d3 100644
--- a/src/gpu/ops/GrAALinearizingConvexPathRenderer.cpp
+++ b/src/gpu/ops/GrAALinearizingConvexPathRenderer.cpp
@@ -112,7 +112,8 @@
     }
 }
 
-static sk_sp<GrGeometryProcessor> create_lines_only_gp(bool tweakAlphaForCoverage,
+static sk_sp<GrGeometryProcessor> create_lines_only_gp(const GrShaderCaps* shaderCaps,
+                                                       bool tweakAlphaForCoverage,
                                                        const SkMatrix& viewMatrix,
                                                        bool usesLocalCoords) {
     using namespace GrDefaultGeoProcFactory;
@@ -125,7 +126,10 @@
     }
     LocalCoords::Type localCoordsType =
             usesLocalCoords ? LocalCoords::kUsePosition_Type : LocalCoords::kUnused_Type;
-    return MakeForDeviceSpace(Color::kPremulGrColorAttribute_Type, coverageType, localCoordsType,
+    return MakeForDeviceSpace(shaderCaps,
+                              Color::kPremulGrColorAttribute_Type,
+                              coverageType,
+                              localCoordsType,
                               viewMatrix);
 }
 
@@ -240,7 +244,8 @@
     void onPrepareDraws(Target* target) override {
         auto pipe = fHelper.makePipeline(target);
         // Setup GrGeometryProcessor
-        sk_sp<GrGeometryProcessor> gp(create_lines_only_gp(fHelper.compatibleWithAlphaAsCoverage(),
+        sk_sp<GrGeometryProcessor> gp(create_lines_only_gp(target->caps().shaderCaps(),
+                                                           fHelper.compatibleWithAlphaAsCoverage(),
                                                            this->viewMatrix(),
                                                            fHelper.usesLocalCoords()));
         if (!gp) {
diff --git a/src/gpu/ops/GrAAStrokeRectOp.cpp b/src/gpu/ops/GrAAStrokeRectOp.cpp
index 1b2ab8e..92d1c01 100644
--- a/src/gpu/ops/GrAAStrokeRectOp.cpp
+++ b/src/gpu/ops/GrAAStrokeRectOp.cpp
@@ -94,7 +94,8 @@
     }
 }
 
-static sk_sp<GrGeometryProcessor> create_stroke_rect_gp(bool tweakAlphaForCoverage,
+static sk_sp<GrGeometryProcessor> create_stroke_rect_gp(const GrShaderCaps* shaderCaps,
+                                                        bool tweakAlphaForCoverage,
                                                         const SkMatrix& viewMatrix,
                                                         bool usesLocalCoords) {
     using namespace GrDefaultGeoProcFactory;
@@ -107,7 +108,10 @@
     }
     LocalCoords::Type localCoordsType =
             usesLocalCoords ? LocalCoords::kUsePosition_Type : LocalCoords::kUnused_Type;
-    return MakeForDeviceSpace(Color::kPremulGrColorAttribute_Type, coverageType, localCoordsType,
+    return MakeForDeviceSpace(shaderCaps,
+                              Color::kPremulGrColorAttribute_Type,
+                              coverageType,
+                              localCoordsType,
                               viewMatrix);
 }
 
@@ -258,7 +262,8 @@
 }  // anonymous namespace
 
 void AAStrokeRectOp::onPrepareDraws(Target* target) {
-    sk_sp<GrGeometryProcessor> gp(create_stroke_rect_gp(fHelper.compatibleWithAlphaAsCoverage(),
+    sk_sp<GrGeometryProcessor> gp(create_stroke_rect_gp(target->caps().shaderCaps(),
+                                                        fHelper.compatibleWithAlphaAsCoverage(),
                                                         this->viewMatrix(),
                                                         fHelper.usesLocalCoords()));
     if (!gp) {
diff --git a/src/gpu/ops/GrDashOp.cpp b/src/gpu/ops/GrDashOp.cpp
index 76203e5..61fad24 100644
--- a/src/gpu/ops/GrDashOp.cpp
+++ b/src/gpu/ops/GrDashOp.cpp
@@ -392,7 +392,10 @@
             Color color(this->color());
             LocalCoords::Type localCoordsType =
                     fUsesLocalCoords ? LocalCoords::kUsePosition_Type : LocalCoords::kUnused_Type;
-            gp = MakeForDeviceSpace(color, Coverage::kSolid_Type, localCoordsType,
+            gp = MakeForDeviceSpace(target->caps().shaderCaps(),
+                                    color,
+                                    Coverage::kSolid_Type,
+                                    localCoordsType,
                                     this->viewMatrix());
         }
 
diff --git a/src/gpu/ops/GrDefaultPathRenderer.cpp b/src/gpu/ops/GrDefaultPathRenderer.cpp
index 9fb1027..07e40f0 100644
--- a/src/gpu/ops/GrDefaultPathRenderer.cpp
+++ b/src/gpu/ops/GrDefaultPathRenderer.cpp
@@ -405,7 +405,11 @@
             Coverage coverage(this->coverage());
             LocalCoords localCoords(fHelper.usesLocalCoords() ? LocalCoords::kUsePosition_Type
                                                               : LocalCoords::kUnused_Type);
-            gp = GrDefaultGeoProcFactory::Make(color, coverage, localCoords, this->viewMatrix());
+            gp = GrDefaultGeoProcFactory::Make(target->caps().shaderCaps(),
+                                               color,
+                                               coverage,
+                                               localCoords,
+                                               this->viewMatrix());
         }
 
         SkASSERT(gp->debugOnly_vertexStride() == sizeof(SkPoint));
diff --git a/src/gpu/ops/GrDrawAtlasOp.cpp b/src/gpu/ops/GrDrawAtlasOp.cpp
index 0f94d7e..d280ad9 100644
--- a/src/gpu/ops/GrDrawAtlasOp.cpp
+++ b/src/gpu/ops/GrDrawAtlasOp.cpp
@@ -13,7 +13,8 @@
 #include "SkRandom.h"
 #include "SkRectPriv.h"
 
-static sk_sp<GrGeometryProcessor> make_gp(bool hasColors,
+static sk_sp<GrGeometryProcessor> make_gp(const GrShaderCaps* shaderCaps,
+                                          bool hasColors,
                                           GrColor color,
                                           const SkMatrix& viewMatrix) {
     using namespace GrDefaultGeoProcFactory;
@@ -22,7 +23,7 @@
         gpColor.fType = Color::kPremulGrColorAttribute_Type;
     }
 
-    return GrDefaultGeoProcFactory::Make(gpColor, Coverage::kSolid_Type,
+    return GrDefaultGeoProcFactory::Make(shaderCaps, gpColor, Coverage::kSolid_Type,
                                          LocalCoords::kHasExplicit_Type, viewMatrix);
 }
 
@@ -119,7 +120,10 @@
 
 void GrDrawAtlasOp::onPrepareDraws(Target* target) {
     // Setup geometry processor
-    sk_sp<GrGeometryProcessor> gp(make_gp(this->hasColors(), this->color(), this->viewMatrix()));
+    sk_sp<GrGeometryProcessor> gp(make_gp(target->caps().shaderCaps(),
+                                          this->hasColors(),
+                                          this->color(),
+                                          this->viewMatrix()));
 
     int instanceCount = fGeoData.count();
     size_t vertexStride =
diff --git a/src/gpu/ops/GrDrawVerticesOp.cpp b/src/gpu/ops/GrDrawVerticesOp.cpp
index 83a703f..b5d16ea 100644
--- a/src/gpu/ops/GrDrawVerticesOp.cpp
+++ b/src/gpu/ops/GrDrawVerticesOp.cpp
@@ -152,7 +152,8 @@
     return result;
 }
 
-sk_sp<GrGeometryProcessor> GrDrawVerticesOp::makeGP(bool* hasColorAttribute,
+sk_sp<GrGeometryProcessor> GrDrawVerticesOp::makeGP(const GrShaderCaps* shaderCaps,
+                                                    bool* hasColorAttribute,
                                                     bool* hasLocalCoordAttribute,
                                                     bool* hasBoneAttribute) const {
     using namespace GrDefaultGeoProcFactory;
@@ -191,13 +192,15 @@
     *hasBoneAttribute = this->hasBones();
 
     if (this->hasBones()) {
-        return GrDefaultGeoProcFactory::MakeWithBones(color,
+        return GrDefaultGeoProcFactory::MakeWithBones(shaderCaps,
+                                                      color,
                                                       Coverage::kSolid_Type,
                                                       localCoordsType,
                                                       bones,
                                                       vm);
     } else {
-        return GrDefaultGeoProcFactory::Make(color,
+        return GrDefaultGeoProcFactory::Make(shaderCaps,
+                                             color,
                                              Coverage::kSolid_Type,
                                              localCoordsType,
                                              vm);
@@ -205,7 +208,8 @@
 }
 
 void GrDrawVerticesOp::onPrepareDraws(Target* target) {
-    if (fMeshes[0].fVertices->isVolatile()) {
+    bool hasMapBufferSupport = GrCaps::kNone_MapFlags != target->caps().mapBufferFlags();
+    if (fMeshes[0].fVertices->isVolatile() || !hasMapBufferSupport) {
         this->drawVolatile(target);
     } else {
         this->drawNonVolatile(target);
@@ -216,7 +220,8 @@
     bool hasColorAttribute;
     bool hasLocalCoordsAttribute;
     bool hasBoneAttribute;
-    sk_sp<GrGeometryProcessor> gp = this->makeGP(&hasColorAttribute,
+    sk_sp<GrGeometryProcessor> gp = this->makeGP(target->caps().shaderCaps(),
+                                                 &hasColorAttribute,
                                                  &hasLocalCoordsAttribute,
                                                  &hasBoneAttribute);
 
@@ -224,7 +229,7 @@
     size_t vertexStride = sizeof(SkPoint) +
                           (hasColorAttribute ? sizeof(uint32_t) : 0) +
                           (hasLocalCoordsAttribute ? sizeof(SkPoint) : 0) +
-                          (hasBoneAttribute ? 4 * (sizeof(uint32_t) + sizeof(float)) : 0);
+                          (hasBoneAttribute ? 4 * (sizeof(int8_t) + sizeof(uint8_t)) : 0);
     SkASSERT(vertexStride == gp->debugOnly_vertexStride());
 
     // Allocate buffers.
@@ -265,7 +270,8 @@
     bool hasColorAttribute;
     bool hasLocalCoordsAttribute;
     bool hasBoneAttribute;
-    sk_sp<GrGeometryProcessor> gp = this->makeGP(&hasColorAttribute,
+    sk_sp<GrGeometryProcessor> gp = this->makeGP(target->caps().shaderCaps(),
+                                                 &hasColorAttribute,
                                                  &hasLocalCoordsAttribute,
                                                  &hasBoneAttribute);
 
@@ -300,7 +306,7 @@
     size_t vertexStride = sizeof(SkPoint) +
                           (hasColorAttribute ? sizeof(uint32_t) : 0) +
                           (hasLocalCoordsAttribute ? sizeof(SkPoint) : 0) +
-                          (hasBoneAttribute ? 4 * (sizeof(uint32_t) + sizeof(float)) : 0);
+                          (hasBoneAttribute ? 4 * (sizeof(int8_t) + sizeof(uint8_t)) : 0);
     SkASSERT(vertexStride == gp->debugOnly_vertexStride());
 
     // Allocate vertex buffer.
@@ -417,7 +423,7 @@
             }
             size_t boneIndexOffset = offset;
             if (hasBoneAttribute) {
-                offset += 4 * sizeof(uint32_t);
+                offset += 4 * sizeof(int8_t);
             }
             size_t boneWeightOffset = offset;
 
@@ -445,10 +451,10 @@
                     const SkVertices::BoneIndices& indices = boneIndices[j];
                     const SkVertices::BoneWeights& weights = boneWeights[j];
                     for (int k = 0; k < 4; k++) {
-                        size_t indexOffset = boneIndexOffset + sizeof(uint32_t) * k;
-                        size_t weightOffset = boneWeightOffset + sizeof(float) * k;
-                        *(uint32_t*)((intptr_t)verts + indexOffset) = indices.indices[k];
-                        *(float*)((intptr_t)verts + weightOffset) = weights.weights[k];
+                        size_t indexOffset = boneIndexOffset + sizeof(int8_t) * k;
+                        size_t weightOffset = boneWeightOffset + sizeof(uint8_t) * k;
+                        *(int8_t*)((intptr_t)verts + indexOffset) = indices.indices[k];
+                        *(uint8_t*)((intptr_t)verts + weightOffset) = weights.weights[k] * 255.0f;
                     }
                 }
                 verts = (void*)((intptr_t)verts + vertexStride);
diff --git a/src/gpu/ops/GrDrawVerticesOp.h b/src/gpu/ops/GrDrawVerticesOp.h
index 9b638b8..7695dd9 100644
--- a/src/gpu/ops/GrDrawVerticesOp.h
+++ b/src/gpu/ops/GrDrawVerticesOp.h
@@ -86,7 +86,8 @@
                       const GrBuffer* indexBuffer,
                       int firstIndex);
 
-    sk_sp<GrGeometryProcessor> makeGP(bool* hasColorAttribute,
+    sk_sp<GrGeometryProcessor> makeGP(const GrShaderCaps* shaderCaps,
+                                      bool* hasColorAttribute,
                                       bool* hasLocalCoordAttribute,
                                       bool* hasBoneAttribute) const;
 
diff --git a/src/gpu/ops/GrNonAAFillRectOp.cpp b/src/gpu/ops/GrNonAAFillRectOp.cpp
index 1b76d4a..c554232 100644
--- a/src/gpu/ops/GrNonAAFillRectOp.cpp
+++ b/src/gpu/ops/GrNonAAFillRectOp.cpp
@@ -29,13 +29,17 @@
 
     The vertex attrib order is always pos, color, [local coords].
  */
-static sk_sp<GrGeometryProcessor> make_gp() {
+static sk_sp<GrGeometryProcessor> make_gp(const GrShaderCaps* shaderCaps) {
     using namespace GrDefaultGeoProcFactory;
-    return GrDefaultGeoProcFactory::Make(Color::kPremulGrColorAttribute_Type, Coverage::kSolid_Type,
-                                         LocalCoords::kHasExplicit_Type, SkMatrix::I());
+    return GrDefaultGeoProcFactory::Make(shaderCaps,
+                                         Color::kPremulGrColorAttribute_Type,
+                                         Coverage::kSolid_Type,
+                                         LocalCoords::kHasExplicit_Type,
+                                         SkMatrix::I());
 }
 
-static sk_sp<GrGeometryProcessor> make_perspective_gp(const SkMatrix& viewMatrix,
+static sk_sp<GrGeometryProcessor> make_perspective_gp(const GrShaderCaps* shaderCaps,
+                                                      const SkMatrix& viewMatrix,
                                                       bool hasExplicitLocalCoords,
                                                       const SkMatrix* localMatrix) {
     SkASSERT(viewMatrix.hasPerspective() || (localMatrix && localMatrix->hasPerspective()));
@@ -50,15 +54,16 @@
         LocalCoords localCoords(hasExplicitLocalCoords ? LocalCoords::kHasExplicit_Type
                                                        : LocalCoords::kUsePosition_Type,
                                 localMatrix);
-        return GrDefaultGeoProcFactory::Make(Color::kPremulGrColorAttribute_Type,
+        return GrDefaultGeoProcFactory::Make(shaderCaps, Color::kPremulGrColorAttribute_Type,
                                              Coverage::kSolid_Type, localCoords, viewMatrix);
     } else if (hasExplicitLocalCoords) {
         LocalCoords localCoords(LocalCoords::kHasExplicit_Type, localMatrix);
-        return GrDefaultGeoProcFactory::Make(Color::kPremulGrColorAttribute_Type,
+        return GrDefaultGeoProcFactory::Make(shaderCaps, Color::kPremulGrColorAttribute_Type,
                                              Coverage::kSolid_Type, localCoords, SkMatrix::I());
     } else {
         LocalCoords localCoords(LocalCoords::kUsePosition_Type, localMatrix);
-        return GrDefaultGeoProcFactory::MakeForDeviceSpace(Color::kPremulGrColorAttribute_Type,
+        return GrDefaultGeoProcFactory::MakeForDeviceSpace(shaderCaps,
+                                                           Color::kPremulGrColorAttribute_Type,
                                                            Coverage::kSolid_Type, localCoords,
                                                            viewMatrix);
     }
@@ -174,7 +179,7 @@
 
 private:
     void onPrepareDraws(Target* target) override {
-        sk_sp<GrGeometryProcessor> gp = make_gp();
+        sk_sp<GrGeometryProcessor> gp = make_gp(target->caps().shaderCaps());
         if (!gp) {
             SkDebugf("Couldn't create GrGeometryProcessor\n");
             return;
@@ -304,7 +309,10 @@
 private:
     void onPrepareDraws(Target* target) override {
         sk_sp<GrGeometryProcessor> gp = make_perspective_gp(
-                fViewMatrix, fHasLocalRect, fHasLocalMatrix ? &fLocalMatrix : nullptr);
+                target->caps().shaderCaps(),
+                fViewMatrix,
+                fHasLocalRect,
+                fHasLocalMatrix ? &fLocalMatrix : nullptr);
         if (!gp) {
             SkDebugf("Couldn't create GrGeometryProcessor\n");
             return;
diff --git a/src/gpu/ops/GrNonAAStrokeRectOp.cpp b/src/gpu/ops/GrNonAAStrokeRectOp.cpp
index 357d923..21636b2 100644
--- a/src/gpu/ops/GrNonAAStrokeRectOp.cpp
+++ b/src/gpu/ops/GrNonAAStrokeRectOp.cpp
@@ -147,7 +147,8 @@
             LocalCoords::Type localCoordsType = fHelper.usesLocalCoords()
                                                         ? LocalCoords::kUsePosition_Type
                                                         : LocalCoords::kUnused_Type;
-            gp = GrDefaultGeoProcFactory::Make(color, Coverage::kSolid_Type, localCoordsType,
+            gp = GrDefaultGeoProcFactory::Make(target->caps().shaderCaps(), color,
+                                               Coverage::kSolid_Type, localCoordsType,
                                                fViewMatrix);
         }
 
diff --git a/src/gpu/ops/GrRegionOp.cpp b/src/gpu/ops/GrRegionOp.cpp
index 852cd46..d0c24e6 100644
--- a/src/gpu/ops/GrRegionOp.cpp
+++ b/src/gpu/ops/GrRegionOp.cpp
@@ -19,10 +19,12 @@
 static const int kVertsPerInstance = 4;
 static const int kIndicesPerInstance = 6;
 
-static sk_sp<GrGeometryProcessor> make_gp(const SkMatrix& viewMatrix) {
+static sk_sp<GrGeometryProcessor> make_gp(const GrShaderCaps* shaderCaps,
+                                          const SkMatrix& viewMatrix) {
     using namespace GrDefaultGeoProcFactory;
-    return GrDefaultGeoProcFactory::Make(Color::kPremulGrColorAttribute_Type, Coverage::kSolid_Type,
-                                         LocalCoords::kUsePosition_Type, viewMatrix);
+    return GrDefaultGeoProcFactory::Make(shaderCaps, Color::kPremulGrColorAttribute_Type,
+                                         Coverage::kSolid_Type, LocalCoords::kUsePosition_Type,
+                                         viewMatrix);
 }
 
 static void tesselate_region(intptr_t vertices,
@@ -109,7 +111,7 @@
 
 private:
     void onPrepareDraws(Target* target) override {
-        sk_sp<GrGeometryProcessor> gp = make_gp(fViewMatrix);
+        sk_sp<GrGeometryProcessor> gp = make_gp(target->caps().shaderCaps(), fViewMatrix);
         if (!gp) {
             SkDebugf("Couldn't create GrGeometryProcessor\n");
             return;
diff --git a/src/gpu/ops/GrTessellatingPathRenderer.cpp b/src/gpu/ops/GrTessellatingPathRenderer.cpp
index 475197e..2fea9cb 100644
--- a/src/gpu/ops/GrTessellatingPathRenderer.cpp
+++ b/src/gpu/ops/GrTessellatingPathRenderer.cpp
@@ -335,10 +335,12 @@
                 coverageType = Coverage::kSolid_Type;
             }
             if (fAntiAlias) {
-                gp = GrDefaultGeoProcFactory::MakeForDeviceSpace(color, coverageType,
+                gp = GrDefaultGeoProcFactory::MakeForDeviceSpace(target->caps().shaderCaps(),
+                                                                 color, coverageType,
                                                                  localCoordsType, fViewMatrix);
             } else {
-                gp = GrDefaultGeoProcFactory::Make(color, coverageType, localCoordsType,
+                gp = GrDefaultGeoProcFactory::Make(target->caps().shaderCaps(),
+                                                   color, coverageType, localCoordsType,
                                                    fViewMatrix);
             }
         }
diff --git a/src/gpu/vk/GrVkCaps.cpp b/src/gpu/vk/GrVkCaps.cpp
index 8181569..8503bea 100644
--- a/src/gpu/vk/GrVkCaps.cpp
+++ b/src/gpu/vk/GrVkCaps.cpp
@@ -399,6 +399,9 @@
     shaderCaps->fFloatIs32Bits = true;
     shaderCaps->fHalfIs32Bits = false;
 
+    // SPIR-V supports unsigned integers.
+    shaderCaps->fUnsignedSupport = true;
+
     shaderCaps->fMaxVertexSamplers =
     shaderCaps->fMaxGeometrySamplers =
     shaderCaps->fMaxFragmentSamplers = SkTMin(
diff --git a/src/gpu/vk/GrVkPipeline.cpp b/src/gpu/vk/GrVkPipeline.cpp
index 91f42ad..60e7f43 100644
--- a/src/gpu/vk/GrVkPipeline.cpp
+++ b/src/gpu/vk/GrVkPipeline.cpp
@@ -34,6 +34,22 @@
             return VK_FORMAT_R32G32B32_SINT;
         case kInt4_GrVertexAttribType:
             return VK_FORMAT_R32G32B32A32_SINT;
+        case kByte_GrVertexAttribType:
+            return VK_FORMAT_R8_SINT;
+        case kByte2_GrVertexAttribType:
+            return VK_FORMAT_R8G8_SINT;
+        case kByte3_GrVertexAttribType:
+            return VK_FORMAT_R8G8B8_SINT;
+        case kByte4_GrVertexAttribType:
+            return VK_FORMAT_R8G8B8A8_SINT;
+        case kUByte_GrVertexAttribType:
+            return VK_FORMAT_R8_UINT;
+        case kUByte2_GrVertexAttribType:
+            return VK_FORMAT_R8G8_UINT;
+        case kUByte3_GrVertexAttribType:
+            return VK_FORMAT_R8G8B8_UINT;
+        case kUByte4_GrVertexAttribType:
+            return VK_FORMAT_R8G8B8A8_UINT;
         case kUByte_norm_GrVertexAttribType:
             return VK_FORMAT_R8_UNORM;
         case kUByte4_norm_GrVertexAttribType:
diff --git a/src/gpu/vk/GrVkUniformHandler.cpp b/src/gpu/vk/GrVkUniformHandler.cpp
index d92d8d2..848d52a 100644
--- a/src/gpu/vk/GrVkUniformHandler.cpp
+++ b/src/gpu/vk/GrVkUniformHandler.cpp
@@ -18,6 +18,17 @@
 // https://www.khronos.org/registry/vulkan/specs/1.0-wsi_extensions/html/vkspec.html#interfaces-resources-layout
 uint32_t grsltype_to_alignment_mask(GrSLType type) {
     switch(type) {
+        case kByte_GrSLType: // fall through
+        case kUByte_GrSLType:
+            return 0x0;
+        case kByte2_GrSLType: // fall through
+        case kUByte2_GrSLType:
+            return 0x1;
+        case kByte3_GrSLType: // fall through
+        case kByte4_GrSLType:
+        case kUByte3_GrSLType:
+        case kUByte4_GrSLType:
+            return 0x3;
         case kShort_GrSLType: // fall through
         case kUShort_GrSLType:
             return 0x1;
@@ -80,6 +91,22 @@
 /** Returns the size in bytes taken up in vulkanbuffers for GrSLTypes. */
 static inline uint32_t grsltype_to_vk_size(GrSLType type) {
     switch(type) {
+        case kByte_GrSLType:
+            return sizeof(int8_t);
+        case kByte2_GrSLType:
+            return 2 * sizeof(int8_t);
+        case kByte3_GrSLType:
+            return 3 * sizeof(int8_t);
+        case kByte4_GrSLType:
+            return 4 * sizeof(int8_t);
+        case kUByte_GrSLType:
+            return sizeof(uint8_t);
+        case kUByte2_GrSLType:
+            return 2 * sizeof(uint8_t);
+        case kUByte3_GrSLType:
+            return 3 * sizeof(uint8_t);
+        case kUByte4_GrSLType:
+            return 4 * sizeof(uint8_t);
         case kShort_GrSLType:
             return sizeof(int16_t);
         case kShort2_GrSLType:
diff --git a/src/gpu/vk/GrVkVaryingHandler.cpp b/src/gpu/vk/GrVkVaryingHandler.cpp
index c8c56c2..d210aba 100644
--- a/src/gpu/vk/GrVkVaryingHandler.cpp
+++ b/src/gpu/vk/GrVkVaryingHandler.cpp
@@ -30,14 +30,20 @@
         case kInt2_GrSLType:
         case kShort2_GrSLType:
         case kUShort2_GrSLType:
+        case kByte2_GrSLType:
+        case kUByte2_GrSLType:
             return 1;
         case kInt3_GrSLType:
         case kShort3_GrSLType:
         case kUShort3_GrSLType:
+        case kByte3_GrSLType:
+        case kUByte3_GrSLType:
             return 1;
         case kInt4_GrSLType:
         case kShort4_GrSLType:
         case kUShort4_GrSLType:
+        case kByte4_GrSLType:
+        case kUByte4_GrSLType:
             return 1;
         case kFloat2x2_GrSLType:
         case kHalf2x2_GrSLType:
@@ -60,9 +66,11 @@
              return 1;
         case kInt_GrSLType: // fall through
         case kShort_GrSLType:
+        case kByte_GrSLType:
              return 1;
-        case kUint_GrSLType:
-        case kUShort_GrSLType: // fall through
+        case kUint_GrSLType: // fall through
+        case kUShort_GrSLType:
+        case kUByte_GrSLType:
              return 1;
         case kTexture2D_GrSLType:
              return 0;
diff --git a/src/sksl/SkSLCPPCodeGenerator.cpp b/src/sksl/SkSLCPPCodeGenerator.cpp
index fe2dc70..be40208 100644
--- a/src/sksl/SkSLCPPCodeGenerator.cpp
+++ b/src/sksl/SkSLCPPCodeGenerator.cpp
@@ -177,7 +177,9 @@
     } else if (type.kind() == Type::kEnum_Kind) {
         this->write("%d");
         fFormatArgs.push_back("(int) " + cppCode);
-    } else if (type == *fContext.fInt4_Type || type == *fContext.fShort4_Type) {
+    } else if (type == *fContext.fInt4_Type ||
+               type == *fContext.fShort4_Type ||
+               type == *fContext.fByte4_Type) {
         this->write(type.name() + "(%d, %d, %d, %d)");
         fFormatArgs.push_back(cppCode + ".left()");
         fFormatArgs.push_back(cppCode + ".top()");
diff --git a/src/sksl/SkSLCompiler.cpp b/src/sksl/SkSLCompiler.cpp
index 0cf55c2..feaafeb 100644
--- a/src/sksl/SkSLCompiler.cpp
+++ b/src/sksl/SkSLCompiler.cpp
@@ -100,6 +100,14 @@
     ADD_TYPE(UShort2);
     ADD_TYPE(UShort3);
     ADD_TYPE(UShort4);
+    ADD_TYPE(Byte);
+    ADD_TYPE(Byte2);
+    ADD_TYPE(Byte3);
+    ADD_TYPE(Byte4);
+    ADD_TYPE(UByte);
+    ADD_TYPE(UByte2);
+    ADD_TYPE(UByte3);
+    ADD_TYPE(UByte4);
     ADD_TYPE(Bool);
     ADD_TYPE(Bool2);
     ADD_TYPE(Bool3);
@@ -149,6 +157,8 @@
     ADD_TYPE(UVec);
     ADD_TYPE(SVec);
     ADD_TYPE(USVec);
+    ADD_TYPE(ByteVec);
+    ADD_TYPE(UByteVec);
     ADD_TYPE(BVec);
 
     ADD_TYPE(Sampler1D);
diff --git a/src/sksl/SkSLContext.h b/src/sksl/SkSLContext.h
index 61dd804..ef2aef0 100644
--- a/src/sksl/SkSLContext.h
+++ b/src/sksl/SkSLContext.h
@@ -49,6 +49,14 @@
     , fShort2_Type(new Type("short2", *fShort_Type, 2))
     , fShort3_Type(new Type("short3", *fShort_Type, 3))
     , fShort4_Type(new Type("short4", *fShort_Type, 4))
+    , fUByte_Type(new Type("ubyte", Type::kUnsigned_NumberKind, 0))
+    , fUByte2_Type(new Type("ubyte2", *fUByte_Type, 2))
+    , fUByte3_Type(new Type("ubyte3", *fUByte_Type, 3))
+    , fUByte4_Type(new Type("ubyte4", *fUByte_Type, 4))
+    , fByte_Type(new Type("byte", Type::kSigned_NumberKind, 0))
+    , fByte2_Type(new Type("byte2", *fByte_Type, 2))
+    , fByte3_Type(new Type("byte3", *fByte_Type, 3))
+    , fByte4_Type(new Type("byte4", *fByte_Type, 4))
     , fBool_Type(new Type("bool", Type::kNonnumeric_NumberKind, -1))
     , fBool2_Type(new Type("bool2", *fBool_Type, 2))
     , fBool3_Type(new Type("bool3", *fBool_Type, 3))
@@ -180,6 +188,10 @@
                                      fShort3_Type.get(), fShort4_Type.get() }))
     , fUSVec_Type(new Type("$usvec", { fInvalid_Type.get(), fUShort2_Type.get(),
                                        fUShort3_Type.get(), fUShort4_Type.get() }))
+    , fByteVec_Type(new Type("$bytevec", { fInvalid_Type.get(), fByte2_Type.get(),
+                                     fByte3_Type.get(), fByte4_Type.get() }))
+    , fUByteVec_Type(new Type("$ubytevec", { fInvalid_Type.get(), fUByte2_Type.get(),
+                                       fUByte3_Type.get(), fUByte4_Type.get() }))
     , fBVec_Type(new Type("$bvec", { fInvalid_Type.get(), fBool2_Type.get(),
                                      fBool3_Type.get(), fBool4_Type.get() }))
     , fSkCaps_Type(new Type("$sk_Caps"))
@@ -230,6 +242,16 @@
     const std::unique_ptr<Type> fShort3_Type;
     const std::unique_ptr<Type> fShort4_Type;
 
+    const std::unique_ptr<Type> fUByte_Type;
+    const std::unique_ptr<Type> fUByte2_Type;
+    const std::unique_ptr<Type> fUByte3_Type;
+    const std::unique_ptr<Type> fUByte4_Type;
+
+    const std::unique_ptr<Type> fByte_Type;
+    const std::unique_ptr<Type> fByte2_Type;
+    const std::unique_ptr<Type> fByte3_Type;
+    const std::unique_ptr<Type> fByte4_Type;
+
     const std::unique_ptr<Type> fBool_Type;
     const std::unique_ptr<Type> fBool2_Type;
     const std::unique_ptr<Type> fBool3_Type;
@@ -328,6 +350,8 @@
     const std::unique_ptr<Type> fUVec_Type;
     const std::unique_ptr<Type> fSVec_Type;
     const std::unique_ptr<Type> fUSVec_Type;
+    const std::unique_ptr<Type> fByteVec_Type;
+    const std::unique_ptr<Type> fUByteVec_Type;
 
     const std::unique_ptr<Type> fBVec_Type;
 
diff --git a/src/sksl/SkSLGLSLCodeGenerator.cpp b/src/sksl/SkSLGLSLCodeGenerator.cpp
index aa4f825..5f6fedc 100644
--- a/src/sksl/SkSLGLSLCodeGenerator.cpp
+++ b/src/sksl/SkSLGLSLCodeGenerator.cpp
@@ -82,10 +82,14 @@
             else if (component == *fContext.fDouble_Type) {
                 result = "dvec";
             }
-            else if (component == *fContext.fInt_Type || component == *fContext.fShort_Type) {
+            else if (component == *fContext.fInt_Type ||
+                     component == *fContext.fShort_Type ||
+                     component == *fContext.fByte_Type) {
                 result = "ivec";
             }
-            else if (component == *fContext.fUInt_Type || component == *fContext.fUShort_Type) {
+            else if (component == *fContext.fUInt_Type ||
+                     component == *fContext.fUShort_Type ||
+                     component == *fContext.fUByte_Type) {
                 result = "uvec";
             }
             else if (component == *fContext.fBool_Type) {
@@ -134,6 +138,12 @@
             else if (type == *fContext.fUShort_Type) {
                 return "uint";
             }
+            else if (type == *fContext.fByte_Type) {
+                return "int";
+            }
+            else if (type == *fContext.fUByte_Type) {
+                return "uint";
+            }
             else {
                 return type.name();
             }
@@ -857,7 +867,9 @@
         this->write(to_string(i.fValue & 0xffffffff) + "u");
     } else if (i.fType == *fContext.fUShort_Type) {
         this->write(to_string(i.fValue & 0xffff) + "u");
-     } else {
+    } else if (i.fType == *fContext.fUByte_Type) {
+        this->write(to_string(i.fValue & 0xff) + "u");
+    } else {
         this->write(to_string((int32_t) i.fValue));
     }
 }
@@ -1018,7 +1030,8 @@
     if (usesPrecisionModifiers()) {
         switch (type.kind()) {
             case Type::kScalar_Kind:
-                if (type == *fContext.fShort_Type || type == *fContext.fUShort_Type) {
+                if (type == *fContext.fShort_Type || type == *fContext.fUShort_Type ||
+                    type == *fContext.fByte_Type || type == *fContext.fUByte_Type) {
                     if (fProgram.fSettings.fForceHighPrecision ||
                             fProgram.fSettings.fCaps->incompleteShortIntPrecision()) {
                         return "highp ";
diff --git a/src/sksl/SkSLHCodeGenerator.cpp b/src/sksl/SkSLHCodeGenerator.cpp
index d6a92d3..be0f1ad 100644
--- a/src/sksl/SkSLHCodeGenerator.cpp
+++ b/src/sksl/SkSLHCodeGenerator.cpp
@@ -33,7 +33,9 @@
         return "float";
     } else if (type == *context.fFloat2_Type || type == *context.fHalf2_Type) {
         return "SkPoint";
-    } else if (type == *context.fInt4_Type || type == *context.fShort4_Type) {
+    } else if (type == *context.fInt4_Type ||
+               type == *context.fShort4_Type ||
+               type == *context.fByte4_Type) {
         return "SkIRect";
     } else if (type == *context.fFloat4_Type || type == *context.fHalf4_Type) {
         return "SkRect";
diff --git a/src/sksl/SkSLJIT.cpp b/src/sksl/SkSLJIT.cpp
index 57286b5..115a6be 100644
--- a/src/sksl/SkSLJIT.cpp
+++ b/src/sksl/SkSLJIT.cpp
@@ -190,13 +190,13 @@
             if (type.name() == "float4" || type.name() == "half4") {
                 return fFloat32Vector4Type;
             }
-            if (type.name() == "int2" || type.name() == "short2") {
+            if (type.name() == "int2" || type.name() == "short2" || type.name == "byte2") {
                 return fInt32Vector2Type;
             }
-            if (type.name() == "int3" || type.name() == "short3") {
+            if (type.name() == "int3" || type.name() == "short3" || type.name == "byte3") {
                 return fInt32Vector3Type;
             }
-            if (type.name() == "int4" || type.name() == "short4") {
+            if (type.name() == "int4" || type.name() == "short4" || type.name == "byte3") {
                 return fInt32Vector4Type;
             }
             // fall through
@@ -402,9 +402,9 @@
     if (type.kind() == Type::kVector_Kind) {
         return this->typeKind(type.componentType());
     }
-    if (type.fName == "int" || type.fName == "short") {
+    if (type.fName == "int" || type.fName == "short" || type.fName == "byte") {
         return JIT::kInt_TypeKind;
-    } else if (type.fName == "uint" || type.fName == "ushort") {
+    } else if (type.fName == "uint" || type.fName == "ushort" || type.fName == "ubyte") {
         return JIT::kUInt_TypeKind;
     } else if (type.fName == "float" || type.fName == "double") {
         return JIT::kFloat_TypeKind;
diff --git a/src/sksl/SkSLSPIRVCodeGenerator.cpp b/src/sksl/SkSLSPIRVCodeGenerator.cpp
index 84a15f1..3357faa 100644
--- a/src/sksl/SkSLSPIRVCodeGenerator.cpp
+++ b/src/sksl/SkSLSPIRVCodeGenerator.cpp
@@ -154,14 +154,16 @@
     if (type.kind() == Type::kVector_Kind) {
         return is_signed(context, type.componentType());
     }
-    return type == *context.fInt_Type || type == *context.fShort_Type;
+    return type == *context.fInt_Type || type == *context.fShort_Type ||
+           type == *context.fByte_Type;
 }
 
 static bool is_unsigned(const Context& context, const Type& type) {
     if (type.kind() == Type::kVector_Kind) {
         return is_unsigned(context, type.componentType());
     }
-    return type == *context.fUInt_Type || type == *context.fUShort_Type;
+    return type == *context.fUInt_Type || type == *context.fUShort_Type ||
+           type == *context.fUByte_Type;
 }
 
 static bool is_bool(const Context& context, const Type& type) {
@@ -433,20 +435,22 @@
     if (type == *fContext.fHalf_Type) {
         return *fContext.fFloat_Type;
     }
-    if (type == *fContext.fShort_Type) {
+    if (type == *fContext.fShort_Type || type == *fContext.fByte_Type) {
         return *fContext.fInt_Type;
     }
-    if (type == *fContext.fUShort_Type) {
+    if (type == *fContext.fUShort_Type || type == *fContext.fUByte_Type) {
         return *fContext.fUInt_Type;
     }
     if (type.kind() == Type::kMatrix_Kind || type.kind() == Type::kVector_Kind) {
         if (type.componentType() == *fContext.fHalf_Type) {
             return fContext.fFloat_Type->toCompound(fContext, type.columns(), type.rows());
         }
-        if (type.componentType() == *fContext.fShort_Type) {
+        if (type.componentType() == *fContext.fShort_Type ||
+            type.componentType() == *fContext.fByte_Type) {
             return fContext.fInt_Type->toCompound(fContext, type.columns(), type.rows());
         }
-        if (type.componentType() == *fContext.fUShort_Type) {
+        if (type.componentType() == *fContext.fUShort_Type ||
+            type.componentType() == *fContext.fUByte_Type) {
             return fContext.fUInt_Type->toCompound(fContext, type.columns(), type.rows());
         }
     }
@@ -1298,31 +1302,47 @@
                     if (c.fArguments.size() == 1) {
                         return vec;
                     }
-                } else if (src == *fContext.fInt_Type || src == *fContext.fShort_Type) {
+                } else if (src == *fContext.fInt_Type ||
+                           src == *fContext.fShort_Type ||
+                           src == *fContext.fByte_Type) {
                     op = SpvOpConvertSToF;
-                } else if (src == *fContext.fUInt_Type || src == *fContext.fUShort_Type) {
+                } else if (src == *fContext.fUInt_Type ||
+                           src == *fContext.fUShort_Type ||
+                           src == *fContext.fUByte_Type) {
                     op = SpvOpConvertUToF;
                 } else {
                     SkASSERT(false);
                 }
-            } else if (dst == *fContext.fInt_Type || dst == *fContext.fShort_Type) {
+            } else if (dst == *fContext.fInt_Type ||
+                       dst == *fContext.fShort_Type ||
+                       dst == *fContext.fByte_Type) {
                 if (src == *fContext.fFloat_Type || src == *fContext.fHalf_Type) {
                     op = SpvOpConvertFToS;
-                } else if (src == *fContext.fInt_Type || src == *fContext.fShort_Type) {
+                } else if (src == *fContext.fInt_Type ||
+                           src == *fContext.fShort_Type ||
+                           src == *fContext.fByte_Type) {
                     if (c.fArguments.size() == 1) {
                         return vec;
                     }
-                } else if (src == *fContext.fUInt_Type || src == *fContext.fUShort_Type) {
+                } else if (src == *fContext.fUInt_Type ||
+                           src == *fContext.fUShort_Type ||
+                           src == *fContext.fUByte_Type) {
                     op = SpvOpBitcast;
                 } else {
                     SkASSERT(false);
                 }
-            } else if (dst == *fContext.fUInt_Type || dst == *fContext.fUShort_Type) {
+            } else if (dst == *fContext.fUInt_Type ||
+                       dst == *fContext.fUShort_Type ||
+                       dst == *fContext.fUByte_Type) {
                 if (src == *fContext.fFloat_Type || src == *fContext.fHalf_Type) {
                     op = SpvOpConvertFToS;
-                } else if (src == *fContext.fInt_Type || src == *fContext.fShort_Type) {
+                } else if (src == *fContext.fInt_Type ||
+                           src == *fContext.fShort_Type ||
+                           src == *fContext.fByte_Type) {
                     op = SpvOpBitcast;
-                } else if (src == *fContext.fUInt_Type || src == *fContext.fUShort_Type) {
+                } else if (src == *fContext.fUInt_Type ||
+                           src == *fContext.fUShort_Type ||
+                           src == *fContext.fUByte_Type) {
                     if (c.fArguments.size() == 1) {
                         return vec;
                     }
@@ -1391,9 +1411,13 @@
     }
     if (c.fType == *fContext.fFloat_Type || c.fType == *fContext.fHalf_Type) {
         return this->writeFloatConstructor(c, out);
-    } else if (c.fType == *fContext.fInt_Type || c.fType == *fContext.fShort_Type) {
+    } else if (c.fType == *fContext.fInt_Type ||
+               c.fType == *fContext.fShort_Type ||
+               c.fType == *fContext.fByte_Type) {
         return this->writeIntConstructor(c, out);
-    } else if (c.fType == *fContext.fUInt_Type || c.fType == *fContext.fUShort_Type) {
+    } else if (c.fType == *fContext.fUInt_Type ||
+               c.fType == *fContext.fUShort_Type ||
+               c.fType == *fContext.fUByte_Type) {
         return this->writeUIntConstructor(c, out);
     }
     switch (c.fType.kind()) {
diff --git a/src/sksl/ir/SkSLSwizzle.h b/src/sksl/ir/SkSLSwizzle.h
index b90b78d..e713a32 100644
--- a/src/sksl/ir/SkSLSwizzle.h
+++ b/src/sksl/ir/SkSLSwizzle.h
@@ -56,6 +56,12 @@
             case 3: return *context.fShort3_Type;
             case 4: return *context.fShort4_Type;
         }
+    } else if (base == *context.fByte_Type) {
+        switch (count) {
+            case 2: return *context.fByte2_Type;
+            case 3: return *context.fByte3_Type;
+            case 4: return *context.fByte4_Type;
+        }
     } else if (base == *context.fUInt_Type) {
         switch (count) {
             case 2: return *context.fUInt2_Type;
@@ -68,6 +74,12 @@
             case 3: return *context.fUShort3_Type;
             case 4: return *context.fUShort4_Type;
         }
+    } else if (base == *context.fUByte_Type) {
+        switch (count) {
+            case 2: return *context.fUByte2_Type;
+            case 3: return *context.fUByte3_Type;
+            case 4: return *context.fUByte4_Type;
+        }
     } else if (base == *context.fBool_Type) {
         switch (count) {
             case 2: return *context.fBool2_Type;
diff --git a/src/sksl/ir/SkSLType.cpp b/src/sksl/ir/SkSLType.cpp
index d569818..eb3a64f 100644
--- a/src/sksl/ir/SkSLType.cpp
+++ b/src/sksl/ir/SkSLType.cpp
@@ -169,6 +169,17 @@
                 }
             default: ABORT("unsupported row count (%d)", rows);
         }
+    } else if (*this == *context.fByte_Type) {
+        switch (rows) {
+            case 1:
+                switch (columns) {
+                    case 2: return *context.fByte2_Type;
+                    case 3: return *context.fByte3_Type;
+                    case 4: return *context.fByte4_Type;
+                    default: ABORT("unsupported vector column count (%d)", columns);
+                }
+            default: ABORT("unsupported row count (%d)", rows);
+        }
     } else if (*this == *context.fUInt_Type) {
         switch (rows) {
             case 1:
@@ -191,6 +202,17 @@
                 }
             default: ABORT("unsupported row count (%d)", rows);
         }
+    } else if (*this == *context.fUByte_Type) {
+        switch (rows) {
+            case 1:
+                switch (columns) {
+                    case 2: return *context.fUByte2_Type;
+                    case 3: return *context.fUByte3_Type;
+                    case 4: return *context.fUByte4_Type;
+                    default: ABORT("unsupported vector column count (%d)", columns);
+                }
+            default: ABORT("unsupported row count (%d)", rows);
+        }
     } else if (*this == *context.fBool_Type) {
         switch (rows) {
             case 1:
diff --git a/tests/OnFlushCallbackTest.cpp b/tests/OnFlushCallbackTest.cpp
index ea871fb..efbc43a 100644
--- a/tests/OnFlushCallbackTest.cpp
+++ b/tests/OnFlushCallbackTest.cpp
@@ -99,7 +99,8 @@
         static const int kLocalOffset = sizeof(SkPoint) + sizeof(GrColor);
 
         sk_sp<GrGeometryProcessor> gp =
-                GrDefaultGeoProcFactory::Make(Color::kPremulGrColorAttribute_Type,
+                GrDefaultGeoProcFactory::Make(target->caps().shaderCaps(),
+                                              Color::kPremulGrColorAttribute_Type,
                                               Coverage::kSolid_Type,
                                               fHasLocalRect ? LocalCoords::kHasExplicit_Type
                                                             : LocalCoords::kUnused_Type,