diff --git a/src/atlastext/SkAtlasTextTarget.cpp b/src/atlastext/SkAtlasTextTarget.cpp
index 2a59790..fcb489e 100644
--- a/src/atlastext/SkAtlasTextTarget.cpp
+++ b/src/atlastext/SkAtlasTextTarget.cpp
@@ -105,7 +105,7 @@
 
     void makeGrPaint(GrMaskFormat, const SkPaint& skPaint, const SkMatrix&,
                      GrPaint* grPaint) override {
-        grPaint->setColor4f(GrColor4f::FromRGBA4f(skPaint.getColor4f().premul()));
+        grPaint->setColor4f(skPaint.getColor4f().premul());
     }
 
     GrContext* getContext() override {
diff --git a/src/core/SkColor.cpp b/src/core/SkColor.cpp
index 8dc3fdd..337dfed 100644
--- a/src/core/SkColor.cpp
+++ b/src/core/SkColor.cpp
@@ -127,6 +127,18 @@
 }
 
 template <>
+uint32_t SkPMColor4f::toBytes_RGBA() const {
+    return Sk4f_toL32(Sk4f::Load(this->vec()));
+}
+
+template <>
+SkPMColor4f SkPMColor4f::FromBytes_RGBA(uint32_t c) {
+    SkPMColor4f color;
+    Sk4f_fromL32(c).store(&color);
+    return color;
+}
+
+template <>
 SkColor4f SkColor4f::Pin(float r, float g, float b, float a) {
     SkColor4f c4;
     Sk4f::Min(Sk4f::Max(Sk4f(r, g, b, a), Sk4f(0)), Sk4f(1)).store(c4.vec());
diff --git a/src/core/SkGlyphRunPainter.cpp b/src/core/SkGlyphRunPainter.cpp
index 90a8c3d..1d4d7da 100644
--- a/src/core/SkGlyphRunPainter.cpp
+++ b/src/core/SkGlyphRunPainter.cpp
@@ -326,12 +326,15 @@
 #if SK_SUPPORT_GPU
 // -- GrTextContext --------------------------------------------------------------------------------
 GrColor generate_filtered_color(const SkPaint& paint, const GrColorSpaceInfo& colorSpaceInfo) {
-    GrColor4f filteredColor = SkColor4fToUnpremulGrColor4f(paint.getColor4f(), colorSpaceInfo);
-    if (paint.getColorFilter() != nullptr) {
-        filteredColor = GrColor4f::FromRGBA4f(paint.getColorFilter()->filterColor4f(
-                filteredColor.asRGBA4f<kUnpremul_SkAlphaType>(),colorSpaceInfo.colorSpace()));
+    SkColor4f filteredColor = paint.getColor4f();
+    if (auto* xform = colorSpaceInfo.colorSpaceXformFromSRGB()) {
+        filteredColor = xform->apply(filteredColor);
     }
-    return filteredColor.premul().toGrColor();
+    if (paint.getColorFilter() != nullptr) {
+        filteredColor = paint.getColorFilter()->filterColor4f(filteredColor,
+                                                              colorSpaceInfo.colorSpace());
+    }
+    return filteredColor.premul().toBytes_RGBA();
 }
 
 void GrTextContext::drawGlyphRunList(
diff --git a/src/gpu/GrPaint.cpp b/src/gpu/GrPaint.cpp
index deed0d4..32b7016 100644
--- a/src/gpu/GrPaint.cpp
+++ b/src/gpu/GrPaint.cpp
@@ -70,7 +70,7 @@
         return false;
     }
     if (kSrc == fXPFactory || (!fXPFactory && fColor.isOpaque())) {
-        *constantColor = fColor.toGrColor();
+        *constantColor = fColor.toBytes_RGBA();
         return true;
     }
     return false;
diff --git a/src/gpu/GrPaint.h b/src/gpu/GrPaint.h
index 5d87eb0..7f5b035 100644
--- a/src/gpu/GrPaint.h
+++ b/src/gpu/GrPaint.h
@@ -47,13 +47,13 @@
     /**
      * The initial color of the drawn primitive. Defaults to solid white.
      */
-    void setColor4f(const GrColor4f& color) { fColor = color; }
-    const GrColor4f& getColor4f() const { return fColor; }
+    void setColor4f(const SkPMColor4f& color) { fColor = color; }
+    const SkPMColor4f& getColor4f() const { return fColor; }
 
     /**
      * Legacy getter, until all code handles 4f directly.
      */
-    GrColor getColor() const { return fColor.toGrColor(); }
+    GrColor getColor() const { return fColor.toBytes_RGBA(); }
 
     void setXPFactory(const GrXPFactory* xpFactory) {
         fXPFactory = xpFactory;
@@ -132,7 +132,7 @@
     SkSTArray<4, std::unique_ptr<GrFragmentProcessor>> fColorFragmentProcessors;
     SkSTArray<2, std::unique_ptr<GrFragmentProcessor>> fCoverageFragmentProcessors;
     bool fTrivial = true;
-    GrColor4f fColor = GrColor4f::OpaqueWhite();
+    SkPMColor4f fColor = SK_PMColor4fWHITE;
 };
 
 #endif
diff --git a/src/gpu/GrProcessorAnalysis.cpp b/src/gpu/GrProcessorAnalysis.cpp
index 1d58870..6c4ffbd 100644
--- a/src/gpu/GrProcessorAnalysis.cpp
+++ b/src/gpu/GrProcessorAnalysis.cpp
@@ -19,7 +19,7 @@
     fProcessorsToEliminate = 0;
     GrColor color;
     if ((fKnowOutputColor = input.isConstant(&color))) {
-        fLastKnownOutputColor = GrColor4f::FromGrColor(color).asRGBA4f<kPremul_SkAlphaType>();
+        fLastKnownOutputColor = SkPMColor4f::FromBytes_RGBA(color);
     }
     for (int i = 0; i < cnt; ++i) {
         if (fUsesLocalCoords && !fKnowOutputColor && !fCompatibleWithCoverageAsAlpha &&
diff --git a/src/gpu/GrProcessorAnalysis.h b/src/gpu/GrProcessorAnalysis.h
index b7475db..6767941 100644
--- a/src/gpu/GrProcessorAnalysis.h
+++ b/src/gpu/GrProcessorAnalysis.h
@@ -124,7 +124,7 @@
      */
     int initialProcessorsToEliminate(GrColor* newPipelineInputColor) const {
         if (fProcessorsToEliminate > 0) {
-            *newPipelineInputColor = GrColor4f::FromRGBA4f(fLastKnownOutputColor).toGrColor();
+            *newPipelineInputColor = fLastKnownOutputColor.toBytes_RGBA();
         }
         return fProcessorsToEliminate;
     }
@@ -141,7 +141,7 @@
      */
     GrProcessorAnalysisColor outputColor() const {
         if (fKnowOutputColor) {
-            return GrColor4f::FromRGBA4f(fLastKnownOutputColor).toGrColor();
+            return fLastKnownOutputColor.toBytes_RGBA();
         }
         return fIsOpaque ? GrProcessorAnalysisColor::Opaque::kYes
                          : GrProcessorAnalysisColor::Opaque::kNo;
diff --git a/src/gpu/GrRenderTargetContext.cpp b/src/gpu/GrRenderTargetContext.cpp
index 6b9e3d1..44ef3cf 100644
--- a/src/gpu/GrRenderTargetContext.cpp
+++ b/src/gpu/GrRenderTargetContext.cpp
@@ -296,7 +296,7 @@
     // It could be done but will take more finagling.
     if (clearRect && fRenderTargetContext->caps()->performPartialClearsAsDraws()) {
         GrPaint paint;
-        paint.setColor4f(GrColor4f::FromGrColor(color));
+        paint.setColor4f(SkPMColor4f::FromBytes_RGBA(color));
         SkRect scissor = SkRect::Make(rtRect);
         std::unique_ptr<GrDrawOp> op(GrRectOpFactory::MakeNonAAFill(fRenderTargetContext->fContext,
                                                                     std::move(paint), SkMatrix::I(),
@@ -345,7 +345,7 @@
     } else {
         if (this->caps()->performPartialClearsAsDraws()) {
             GrPaint paint;
-            paint.setColor4f(GrColor4f::FromGrColor(color));
+            paint.setColor4f(SkPMColor4f::FromBytes_RGBA(color));
             SkRect scissor = SkRect::Make(clip.scissorRect());
             std::unique_ptr<GrDrawOp> op(GrRectOpFactory::MakeNonAAFill(fContext, std::move(paint),
                                                                         SkMatrix::I(), scissor,
diff --git a/src/gpu/SkGr.cpp b/src/gpu/SkGr.cpp
index f78ef18..0406aa3 100644
--- a/src/gpu/SkGr.cpp
+++ b/src/gpu/SkGr.cpp
@@ -254,14 +254,6 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-GrColor4f SkColor4fToUnpremulGrColor4f(SkColor4f c, const GrColorSpaceInfo& colorSpaceInfo) {
-    GrColor4f color = GrColor4f::FromRGBA4f(c);
-    if (auto* xform = colorSpaceInfo.colorSpaceXformFromSRGB()) {
-        color = xform->apply(color);
-    }
-    return color;
-}
-
 SkPMColor4f SkColorToPMColor4f(SkColor c, const GrColorSpaceInfo& colorSpaceInfo) {
     SkColor4f color = SkColor4f::FromColor(c);
     if (auto* xform = colorSpaceInfo.colorSpaceXformFromSRGB()) {
@@ -365,7 +357,10 @@
                                            SkBlendMode* primColorMode,
                                            GrPaint* grPaint) {
     // Convert SkPaint color to 4f format in the destination color space
-    GrColor4f origColor = SkColor4fToUnpremulGrColor4f(skPaint.getColor4f(), colorSpaceInfo);
+    SkColor4f origColor = skPaint.getColor4f();
+    if (auto* xform = colorSpaceInfo.colorSpaceXformFromSRGB()) {
+        origColor = xform->apply(origColor);
+    }
 
     const GrFPArgs fpArgs(context, &viewM, skPaint.getFilterQuality(), &colorSpaceInfo);
 
@@ -396,7 +391,7 @@
             // The geometry processor will insert the primitive color to start the color chain, so
             // the GrPaint color will be ignored.
 
-            SkPMColor4f shaderInput = origColor.opaque().asRGBA4f<kPremul_SkAlphaType>();
+            SkPMColor4f shaderInput = origColor.makeOpaque().premul();
             shaderFP = GrFragmentProcessor::OverrideInput(std::move(shaderFP), shaderInput);
             shaderFP = GrXfermodeFragmentProcessor::MakeFromSrcProcessor(std::move(shaderFP),
                                                                          *primColorMode);
@@ -412,28 +407,29 @@
                 // No gamut conversion - paintAlpha is a (linear) alpha value, splatted to all
                 // color channels. It's value should be treated as the same in ANY color space.
                 grPaint->addColorFragmentProcessor(GrConstColorProcessor::Make(
-                    GrColorToPMColor4f(paintAlpha),
+                    SkPMColor4f::FromBytes_RGBA(paintAlpha),
                     GrConstColorProcessor::InputMode::kModulateRGBA));
             }
         } else {
-            // The shader's FP sees the paint unpremul color
-            grPaint->setColor4f(origColor);
+            // The shader's FP sees the paint *unpremul* color
+            SkPMColor4f origColorAsPM = { origColor.fR, origColor.fG, origColor.fB, origColor.fA };
+            grPaint->setColor4f(origColorAsPM);
             grPaint->addColorFragmentProcessor(std::move(shaderFP));
         }
     } else {
         if (primColorMode) {
             // There is a blend between the primitive color and the paint color. The blend considers
             // the opaque paint color. The paint's alpha is applied to the post-blended color.
-            auto processor = GrConstColorProcessor::Make(
-                    origColor.opaque().asRGBA4f<kPremul_SkAlphaType>(),
-                    GrConstColorProcessor::InputMode::kIgnore);
+            SkPMColor4f opaqueColor = origColor.makeOpaque().premul();
+            auto processor = GrConstColorProcessor::Make(opaqueColor,
+                                                         GrConstColorProcessor::InputMode::kIgnore);
             processor = GrXfermodeFragmentProcessor::MakeFromSrcProcessor(std::move(processor),
                                                                           *primColorMode);
             if (processor) {
                 grPaint->addColorFragmentProcessor(std::move(processor));
             }
 
-            grPaint->setColor4f(origColor.opaque());
+            grPaint->setColor4f(opaqueColor);
 
             // We can ignore origColor here - alpha is unchanged by gamma
             GrColor paintAlpha = GrColorPackA4(skPaint.getAlpha());
@@ -441,7 +437,7 @@
                 // No gamut conversion - paintAlpha is a (linear) alpha value, splatted to all
                 // color channels. It's value should be treated as the same in ANY color space.
                 grPaint->addColorFragmentProcessor(GrConstColorProcessor::Make(
-                    GrColorToPMColor4f(paintAlpha),
+                    SkPMColor4f::FromBytes_RGBA(paintAlpha),
                     GrConstColorProcessor::InputMode::kModulateRGBA));
             }
         } else {
@@ -454,9 +450,8 @@
     SkColorFilter* colorFilter = skPaint.getColorFilter();
     if (colorFilter) {
         if (applyColorFilterToPaintColor) {
-            grPaint->setColor4f(GrColor4f::FromRGBA4f(
-                    colorFilter->filterColor4f(origColor.asRGBA4f<kUnpremul_SkAlphaType>(),
-                                               colorSpaceInfo.colorSpace())).premul());
+            grPaint->setColor4f(
+                    colorFilter->filterColor4f(origColor, colorSpaceInfo.colorSpace()).premul());
         } else {
             auto cfFP = colorFilter->asFragmentProcessor(context, colorSpaceInfo);
             if (cfFP) {
diff --git a/src/gpu/SkGr.h b/src/gpu/SkGr.h
index 2159cd9..d03ac5a 100644
--- a/src/gpu/SkGr.h
+++ b/src/gpu/SkGr.h
@@ -57,10 +57,6 @@
     return GrColorPackRGBA(r, g, b, a);
 }
 
-/** Transform an SkColor (sRGB bytes) or SkColor4f (sRGB floats) to GrColor4f
-    for the specified color space info. */
-GrColor4f SkColor4fToUnpremulGrColor4f(SkColor4f, const GrColorSpaceInfo&);
-
 /** Similar, but using SkPMColor4f. */
 SkPMColor4f SkColorToPMColor4f(SkColor, const GrColorSpaceInfo&);
 
diff --git a/src/gpu/effects/GrConstColorProcessor.cpp b/src/gpu/effects/GrConstColorProcessor.cpp
index 7cf221b..82ef77a 100644
--- a/src/gpu/effects/GrConstColorProcessor.cpp
+++ b/src/gpu/effects/GrConstColorProcessor.cpp
@@ -86,7 +86,7 @@
             uint32_t r = d->fRandom->nextULessThan(a + 1);
             uint32_t g = d->fRandom->nextULessThan(a + 1);
             uint32_t b = d->fRandom->nextULessThan(a + 1);
-            color = GrColorToPMColor4f(GrColorPackRGBA(r, g, b, a));
+            color = SkPMColor4f::FromBytes_RGBA(GrColorPackRGBA(r, g, b, a));
             break;
         }
         case 1:
@@ -94,7 +94,7 @@
             break;
         case 2:
             uint32_t c = d->fRandom->nextULessThan(0x100);
-            color = GrColorToPMColor4f(c | (c << 8) | (c << 16) | (c << 24));
+            color = SkPMColor4f::FromBytes_RGBA(c | (c << 8) | (c << 16) | (c << 24));
             break;
     }
     InputMode mode = static_cast<InputMode>(d->fRandom->nextULessThan(kInputModeCnt));
diff --git a/src/gpu/effects/GrConstColorProcessor.fp b/src/gpu/effects/GrConstColorProcessor.fp
index fd45328..1a301ce 100644
--- a/src/gpu/effects/GrConstColorProcessor.fp
+++ b/src/gpu/effects/GrConstColorProcessor.fp
@@ -71,7 +71,7 @@
             uint32_t r = d->fRandom->nextULessThan(a+1);
             uint32_t g = d->fRandom->nextULessThan(a+1);
             uint32_t b = d->fRandom->nextULessThan(a+1);
-            color = GrColorToPMColor4f(GrColorPackRGBA(r, g, b, a));
+            color = SkPMColor4f::FromBytes_RGBA(GrColorPackRGBA(r, g, b, a));
             break;
         }
         case 1:
@@ -79,7 +79,7 @@
             break;
         case 2:
             uint32_t c = d->fRandom->nextULessThan(0x100);
-            color = GrColorToPMColor4f(c | (c << 8) | (c << 16) | (c << 24));
+            color = SkPMColor4f::FromBytes_RGBA(c | (c << 8) | (c << 16) | (c << 24));
             break;
     }
     InputMode mode = static_cast<InputMode>(d->fRandom->nextULessThan(kInputModeCnt));
diff --git a/src/gpu/mtl/GrMtlGpuCommandBuffer.mm b/src/gpu/mtl/GrMtlGpuCommandBuffer.mm
index 72e5c2e..b982577 100644
--- a/src/gpu/mtl/GrMtlGpuCommandBuffer.mm
+++ b/src/gpu/mtl/GrMtlGpuCommandBuffer.mm
@@ -185,7 +185,8 @@
     // if we end up here from absClear, the clear bounds may be bigger than the RT proxy bounds -
     // but in that case, scissor should be enabled, so this check should still succeed
     SkASSERT(!clip.scissorEnabled() || clip.scissorRect().contains(fBounds));
-    const auto& clear = GrColor4f::FromGrColor(color).fRGBA;
+    float clear[4];
+    GrColorToRGBAFloat(color, clear);
     fRenderPassDesc.colorAttachments[0].clearColor = MTLClearColorMake(clear[0], clear[1], clear[2],
                                                                        clear[3]);
     fRenderPassDesc.colorAttachments[0].loadAction = MTLLoadActionClear;
@@ -241,7 +242,8 @@
             static_cast<GrMtlRenderTarget*>(fRenderTarget)->mtlRenderTexture();
     renderPassDesc.colorAttachments[0].slice = 0;
     renderPassDesc.colorAttachments[0].level = 0;
-    const auto& clearColor = GrColor4f::FromGrColor(fColorLoadAndStoreInfo.fClearColor).fRGBA;
+    float clearColor[4];
+    GrColorToRGBAFloat(fColorLoadAndStoreInfo.fClearColor, clearColor);
     renderPassDesc.colorAttachments[0].clearColor =
             MTLClearColorMake(clearColor[0], clearColor[1], clearColor[2], clearColor[3]);
     renderPassDesc.colorAttachments[0].loadAction =
diff --git a/src/gpu/vk/GrVkGpuCommandBuffer.cpp b/src/gpu/vk/GrVkGpuCommandBuffer.cpp
index e1c795b..edd73fc 100644
--- a/src/gpu/vk/GrVkGpuCommandBuffer.cpp
+++ b/src/gpu/vk/GrVkGpuCommandBuffer.cpp
@@ -99,10 +99,10 @@
                                                                      vkStencilOps);
     }
 
-    cbInfo.fColorClearValue.color.float32[0] = fClearColor.fRGBA[0];
-    cbInfo.fColorClearValue.color.float32[1] = fClearColor.fRGBA[1];
-    cbInfo.fColorClearValue.color.float32[2] = fClearColor.fRGBA[2];
-    cbInfo.fColorClearValue.color.float32[3] = fClearColor.fRGBA[3];
+    cbInfo.fColorClearValue.color.float32[0] = fClearColor[0];
+    cbInfo.fColorClearValue.color.float32[1] = fClearColor[1];
+    cbInfo.fColorClearValue.color.float32[2] = fClearColor[2];
+    cbInfo.fColorClearValue.color.float32[3] = fClearColor[3];
 
     if (VK_ATTACHMENT_LOAD_OP_CLEAR == fVkColorLoadOp) {
         cbInfo.fBounds = SkRect::MakeWH(vkRT->width(), vkRT->height());
@@ -240,7 +240,7 @@
 
     this->INHERITED::set(rt, origin);
 
-    fClearColor = GrColor4f::FromGrColor(colorInfo.fClearColor);
+    GrColorToRGBAFloat(colorInfo.fClearColor, fClearColor);
 
     get_vk_load_store_ops(colorInfo.fLoadOp, colorInfo.fStoreOp,
                           &fVkColorLoadOp, &fVkColorStoreOp);
diff --git a/src/gpu/vk/GrVkGpuCommandBuffer.h b/src/gpu/vk/GrVkGpuCommandBuffer.h
index c00e4ae..6aad0c2 100644
--- a/src/gpu/vk/GrVkGpuCommandBuffer.h
+++ b/src/gpu/vk/GrVkGpuCommandBuffer.h
@@ -199,7 +199,7 @@
     VkAttachmentStoreOp         fVkColorStoreOp;
     VkAttachmentLoadOp          fVkStencilLoadOp;
     VkAttachmentStoreOp         fVkStencilStoreOp;
-    GrColor4f                   fClearColor;
+    float                       fClearColor[4];
     GrVkPipelineState*          fLastPipelineState;
 
     typedef GrGpuRTCommandBuffer INHERITED;
diff --git a/src/shaders/SkPerlinNoiseShader.cpp b/src/shaders/SkPerlinNoiseShader.cpp
index d778448..23b8103 100644
--- a/src/shaders/SkPerlinNoiseShader.cpp
+++ b/src/shaders/SkPerlinNoiseShader.cpp
@@ -1442,7 +1442,7 @@
             // color space of the noise. Either way, this case (and the GLSL) need to convert to
             // the destination.
             auto inner =
-                    GrConstColorProcessor::Make(GrColorToPMColor4f(0x80404040),
+                    GrConstColorProcessor::Make(SkPMColor4f::FromBytes_RGBA(0x80404040),
                                                 GrConstColorProcessor::InputMode::kModulateRGBA);
             return GrFragmentProcessor::MulChildByInputAlpha(std::move(inner));
         }