diff --git a/BUILD.gn b/BUILD.gn
index a5b4d37..6d62efe 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -1243,7 +1243,6 @@
     deps = [
       ":flags",
       ":skia",
-      ":tool_utils",
     ]
     testonly = true
   }
diff --git a/bench/EncoderBench.cpp b/bench/EncoderBench.cpp
index f0adaa1..d7ddfbc 100644
--- a/bench/EncoderBench.cpp
+++ b/bench/EncoderBench.cpp
@@ -11,11 +11,9 @@
 #include "SkData.h"
 #include "SkImageEncoder.h"
 
-#include "sk_tool_utils.h"
-
 class EncodeBench : public Benchmark {
 public:
-    EncodeBench(const char* filename, SkEncodedImageFormat type, int quality)
+    EncodeBench(const char* filename, SkImageEncoder::Type type, int quality)
         : fFilename(filename)
         , fType(type)
         , fQuality(quality)
@@ -25,13 +23,13 @@
         name.append(filename);
         name.append("_");
         switch (type) {
-            case SkEncodedImageFormat::kJPEG:
+            case SkImageEncoder::kJPEG_Type:
                 name.append("JPEG");
                 break;
-            case SkEncodedImageFormat::kPNG:
+            case SkImageEncoder::kPNG_Type:
                 name.append("PNG");
                 break;
-            case SkEncodedImageFormat::kWEBP:
+            case SkImageEncoder::kWEBP_Type:
                 name.append("WEBP");
                 break;
             default:
@@ -56,14 +54,14 @@
 
     void onDraw(int loops, SkCanvas*) override {
         for (int i = 0; i < loops; i++) {
-            sk_sp<SkData> data(sk_tool_utils::EncodeImageToData(fBitmap, fType, fQuality));
+            sk_sp<SkData> data(SkImageEncoder::EncodeData(fBitmap, fType, fQuality));
             SkASSERT(data);
         }
     }
 
 private:
     const char*                fFilename;
-    const SkEncodedImageFormat fType;
+    const SkImageEncoder::Type fType;
     const int                  fQuality;
     SkString                   fName;
     SkBitmap                   fBitmap;
@@ -71,13 +69,13 @@
 
 
 // The Android Photos app uses a quality of 90 on JPEG encodes
-DEF_BENCH(return new EncodeBench("mandrill_512.png", SkEncodedImageFormat::kJPEG, 90));
-DEF_BENCH(return new EncodeBench("color_wheel.jpg", SkEncodedImageFormat::kJPEG, 90));
+DEF_BENCH(return new EncodeBench("mandrill_512.png", SkImageEncoder::kJPEG_Type, 90));
+DEF_BENCH(return new EncodeBench("color_wheel.jpg", SkImageEncoder::kJPEG_Type, 90));
 
 // PNG encodes are lossless so quality should be ignored
-DEF_BENCH(return new EncodeBench("mandrill_512.png", SkEncodedImageFormat::kPNG, 90));
-DEF_BENCH(return new EncodeBench("color_wheel.jpg", SkEncodedImageFormat::kPNG, 90));
+DEF_BENCH(return new EncodeBench("mandrill_512.png", SkImageEncoder::kPNG_Type, 90));
+DEF_BENCH(return new EncodeBench("color_wheel.jpg", SkImageEncoder::kPNG_Type, 90));
 
 // TODO: What is the appropriate quality to use to benchmark WEBP encodes?
-DEF_BENCH(return new EncodeBench("mandrill_512.png", SkEncodedImageFormat::kWEBP, 90));
-DEF_BENCH(return new EncodeBench("color_wheel.jpg", SkEncodedImageFormat::kWEBP, 90));
+DEF_BENCH(return new EncodeBench("mandrill_512.png", SkImageEncoder::kWEBP_Type, 90));
+DEF_BENCH(return new EncodeBench("color_wheel.jpg", SkImageEncoder::kWEBP_Type, 90));
diff --git a/bench/GLBench.cpp b/bench/GLBench.cpp
index cb824da..a39edee 100644
--- a/bench/GLBench.cpp
+++ b/bench/GLBench.cpp
@@ -15,8 +15,6 @@
 #include "SkSLCompiler.h"
 #include <stdio.h>
 
-#include "sk_tool_utils.h"
-
 const GrGLContext* GLBench::getGLContext(SkCanvas* canvas) {
     // This bench exclusively tests GL calls directly
     if (nullptr == canvas->getGrContext()) {
@@ -183,7 +181,7 @@
 
     bm.setPixels(readback.get());
 
-    if (!sk_tool_utils::EncodeImageToFile(filename, bm, SkEncodedImageFormat::kPNG, 100)) {
+    if (!SkImageEncoder::EncodeFile(filename, bm, SkImageEncoder::kPNG_Type, 100)) {
         SkDebugf("------ failed to encode %s\n", filename);
         remove(filename);   // remove any partial file
         return;
diff --git a/bench/nanobench.cpp b/bench/nanobench.cpp
index 3587242..9b4db96 100644
--- a/bench/nanobench.cpp
+++ b/bench/nanobench.cpp
@@ -300,7 +300,7 @@
         SkDebugf("Can't write %s.\n", filename.c_str());
         return false;
     }
-    if (!SkEncodeImage(&stream, bmp, SkEncodedImageFormat::kPNG, 100)) {
+    if (!SkImageEncoder::EncodeStream(&stream, bmp, SkImageEncoder::kPNG_Type, 100)) {
         SkDebugf("Can't encode a PNG.\n");
         return false;
     }
diff --git a/cmake/example.cpp b/cmake/example.cpp
index ca6e55e..38ce901 100644
--- a/cmake/example.cpp
+++ b/cmake/example.cpp
@@ -82,7 +82,7 @@
     // Grab a snapshot of the surface as an immutable SkImage.
     sk_sp<SkImage> image = surface->makeImageSnapshot();
     // Encode that image as a .png into a blob in memory.
-    std::shared_ptr<SkData> png = adopt(image->encode(SkEncodedImageFormat::kPNG, 100));
+    std::shared_ptr<SkData> png = adopt(image->encode(SkImageEncoder::kPNG_Type, 100));
 
     // This code is no longer Skia-specific.  We just dump the .png to disk.  Any way works.
     static const char* path = "example.png";
diff --git a/debugger/QT/SkDebuggerGUI.cpp b/debugger/QT/SkDebuggerGUI.cpp
index 6013183..1437faf 100644
--- a/debugger/QT/SkDebuggerGUI.cpp
+++ b/debugger/QT/SkDebuggerGUI.cpp
@@ -281,7 +281,8 @@
     SkFILEWStream file(filename.c_str());
     sk_sp<SkPicture> copy(fDebugger.copyPicture());
 
-    sk_sp<SkPixelSerializer> serializer(sk_tool_utils::MakePixelSerializer());
+    sk_sp<SkPixelSerializer> serializer(
+            SkImageEncoder::CreatePixelSerializer());
     copy->serialize(&file, serializer.get());
 }
 
diff --git a/dm/DM.cpp b/dm/DM.cpp
index c3e3af4..d42a5f0 100644
--- a/dm/DM.cpp
+++ b/dm/DM.cpp
@@ -524,17 +524,17 @@
     nativeModes.push_back(CodecSrc::kCodec_Mode);
     nativeModes.push_back(CodecSrc::kCodecZeroInit_Mode);
     switch (codec->getEncodedFormat()) {
-        case SkEncodedImageFormat::kJPEG:
+        case SkEncodedFormat::kJPEG_SkEncodedFormat:
             nativeModes.push_back(CodecSrc::kScanline_Mode);
             nativeModes.push_back(CodecSrc::kStripe_Mode);
             nativeModes.push_back(CodecSrc::kCroppedScanline_Mode);
             supportsNativeScaling = true;
             break;
-        case SkEncodedImageFormat::kWEBP:
+        case SkEncodedFormat::kWEBP_SkEncodedFormat:
             nativeModes.push_back(CodecSrc::kSubset_Mode);
             supportsNativeScaling = true;
             break;
-        case SkEncodedImageFormat::kDNG:
+        case SkEncodedFormat::kDNG_SkEncodedFormat:
             break;
         default:
             nativeModes.push_back(CodecSrc::kScanline_Mode);
@@ -547,7 +547,7 @@
     switch (codec->getInfo().colorType()) {
         case kGray_8_SkColorType:
             colorTypes.push_back(CodecSrc::kGrayscale_Always_DstColorType);
-            if (SkEncodedImageFormat::kWBMP == codec->getEncodedFormat()) {
+            if (kWBMP_SkEncodedFormat == codec->getEncodedFormat()) {
                 colorTypes.push_back(CodecSrc::kIndex8_Always_DstColorType);
             }
             break;
@@ -640,15 +640,15 @@
         push_image_gen_src(path, ImageGenSrc::kCodec_Mode, alphaType, false);
 
 #if defined(SK_BUILD_FOR_MAC) || defined(SK_BUILD_FOR_IOS)
-        if (SkEncodedImageFormat::kWEBP != codec->getEncodedFormat() &&
-            SkEncodedImageFormat::kWBMP != codec->getEncodedFormat() &&
+        if (kWEBP_SkEncodedFormat != codec->getEncodedFormat() &&
+            kWBMP_SkEncodedFormat != codec->getEncodedFormat() &&
             kUnpremul_SkAlphaType != alphaType)
         {
             push_image_gen_src(path, ImageGenSrc::kPlatform_Mode, alphaType, false);
         }
 #elif defined(SK_BUILD_FOR_WIN)
-        if (SkEncodedImageFormat::kWEBP != codec->getEncodedFormat() &&
-            SkEncodedImageFormat::kWBMP != codec->getEncodedFormat())
+        if (kWEBP_SkEncodedFormat != codec->getEncodedFormat() &&
+            kWBMP_SkEncodedFormat != codec->getEncodedFormat())
         {
             push_image_gen_src(path, ImageGenSrc::kPlatform_Mode, alphaType, false);
         }
diff --git a/fuzz/fuzz.cpp b/fuzz/fuzz.cpp
index b27eec9..377e53f 100644
--- a/fuzz/fuzz.cpp
+++ b/fuzz/fuzz.cpp
@@ -23,8 +23,6 @@
 
 #include <signal.h>
 
-#include "sk_tool_utils.h"
-
 DEFINE_string2(bytes, b, "", "A path to a file.  This can be the fuzz bytes or a binary to parse.");
 DEFINE_string2(name, n, "", "If --type is 'api', fuzz the API with this name.");
 
@@ -124,7 +122,7 @@
 
 static void dump_png(SkBitmap bitmap) {
     if (!FLAGS_dump.isEmpty()) {
-        sk_tool_utils::EncodeImageToFile(FLAGS_dump[0], bitmap, SkEncodedImageFormat::kPNG, 100);
+        SkImageEncoder::EncodeFile(FLAGS_dump[0], bitmap, SkImageEncoder::kPNG_Type, 100);
         SkDebugf("Dumped to %s\n", FLAGS_dump[0]);
     }
 }
diff --git a/gm/encode-platform.cpp b/gm/encode-platform.cpp
index 0357298..09b64cc 100644
--- a/gm/encode-platform.cpp
+++ b/gm/encode-platform.cpp
@@ -6,11 +6,10 @@
  */
 
 #include "gm.h"
-
 #include "Resources.h"
 #include "SkCanvas.h"
 #include "SkData.h"
-#include "SkImageEncoderPriv.h"
+#include "SkImageEncoder.h"
 #include "SkUnPreMultiply.h"
 
 namespace skiagm {
@@ -37,18 +36,18 @@
     bitmap->setAlphaType(kUnpremul_SkAlphaType);
 }
 
-static SkImageEncoder* make_encoder(SkEncodedImageFormat type) {
+static SkImageEncoder* make_encoder(SkImageEncoder::Type type) {
 #if defined(SK_BUILD_FOR_MAC) || defined(SK_BUILD_FOR_IOS)
-    return CreateImageEncoder_CG((SkImageEncoder::Type)type);
+    return CreateImageEncoder_CG(type);
 #elif defined(SK_BUILD_FOR_WIN)
-    return CreateImageEncoder_WIC((SkImageEncoder::Type)type);
+    return CreateImageEncoder_WIC(type);
 #else
     switch (type) {
-        case SkEncodedImageFormat::kPNG:
+        case SkImageEncoder::kPNG_Type:
             return CreatePNGImageEncoder();
-        case SkEncodedImageFormat::kJPEG:
+        case SkImageEncoder::kJPEG_Type:
             return CreateJPEGImageEncoder();
-        case SkEncodedImageFormat::kWEBP:
+        case SkImageEncoder::kWEBP_Type:
             return CreateWEBPImageEncoder();
         default:
             SkASSERT(false);
@@ -58,28 +57,24 @@
 }
 
 #if defined(SK_BUILD_FOR_MAC) || defined(SK_BUILD_FOR_IOS)
-static SkEncodedImageFormat kTypes[] {
-        SkEncodedImageFormat::kPNG, SkEncodedImageFormat::kJPEG, SkEncodedImageFormat::kGIF,
-        SkEncodedImageFormat::kBMP, SkEncodedImageFormat::kICO,
+static SkImageEncoder::Type kTypes[] {
+        SkImageEncoder::kPNG_Type, SkImageEncoder::kJPEG_Type, SkImageEncoder::kGIF_Type,
+        SkImageEncoder::kBMP_Type, SkImageEncoder::kICO_Type,
 };
 #elif defined(SK_BUILD_FOR_WIN)
 // Use PNG multiple times because our WIC encoder does not support GIF, BMP, or ICO.
-static SkEncodedImageFormat kTypes[] {
-        SkEncodedImageFormat::kPNG, SkEncodedImageFormat::kJPEG, SkEncodedImageFormat::kPNG,
-        SkEncodedImageFormat::kPNG, SkEncodedImageFormat::kPNG,
+static SkImageEncoder::Type kTypes[] {
+        SkImageEncoder::kPNG_Type, SkImageEncoder::kJPEG_Type, SkImageEncoder::kPNG_Type,
+        SkImageEncoder::kPNG_Type, SkImageEncoder::kPNG_Type,
 };
 #else
 // Use WEBP in place of GIF.  Use PNG two extra times.  We don't support GIF, BMP, or ICO.
-static SkEncodedImageFormat kTypes[] {
-        SkEncodedImageFormat::kPNG, SkEncodedImageFormat::kJPEG, SkEncodedImageFormat::kWEBP,
-        SkEncodedImageFormat::kPNG, SkEncodedImageFormat::kPNG,
+static SkImageEncoder::Type kTypes[] {
+        SkImageEncoder::kPNG_Type, SkImageEncoder::kJPEG_Type, SkImageEncoder::kWEBP_Type,
+        SkImageEncoder::kPNG_Type, SkImageEncoder::kPNG_Type,
 };
 #endif
 
-static sk_sp<SkData> encode_data(std::unique_ptr<SkImageEncoder>& encoder, const SkBitmap& src) {
-    SkDynamicMemoryWStream buffer;
-    return encoder->encodeStream(&buffer, src, 100) ? buffer.detachAsData() : nullptr;
-}
 
 class EncodePlatformGM : public GM {
 public:
@@ -100,12 +95,15 @@
         make_premul_256(&premulBm);
         make_unpremul_256(&unpremulBm);
 
-        for (SkEncodedImageFormat type : kTypes) {
+        for (SkImageEncoder::Type type : kTypes) {
             std::unique_ptr<SkImageEncoder> encoder(make_encoder(type));
+            sk_sp<SkData> opaqueData(encoder->encodeData(opaqueBm, 100));
+            sk_sp<SkData> premulData(encoder->encodeData(premulBm, 100));
+            sk_sp<SkData> unpremulData(encoder->encodeData(unpremulBm, 100));
 
-            auto opaqueImage = SkImage::MakeFromEncoded(encode_data(encoder, opaqueBm));
-            auto premulImage = SkImage::MakeFromEncoded(encode_data(encoder, premulBm));
-            auto unpremulImage = SkImage::MakeFromEncoded(encode_data(encoder, unpremulBm));
+            sk_sp<SkImage> opaqueImage = SkImage::MakeFromEncoded(opaqueData);
+            sk_sp<SkImage> premulImage = SkImage::MakeFromEncoded(premulData);
+            sk_sp<SkImage> unpremulImage = SkImage::MakeFromEncoded(unpremulData);
 
             canvas->drawImage(opaqueImage.get(), 0.0f, 0.0f);
             canvas->drawImage(premulImage.get(), 0.0f, 256.0f);
diff --git a/gm/encode.cpp b/gm/encode.cpp
index d4598d0..0cd562a 100644
--- a/gm/encode.cpp
+++ b/gm/encode.cpp
@@ -28,8 +28,8 @@
     void onDraw(SkCanvas* canvas) override {
         SkBitmap orig;
         GetResourceAsBitmap("mandrill_512_q075.jpg", &orig);
-        sk_sp<SkData> pngData(sk_tool_utils::EncodeImageToData(orig, SkEncodedImageFormat::kPNG, 100));
-        sk_sp<SkData> jpegData(sk_tool_utils::EncodeImageToData(orig, SkEncodedImageFormat::kJPEG, 100));
+        sk_sp<SkData> pngData(SkImageEncoder::EncodeData(orig, SkImageEncoder::kPNG_Type, 100));
+        sk_sp<SkData> jpegData(SkImageEncoder::EncodeData(orig, SkImageEncoder::kJPEG_Type, 100));
 
         sk_sp<SkImage> pngImage = SkImage::MakeFromEncoded(pngData);
         sk_sp<SkImage> jpegImage = SkImage::MakeFromEncoded(jpegData);
diff --git a/gm/image.cpp b/gm/image.cpp
index 6545c0a..5454ac3 100644
--- a/gm/image.cpp
+++ b/gm/image.cpp
@@ -348,13 +348,13 @@
 
 static SkImageGenerator* gen_png(const SkImageInfo& info) {
     sk_sp<SkImage> image(make_raster(info, nullptr, draw_opaque_contents));
-    sk_sp<SkData> data(image->encode(SkEncodedImageFormat::kPNG, 100));
+    sk_sp<SkData> data(image->encode(SkImageEncoder::kPNG_Type, 100));
     return SkImageGenerator::NewFromEncoded(data.get());
 }
 
 static SkImageGenerator* gen_jpg(const SkImageInfo& info) {
     sk_sp<SkImage> image(make_raster(info, nullptr, draw_opaque_contents));
-    sk_sp<SkData> data(image->encode(SkEncodedImageFormat::kJPEG, 100));
+    sk_sp<SkData> data(image->encode(SkImageEncoder::kJPEG_Type, 100));
     return SkImageGenerator::NewFromEncoded(data.get());
 }
 
@@ -467,7 +467,7 @@
         // Create encoded image.
         [bmp] {
             sk_sp<SkData> src(
-                sk_tool_utils::EncodeImageToData(bmp, SkEncodedImageFormat::kPNG, 100));
+                SkImageEncoder::EncodeData(bmp, SkImageEncoder::kPNG_Type, 100));
             return SkImage::MakeFromEncoded(std::move(src));
         },
         // Create a picture image.
diff --git a/gm/image_shader.cpp b/gm/image_shader.cpp
index 49b1ed5..924199e 100644
--- a/gm/image_shader.cpp
+++ b/gm/image_shader.cpp
@@ -55,7 +55,7 @@
     if (!src) {
         return nullptr;
     }
-    sk_sp<SkData> encoded(src->encode(SkEncodedImageFormat::kPNG, 100));
+    sk_sp<SkData> encoded(src->encode(SkImageEncoder::kPNG_Type, 100));
     if (!encoded) {
         return nullptr;
     }
diff --git a/gn/android_framework_defines.gni b/gn/android_framework_defines.gni
index a80e38d..90fea2f 100644
--- a/gn/android_framework_defines.gni
+++ b/gn/android_framework_defines.gni
@@ -14,6 +14,5 @@
   "SK_IGNORE_GPU_DITHER",
   "SK_SUPPORT_LEGACY_CANVAS_IS_REFCNT",
   "SK_SUPPORT_LEGACY_CLIP_REGIONOPS",
-  "SK_SUPPORT_LEGACY_IMAGE_ENCODER_CLASS",
   "SK_SUPPORT_LEGACY_SHADER_ISABITMAP",
 ]
diff --git a/include/codec/SkAndroidCodec.h b/include/codec/SkAndroidCodec.h
index ee9d0f3..07d1b13 100644
--- a/include/codec/SkAndroidCodec.h
+++ b/include/codec/SkAndroidCodec.h
@@ -51,7 +51,7 @@
     /**
      *  Format of the encoded data.
      */
-    SkEncodedFormat getEncodedFormat() const { return (SkEncodedFormat)fCodec->getEncodedFormat(); }
+    SkEncodedFormat getEncodedFormat() const { return fCodec->getEncodedFormat(); }
 
     /**
      *  @param requestedColorType Color type requested by the client
@@ -154,7 +154,7 @@
          *
          *  Must be within the bounds returned by getInfo().
          *
-         *  If the EncodedFormat is SkEncodedImageFormat::kWEBP, the top and left
+         *  If the EncodedFormat is kWEBP_SkEncodedFormat, the top and left
          *  values must be even.
          *
          *  The default is NULL, meaning a decode of the entire image.
diff --git a/include/codec/SkCodec.h b/include/codec/SkCodec.h
index ebc2b9a..d5280b4 100644
--- a/include/codec/SkCodec.h
+++ b/include/codec/SkCodec.h
@@ -10,7 +10,7 @@
 
 #include "../private/SkTemplates.h"
 #include "SkColor.h"
-#include "SkEncodedImageFormat.h"
+#include "SkEncodedFormat.h"
 #include "SkEncodedInfo.h"
 #include "SkImageInfo.h"
 #include "SkSize.h"
@@ -176,7 +176,7 @@
     /**
      *  Format of the encoded data.
      */
-    SkEncodedImageFormat getEncodedFormat() const { return this->onGetEncodedFormat(); }
+    SkEncodedFormat getEncodedFormat() const { return this->onGetEncodedFormat(); }
 
     /**
      *  Used to describe the result of a call to getPixels().
@@ -255,7 +255,7 @@
         /**
          *  If not NULL, represents a subset of the original image to decode.
          *  Must be within the bounds returned by getInfo().
-         *  If the EncodedFormat is SkEncodedImageFormat::kWEBP (the only one which
+         *  If the EncodedFormat is kWEBP_SkEncodedFormat (the only one which
          *  currently supports subsets), the top and left values must be even.
          *
          *  In getPixels and incremental decode, we will attempt to decode the
@@ -667,7 +667,7 @@
         return false;
     }
 
-    virtual SkEncodedImageFormat onGetEncodedFormat() const = 0;
+    virtual SkEncodedFormat onGetEncodedFormat() const = 0;
 
     /**
      * @param rowsDecoded When the encoded image stream is incomplete, this function
diff --git a/include/codec/SkEncodedFormat.h b/include/codec/SkEncodedFormat.h
index 114e976..c097e08 100644
--- a/include/codec/SkEncodedFormat.h
+++ b/include/codec/SkEncodedFormat.h
@@ -8,29 +8,21 @@
 #ifndef SkEncodedFormat_DEFINED
 #define SkEncodedFormat_DEFINED
 
-#include "SkEncodedImageFormat.h"
-#include "SkTypes.h"
-
-#ifdef SK_SUPPORT_LEGACY_IMAGE_ENCODER_CLASS
-
+/**
+ *  Enum describing format of encoded data.
+ */
 enum SkEncodedFormat {
-    kBMP_SkEncodedFormat  = (uint8_t)SkEncodedImageFormat::kBMP,
-    kGIF_SkEncodedFormat  = (uint8_t)SkEncodedImageFormat::kGIF,
-    kICO_SkEncodedFormat  = (uint8_t)SkEncodedImageFormat::kICO,
-    kJPEG_SkEncodedFormat = (uint8_t)SkEncodedImageFormat::kJPEG,
-    kPNG_SkEncodedFormat  = (uint8_t)SkEncodedImageFormat::kPNG,
-    kWBMP_SkEncodedFormat = (uint8_t)SkEncodedImageFormat::kWBMP,
-    kWEBP_SkEncodedFormat = (uint8_t)SkEncodedImageFormat::kWEBP,
-    kPKM_SkEncodedFormat  = (uint8_t)SkEncodedImageFormat::kPKM,
-    kKTX_SkEncodedFormat  = (uint8_t)SkEncodedImageFormat::kKTX,
-    kASTC_SkEncodedFormat = (uint8_t)SkEncodedImageFormat::kASTC,
-    kDNG_SkEncodedFormat  = (uint8_t)SkEncodedImageFormat::kDNG,
+    kUnknown_SkEncodedFormat,
+    kBMP_SkEncodedFormat,
+    kGIF_SkEncodedFormat,
+    kICO_SkEncodedFormat,
+    kJPEG_SkEncodedFormat,
+    kPNG_SkEncodedFormat,
+    kWBMP_SkEncodedFormat,
+    kWEBP_SkEncodedFormat,
+    kPKM_SkEncodedFormat,
+    kKTX_SkEncodedFormat,
+    kASTC_SkEncodedFormat,
+    kDNG_SkEncodedFormat,
 };
-
-#else
-
-typedef SkEncodedImageFormat SkEncodedFormat;
-
-#endif  // SK_SUPPORT_LEGACY_IMAGE_ENCODER_CLASS
-
 #endif  // SkEncodedFormat_DEFINED
diff --git a/include/core/SkEncodedImageFormat.h b/include/core/SkEncodedImageFormat.h
deleted file mode 100644
index 8f79236..0000000
--- a/include/core/SkEncodedImageFormat.h
+++ /dev/null
@@ -1,33 +0,0 @@
-/*
- * Copyright 2015 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#ifndef SkEncodedImageFormat_DEFINED
-#define SkEncodedImageFormat_DEFINED
-
-#include <stdint.h>
-
-/**
- *  Enum describing format of encoded data.
- */
-enum class SkEncodedImageFormat {
-#ifdef GOOGLE3
-    kUnknown,
-#endif
-    kBMP,
-    kGIF,
-    kICO,
-    kJPEG,
-    kPNG,
-    kWBMP,
-    kWEBP,
-    kPKM,
-    kKTX,
-    kASTC,
-    kDNG,
-};
-
-#endif  // SkEncodedImageFormat_DEFINED
diff --git a/include/core/SkImage.h b/include/core/SkImage.h
index 625d0a0..02b632b 100644
--- a/include/core/SkImage.h
+++ b/include/core/SkImage.h
@@ -275,12 +275,7 @@
      *  Note: this will attempt to encode the image's pixels in the specified format,
      *  even if the image returns a data from refEncoded(). That data will be ignored.
      */
-    SkData* encode(SkEncodedImageFormat, int quality) const;
-#ifdef SK_SUPPORT_LEGACY_IMAGE_ENCODER_CLASS
-    SkData* encode(SkImageEncoder::Type t, int quality) const {
-        return this->encode((SkEncodedImageFormat)t, quality);
-    }
-#endif
+    SkData* encode(SkImageEncoder::Type, int quality) const;
 
     /**
      *  Encode the image and return the result as a caller-managed SkData.  This will
diff --git a/include/core/SkImageEncoder.h b/include/core/SkImageEncoder.h
index 1d928ae..7d15250 100644
--- a/include/core/SkImageEncoder.h
+++ b/include/core/SkImageEncoder.h
@@ -8,60 +8,32 @@
 #ifndef SkImageEncoder_DEFINED
 #define SkImageEncoder_DEFINED
 
-#include "SkBitmap.h"
-#include "SkEncodedImageFormat.h"
-#include "SkPixelSerializer.h"
-#include "SkStream.h"
+#include "SkImageInfo.h"
+#include "SkTRegistry.h"
 
-/**
- * Encode SkPixmap in the given binary image format.
- *
- * @param  dst     results are written to this stream.
- * @param  src     source pixels.
- * @param  format  image format, not all formats are supported.
- * @param  quality range from 0-100, not all formats respect quality.
- *
- * @return false iff input is bad or format is unsupported.
- *
- * Will always return false if Skia is compiled without image
- * encoders.
- *
- * For examples of encoding an image to a file or to a block of memory,
- * see tools/sk_tool_utils.h.
- */
-SK_API bool SkEncodeImage(SkWStream* dst, const SkPixmap& src,
-                          SkEncodedImageFormat format, int quality);
-/**
- * The following helper function wraps SkEncodeImage().
- */
-inline bool SkEncodeImage(SkWStream* dst, const SkBitmap& src, SkEncodedImageFormat f, int q) {
-    SkAutoLockPixels autoLockPixels(src);
-    SkPixmap pixmap;
-    return src.peekPixels(&pixmap) && SkEncodeImage(dst, pixmap, f, q);
-}
-
-#ifdef SK_SUPPORT_LEGACY_IMAGE_ENCODER_CLASS
-
-////////////////////////////////////////////////////////////////////////////////
+class SkBitmap;
+class SkPixelSerializer;
+class SkPixmap;
+class SkData;
+class SkWStream;
 
 class SkImageEncoder {
 public:
+    // TODO (scroggo): Merge with SkEncodedFormat.
     enum Type {
-#ifdef GOOGLE3
-        kUnknown_Type = (uint8_t)SkEncodedImageFormat::kUnknown,
-#endif
-        kBMP_Type     = (uint8_t)SkEncodedImageFormat::kBMP,
-        kGIF_Type     = (uint8_t)SkEncodedImageFormat::kGIF,
-        kICO_Type     = (uint8_t)SkEncodedImageFormat::kICO,
-        kJPEG_Type    = (uint8_t)SkEncodedImageFormat::kJPEG,
-        kPNG_Type     = (uint8_t)SkEncodedImageFormat::kPNG,
-        kWBMP_Type    = (uint8_t)SkEncodedImageFormat::kWBMP,
-        kWEBP_Type    = (uint8_t)SkEncodedImageFormat::kWEBP,
-        kKTX_Type     = (uint8_t)SkEncodedImageFormat::kKTX,
+        kUnknown_Type,
+        kBMP_Type,
+        kGIF_Type,
+        kICO_Type,
+        kJPEG_Type,
+        kPNG_Type,
+        kWBMP_Type,
+        kWEBP_Type,
+        kKTX_Type,
     };
     static SkImageEncoder* Create(Type);
 
-    virtual ~SkImageEncoder() {}
+    virtual ~SkImageEncoder();
 
     /*  Quality ranges from 0..100 */
     enum {
@@ -74,57 +46,36 @@
      *  encoded, return null. On success, the caller is responsible for
      *  calling unref() on the data when they are finished.
      */
-    SkData* encodeData(const SkBitmap& bm, int quality) {
-        SkDynamicMemoryWStream buffer;
-        return this->encodeStream(&buffer, bm, quality)
-               ? buffer.detachAsData().release()
-               : nullptr;
-    }
+    SkData* encodeData(const SkBitmap&, int quality);
 
     /**
      * Encode bitmap 'bm' in the desired format, writing results to
      * file 'file', at quality level 'quality' (which can be in range
      * 0-100). Returns false on failure.
      */
-    bool encodeFile(const char path[], const SkBitmap& bm, int quality) {
-        SkFILEWStream file(path);
-        return this->encodeStream(&file, bm, quality);
-    }
+    bool encodeFile(const char file[], const SkBitmap& bm, int quality);
 
     /**
      * Encode bitmap 'bm' in the desired format, writing results to
      * stream 'stream', at quality level 'quality' (which can be in
      * range 0-100). Returns false on failure.
      */
-    bool encodeStream(SkWStream* dst, const SkBitmap& src, int quality) {
-        return this->onEncode(dst, src, SkMin32(100, SkMax32(0, quality)));
-    }
+    bool encodeStream(SkWStream* stream, const SkBitmap& bm, int quality);
 
-    static SkData* EncodeData(const SkImageInfo& info, const void* pixels, size_t rowBytes,
-                              Type t, int quality) {
-        SkPixmap pixmap(info, pixels, rowBytes, nullptr);
-        return SkImageEncoder::EncodeData(pixmap, t, quality);
-    }
+    static SkData* EncodeData(const SkImageInfo&, const void* pixels, size_t rowBytes,
+                              Type, int quality);
+    static SkData* EncodeData(const SkBitmap&, Type, int quality);
 
-    static SkData* EncodeData(const SkBitmap& src, Type t, int quality) {
-        SkDynamicMemoryWStream buf;
-        return SkEncodeImage(&buf, src, (SkEncodedImageFormat)t, quality)
-            ? buf.detachAsData().release() : nullptr;
-    }
+    static SkData* EncodeData(const SkPixmap&, Type, int quality);
 
-    static SkData* EncodeData(const SkPixmap& pixmap, Type t, int quality) {
-        SkDynamicMemoryWStream buf;
-        return SkEncodeImage(&buf, pixmap, (SkEncodedImageFormat)t, quality)
-            ? buf.detachAsData().release() : nullptr;
-    }
+    static bool EncodeFile(const char file[], const SkBitmap&, Type,
+                           int quality);
+    static bool EncodeStream(SkWStream*, const SkBitmap&, Type,
+                           int quality);
 
-    static bool EncodeFile(const char path[], const SkBitmap& src, Type t, int quality) {
-        SkFILEWStream file(path);
-        return SkEncodeImage(&file, src, (SkEncodedImageFormat)t, quality);
-    }
-    static bool EncodeStream(SkWStream* dst, const SkBitmap& bm, Type t, int quality) {
-        return SkEncodeImage(dst, bm, (SkEncodedImageFormat)t, quality);
-    }
+    /** Uses SkImageEncoder to serialize images that are not already
+        encoded as SkImageEncoder::kPNG_Type images. */
+    static SkPixelSerializer* CreatePixelSerializer();
 
 protected:
     /**
@@ -137,5 +88,32 @@
     virtual bool onEncode(SkWStream* stream, const SkBitmap& bm, int quality) = 0;
 };
 
-#endif  // SK_SUPPORT_LEGACY_IMAGE_ENCODER_CLASS
-#endif  // SkImageEncoder_DEFINED
+// This macro declares a global (i.e., non-class owned) creation entry point
+// for each encoder (e.g., CreateJPEGImageEncoder)
+#define DECLARE_ENCODER_CREATOR(codec)          \
+    SK_API SkImageEncoder *Create ## codec ();
+
+// This macro defines the global creation entry point for each encoder. Each
+// encoder implementation that registers with the encoder factory must call it.
+#define DEFINE_ENCODER_CREATOR(codec) \
+    SkImageEncoder* Create##codec() { return new Sk##codec; }
+
+// All the encoders known by Skia. Note that, depending on the compiler settings,
+// not all of these will be available
+DECLARE_ENCODER_CREATOR(JPEGImageEncoder);
+DECLARE_ENCODER_CREATOR(PNGImageEncoder);
+DECLARE_ENCODER_CREATOR(KTXImageEncoder);
+DECLARE_ENCODER_CREATOR(WEBPImageEncoder);
+
+#if defined(SK_BUILD_FOR_MAC) || defined(SK_BUILD_FOR_IOS)
+SkImageEncoder* CreateImageEncoder_CG(SkImageEncoder::Type type);
+#endif
+
+#if defined(SK_BUILD_FOR_WIN)
+SkImageEncoder* CreateImageEncoder_WIC(SkImageEncoder::Type type);
+#endif
+
+// Typedef to make registering encoder callback easier
+// This has to be defined outside SkImageEncoder. :(
+typedef SkTRegistry<SkImageEncoder*(*)(SkImageEncoder::Type)> SkImageEncoder_EncodeReg;
+#endif
diff --git a/public.bzl b/public.bzl
index d385279..55f40f8 100644
--- a/public.bzl
+++ b/public.bzl
@@ -599,7 +599,6 @@
     # Staging flags for API changes
     "SK_SUPPORT_LEGACY_ACCESSBITMAP",
     "SK_SUPPORT_LEGACY_CLIP_REGIONOPS",
-    "SK_SUPPORT_LEGACY_IMAGE_ENCODER_CLASS",
     "SK_SUPPORT_LEGACY_XFERMODE_IS_PUBLIC",
     # Temporarily Disable analytic AA for Google3
     "SK_NO_ANALYTIC_AA",
diff --git a/samplecode/SampleApp.cpp b/samplecode/SampleApp.cpp
index a8c2e0b..8a5927f 100644
--- a/samplecode/SampleApp.cpp
+++ b/samplecode/SampleApp.cpp
@@ -1407,8 +1407,8 @@
             static int gSampleGrabCounter;
             SkString name;
             name.printf("sample_grab_%d.png", gSampleGrabCounter++);
-            sk_tool_utils::EncodeImageToFile(name.c_str(), bmp,
-                                       SkEncodedImageFormat::kPNG, 100);
+            SkImageEncoder::EncodeFile(name.c_str(), bmp,
+                                       SkImageEncoder::kPNG_Type, 100);
         }
         this->inval(nullptr);
         return;
diff --git a/samplecode/SampleSlides.cpp b/samplecode/SampleSlides.cpp
index c1c49b4..43221d4 100644
--- a/samplecode/SampleSlides.cpp
+++ b/samplecode/SampleSlides.cpp
@@ -15,8 +15,6 @@
 #include "SkPaint.h"
 #include "SkView.h"
 
-#include "sk_tool_utils.h"
-
 #define BG_COLOR    0xFFDDDDDD
 
 typedef void (*SlideProc)(SkCanvas*);
@@ -683,7 +681,7 @@
             canvas.restore();
             SkString str;
             str.printf("/skimages/slide_" SK_SIZE_T_SPECIFIER ".png", i);
-            sk_tool_utils::EncodeImageToFile(str.c_str(), bm, SkEncodedImageFormat::kPNG, 100);
+            SkImageEncoder::EncodeFile(str.c_str(), bm, SkImageEncoder::kPNG_Type, 100);
         }
         this->setBGColor(BG_COLOR);
     }
diff --git a/src/android/SkBitmapRegionCodec.h b/src/android/SkBitmapRegionCodec.h
index 2c9536c..5c59d52 100644
--- a/src/android/SkBitmapRegionCodec.h
+++ b/src/android/SkBitmapRegionCodec.h
@@ -26,9 +26,7 @@
 
     bool conversionSupported(SkColorType colorType) override;
 
-    SkEncodedFormat getEncodedFormat() override {
-        return (SkEncodedFormat)fCodec->getEncodedFormat();
-    }
+    SkEncodedFormat getEncodedFormat() override { return fCodec->getEncodedFormat(); }
 
 private:
 
diff --git a/src/android/SkBitmapRegionDecoder.cpp b/src/android/SkBitmapRegionDecoder.cpp
index 8298fb5..15a530e 100644
--- a/src/android/SkBitmapRegionDecoder.cpp
+++ b/src/android/SkBitmapRegionDecoder.cpp
@@ -29,10 +29,11 @@
                 return NULL;
             }
 
-            switch ((SkEncodedImageFormat)codec->getEncodedFormat()) {
-                case SkEncodedImageFormat::kJPEG:
-                case SkEncodedImageFormat::kPNG:
-                case SkEncodedImageFormat::kWEBP:
+            SkEncodedFormat format = codec->getEncodedFormat();
+            switch (format) {
+                case SkEncodedFormat::kJPEG_SkEncodedFormat:
+                case SkEncodedFormat::kPNG_SkEncodedFormat:
+                case SkEncodedFormat::kWEBP_SkEncodedFormat:
                     break;
                 default:
                     return nullptr;
diff --git a/src/animator/SkSnapshot.cpp b/src/animator/SkSnapshot.cpp
index 6be1a53..fbaedff 100644
--- a/src/animator/SkSnapshot.cpp
+++ b/src/animator/SkSnapshot.cpp
@@ -30,7 +30,7 @@
 SkSnapshot::SkSnapshot()
 {
     quality     = 100 * SK_Scalar1;
-    type        = (SkEncodedImageFormat) -1;
+    type        = (SkImageEncoder::Type) -1;
     sequence    = false;
     fSeqVal     = 0;
 }
@@ -38,7 +38,7 @@
 bool SkSnapshot::draw(SkAnimateMaker& maker) {
     SkASSERT(type >= 0);
     SkASSERT(filename.size() > 0);
-    SkImageEncoder* encoder = SkImageEncoder::Create((SkEncodedImageFormat) type);
+    SkImageEncoder* encoder = SkImageEncoder::Create((SkImageEncoder::Type) type);
     if (!encoder) {
         return false;
     }
@@ -54,9 +54,9 @@
         if (++fSeqVal > 999)
             sequence = false;
     }
-    if (type == SkEncodedImageFormat::kJPEG)
+    if (type == SkImageEncoder::kJPEG_Type)
         name.append(".jpg");
-    else if (type == SkEncodedImageFormat::kPNG)
+    else if (type == SkImageEncoder::kPNG_Type)
         name.append(".png");
 
     SkBitmap pixels;
diff --git a/src/animator/SkSnapshot.h b/src/animator/SkSnapshot.h
index a802d99..003a9dc 100644
--- a/src/animator/SkSnapshot.h
+++ b/src/animator/SkSnapshot.h
@@ -22,7 +22,7 @@
     SkString filename;
     SkScalar quality;
     SkBool sequence;
-    int /*SkEncodedImageFormat*/    type;
+    int /*SkImageEncoder::Type*/    type;
     int fSeqVal;
 };
 
diff --git a/src/codec/SkAndroidCodec.cpp b/src/codec/SkAndroidCodec.cpp
index c315b03..01605b2 100644
--- a/src/codec/SkAndroidCodec.cpp
+++ b/src/codec/SkAndroidCodec.cpp
@@ -28,24 +28,24 @@
         return nullptr;
     }
 
-    switch ((SkEncodedImageFormat)codec->getEncodedFormat()) {
+    switch (codec->getEncodedFormat()) {
 #ifdef SK_HAS_PNG_LIBRARY
-        case SkEncodedImageFormat::kPNG:
-        case SkEncodedImageFormat::kICO:
+        case kPNG_SkEncodedFormat:
+        case kICO_SkEncodedFormat:
 #endif
 #ifdef SK_HAS_JPEG_LIBRARY
-        case SkEncodedImageFormat::kJPEG:
+        case kJPEG_SkEncodedFormat:
 #endif
-        case SkEncodedImageFormat::kGIF:
-        case SkEncodedImageFormat::kBMP:
-        case SkEncodedImageFormat::kWBMP:
+        case kGIF_SkEncodedFormat:
+        case kBMP_SkEncodedFormat:
+        case kWBMP_SkEncodedFormat:
             return new SkSampledCodec(codec.release());
 #ifdef SK_HAS_WEBP_LIBRARY
-        case SkEncodedImageFormat::kWEBP:
+        case kWEBP_SkEncodedFormat:
             return new SkWebpAdapterCodec((SkWebpCodec*) codec.release());
 #endif
 #ifdef SK_CODEC_DECODES_RAW
-        case SkEncodedImageFormat::kDNG:
+        case kDNG_SkEncodedFormat:
             return new SkRawAdapterCodec((SkRawCodec*)codec.release());
 #endif
         default:
@@ -64,8 +64,8 @@
 SkColorType SkAndroidCodec::computeOutputColorType(SkColorType requestedColorType) {
     // The legacy GIF and WBMP decoders always decode to kIndex_8_SkColorType.
     // We will maintain this behavior.
-    SkEncodedImageFormat format = (SkEncodedImageFormat)this->getEncodedFormat();
-    if (SkEncodedImageFormat::kGIF == format || SkEncodedImageFormat::kWBMP == format) {
+    SkEncodedFormat format = this->getEncodedFormat();
+    if (kGIF_SkEncodedFormat == format || kWBMP_SkEncodedFormat == format) {
         return kIndex_8_SkColorType;
     }
 
diff --git a/src/codec/SkBmpCodec.h b/src/codec/SkBmpCodec.h
index 75740f7..0e38c84 100644
--- a/src/codec/SkBmpCodec.h
+++ b/src/codec/SkBmpCodec.h
@@ -41,7 +41,7 @@
     SkBmpCodec(int width, int height, const SkEncodedInfo& info, SkStream* stream,
             uint16_t bitsPerPixel, SkCodec::SkScanlineOrder rowOrder);
 
-    SkEncodedImageFormat onGetEncodedFormat() const override { return SkEncodedImageFormat::kBMP; }
+    SkEncodedFormat onGetEncodedFormat() const override { return kBMP_SkEncodedFormat; }
 
     /*
      * Read enough of the stream to initialize the SkBmpCodec. Returns a bool
diff --git a/src/codec/SkGifCodec.h b/src/codec/SkGifCodec.h
index 9e980ab..8e93730 100644
--- a/src/codec/SkGifCodec.h
+++ b/src/codec/SkGifCodec.h
@@ -40,8 +40,8 @@
     Result onGetPixels(const SkImageInfo&, void*, size_t, const Options&,
             SkPMColor*, int*, int*) override;
 
-    SkEncodedImageFormat onGetEncodedFormat() const override {
-        return SkEncodedImageFormat::kGIF;
+    SkEncodedFormat onGetEncodedFormat() const override {
+        return kGIF_SkEncodedFormat;
     }
 
     bool onRewind() override;
diff --git a/src/codec/SkIcoCodec.h b/src/codec/SkIcoCodec.h
index e8dcc83..0c4e504 100644
--- a/src/codec/SkIcoCodec.h
+++ b/src/codec/SkIcoCodec.h
@@ -39,8 +39,8 @@
     Result onGetPixels(const SkImageInfo& dstInfo, void* dst, size_t dstRowBytes, const Options&,
             SkPMColor*, int*, int*) override;
 
-    SkEncodedImageFormat onGetEncodedFormat() const override {
-        return SkEncodedImageFormat::kICO;
+    SkEncodedFormat onGetEncodedFormat() const override {
+        return kICO_SkEncodedFormat;
     }
 
     SkScanlineOrder onGetScanlineOrder() const override;
diff --git a/src/codec/SkJpegCodec.h b/src/codec/SkJpegCodec.h
index 9a34aa6..9e08c86 100644
--- a/src/codec/SkJpegCodec.h
+++ b/src/codec/SkJpegCodec.h
@@ -51,8 +51,8 @@
 
     Result onGetYUV8Planes(const SkYUVSizeInfo& sizeInfo, void* planes[3]) override;
 
-    SkEncodedImageFormat onGetEncodedFormat() const override {
-        return SkEncodedImageFormat::kJPEG;
+    SkEncodedFormat onGetEncodedFormat() const override {
+        return kJPEG_SkEncodedFormat;
     }
 
     bool onRewind() override;
diff --git a/src/codec/SkPngCodec.h b/src/codec/SkPngCodec.h
index c246887..590a631 100644
--- a/src/codec/SkPngCodec.h
+++ b/src/codec/SkPngCodec.h
@@ -9,7 +9,7 @@
 #include "SkColorSpaceXform.h"
 #include "SkColorTable.h"
 #include "SkPngChunkReader.h"
-#include "SkEncodedImageFormat.h"
+#include "SkEncodedFormat.h"
 #include "SkImageInfo.h"
 #include "SkRefCnt.h"
 #include "SkSwizzler.h"
@@ -51,7 +51,7 @@
 
     Result onGetPixels(const SkImageInfo&, void*, size_t, const Options&, SkPMColor*, int*, int*)
             override;
-    SkEncodedImageFormat onGetEncodedFormat() const override { return SkEncodedImageFormat::kPNG; }
+    SkEncodedFormat onGetEncodedFormat() const override { return kPNG_SkEncodedFormat; }
     bool onRewind() override;
     uint64_t onGetFillValue(const SkImageInfo&) const override;
 
diff --git a/src/codec/SkRawAdapterCodec.h b/src/codec/SkRawAdapterCodec.h
index 8777180..b552f2a 100644
--- a/src/codec/SkRawAdapterCodec.h
+++ b/src/codec/SkRawAdapterCodec.h
@@ -10,7 +10,7 @@
 
 #include "SkAndroidCodec.h"
 #include "SkCodec.h"
-#include "SkEncodedImageFormat.h"
+#include "SkEncodedFormat.h"
 #include "SkRawCodec.h"
 #include "SkStream.h"
 #include "SkTypes.h"
diff --git a/src/codec/SkRawCodec.h b/src/codec/SkRawCodec.h
index 51bb234..75654c7 100644
--- a/src/codec/SkRawCodec.h
+++ b/src/codec/SkRawCodec.h
@@ -37,8 +37,8 @@
     Result onGetPixels(const SkImageInfo& dstInfo, void* dst, size_t dstRowBytes, const Options&,
             SkPMColor*, int*, int*) override;
 
-    SkEncodedImageFormat onGetEncodedFormat() const override {
-        return SkEncodedImageFormat::kDNG;
+    SkEncodedFormat onGetEncodedFormat() const override {
+        return kDNG_SkEncodedFormat;
     }
 
     SkISize onGetScaledDimensions(float desiredScale) const override;
diff --git a/src/codec/SkSampledCodec.cpp b/src/codec/SkSampledCodec.cpp
index 1d9953b..e70aade 100644
--- a/src/codec/SkSampledCodec.cpp
+++ b/src/codec/SkSampledCodec.cpp
@@ -26,7 +26,7 @@
     }
 
     // Only JPEG supports native downsampling.
-    if (this->codec()->getEncodedFormat() == SkEncodedImageFormat::kJPEG) {
+    if (this->codec()->getEncodedFormat() == kJPEG_SkEncodedFormat) {
         // See if libjpeg supports this scale directly
         switch (sampleSize) {
             case 2:
diff --git a/src/codec/SkWbmpCodec.cpp b/src/codec/SkWbmpCodec.cpp
index 6356e30..19c8c7d 100644
--- a/src/codec/SkWbmpCodec.cpp
+++ b/src/codec/SkWbmpCodec.cpp
@@ -113,8 +113,8 @@
     , fColorTable(nullptr)
 {}
 
-SkEncodedImageFormat SkWbmpCodec::onGetEncodedFormat() const {
-    return SkEncodedImageFormat::kWBMP;
+SkEncodedFormat SkWbmpCodec::onGetEncodedFormat() const {
+    return kWBMP_SkEncodedFormat;
 }
 
 SkCodec::Result SkWbmpCodec::onGetPixels(const SkImageInfo& info,
diff --git a/src/codec/SkWbmpCodec.h b/src/codec/SkWbmpCodec.h
index 40f507e..6946ea0 100644
--- a/src/codec/SkWbmpCodec.h
+++ b/src/codec/SkWbmpCodec.h
@@ -24,7 +24,7 @@
     static SkCodec* NewFromStream(SkStream*);
 
 protected:
-    SkEncodedImageFormat onGetEncodedFormat() const override;
+    SkEncodedFormat onGetEncodedFormat() const override;
     Result onGetPixels(const SkImageInfo&, void*, size_t,
                        const Options&, SkPMColor[], int*, int*) override;
     bool onRewind() override;
diff --git a/src/codec/SkWebpCodec.h b/src/codec/SkWebpCodec.h
index 93b60f6..b9c493f 100644
--- a/src/codec/SkWebpCodec.h
+++ b/src/codec/SkWebpCodec.h
@@ -10,7 +10,7 @@
 
 #include "SkCodec.h"
 #include "SkColorSpace.h"
-#include "SkEncodedImageFormat.h"
+#include "SkEncodedFormat.h"
 #include "SkImageInfo.h"
 #include "SkTypes.h"
 
@@ -30,7 +30,7 @@
 protected:
     Result onGetPixels(const SkImageInfo&, void*, size_t, const Options&, SkPMColor*, int*, int*)
             override;
-    SkEncodedImageFormat onGetEncodedFormat() const override { return SkEncodedImageFormat::kWEBP; }
+    SkEncodedFormat onGetEncodedFormat() const override { return kWEBP_SkEncodedFormat; }
 
     SkISize onGetScaledDimensions(float desiredScale) const override;
 
diff --git a/src/gpu/GrSurface.cpp b/src/gpu/GrSurface.cpp
index 3bb666e..f67bfd4 100644
--- a/src/gpu/GrSurface.cpp
+++ b/src/gpu/GrSurface.cpp
@@ -165,11 +165,6 @@
                                       rowBytes, pixelOpsFlags);
 }
 
-static bool encode_image_to_file(const char* path, const SkBitmap& src) {
-    SkFILEWStream file(path);
-    return file.isValid() && SkEncodeImage(&file, src, SkEncodedImageFormat::kPNG, 100);
-}
-
 // TODO: This should probably be a non-member helper function. It might only be needed in
 // debug or developer builds.
 bool GrSurface::savePixels(const char* filename) {
@@ -188,7 +183,7 @@
     // remove any previous version of this file
     remove(filename);
 
-    if (!encode_image_to_file(filename, bm)) {
+    if (!SkImageEncoder::EncodeFile(filename, bm, SkImageEncoder::kPNG_Type, 100)) {
         SkDebugf("------ failed to encode %s\n", filename);
         remove(filename);   // remove any partial file
         return false;
diff --git a/src/image/SkImage.cpp b/src/image/SkImage.cpp
index e043681..3487b7d 100644
--- a/src/image/SkImage.cpp
+++ b/src/image/SkImage.cpp
@@ -103,22 +103,27 @@
     return SkImageShader::Make(sk_ref_sp(const_cast<SkImage*>(this)), tileX, tileY, localMatrix);
 }
 
-SkData* SkImage::encode(SkEncodedImageFormat type, int quality) const {
+SkData* SkImage::encode(SkImageEncoder::Type type, int quality) const {
     SkBitmap bm;
     // TODO: Right now, the encoders don't handle F16 or linearly premultiplied data. Once they do,
     // we should decode in "color space aware" mode, then re-encode that. For now, work around this
     // by asking for a legacy decode (which gives us the raw data in N32).
     if (as_IB(this)->getROPixels(&bm, SkDestinationSurfaceColorMode::kLegacy)) {
-        SkDynamicMemoryWStream buf;
-        return SkEncodeImage(&buf, bm, type, quality) ? buf.detachAsData().release() : nullptr;
+        return SkImageEncoder::EncodeData(bm, type, quality);
     }
     return nullptr;
 }
 
 SkData* SkImage::encode(SkPixelSerializer* serializer) const {
+    sk_sp<SkPixelSerializer> defaultSerializer;
+    SkPixelSerializer* effectiveSerializer = serializer;
+    if (!effectiveSerializer) {
+        defaultSerializer.reset(SkImageEncoder::CreatePixelSerializer());
+        SkASSERT(defaultSerializer.get());
+        effectiveSerializer = defaultSerializer.get();
+    }
     sk_sp<SkData> encoded(this->refEncoded());
-    if (encoded &&
-        (!serializer || serializer->useEncodedData(encoded->data(), encoded->size()))) {
+    if (encoded && effectiveSerializer->useEncodedData(encoded->data(), encoded->size())) {
         return encoded.release();
     }
 
@@ -129,13 +134,7 @@
     // by asking for a legacy decode (which gives us the raw data in N32).
     if (as_IB(this)->getROPixels(&bm, SkDestinationSurfaceColorMode::kLegacy) &&
         bm.requestLock(&apu)) {
-        if (serializer) {
-            return serializer->encode(apu.pixmap());
-        } else {
-            SkDynamicMemoryWStream buf;
-            return SkEncodeImage(&buf, apu.pixmap(), SkEncodedImageFormat::kPNG, 100)
-                   ? buf.detachAsData().release() : nullptr;
-        }
+        return effectiveSerializer->encode(apu.pixmap());
     }
 
     return nullptr;
@@ -189,7 +188,7 @@
     GrTexture* texture = as_IB(this)->peekTexture();
     if (texture) {
         GrContext* context = texture->getContext();
-        if (context) {
+        if (context) {            
             if (flushPendingGrContextIO) {
                 context->prepareSurfaceForExternalIO(texture);
             }
diff --git a/src/images/SkForceLinking.cpp b/src/images/SkForceLinking.cpp
index dfed6b4..81d485c 100644
--- a/src/images/SkForceLinking.cpp
+++ b/src/images/SkForceLinking.cpp
@@ -5,7 +5,7 @@
  * found in the LICENSE file.
  */
 
-#include "SkImageEncoderPriv.h"
+#include "SkImageEncoder.h"
 #include "SkForceLinking.h"
 
 // This method is required to fool the linker into not discarding the pre-main
@@ -30,10 +30,10 @@
 #endif
 
 #if defined (SK_USE_CG_ENCODER)
-        CreateImageEncoder_CG(SkEncodedImageFormat::kPNG);
+        CreateImageEncoder_CG(SkImageEncoder::kPNG_Type);
 #endif
 #if defined (SK_USE_WIC_ENCODER)
-        CreateImageEncoder_WIC(SkEncodedImageFormat::kPNG);
+        CreateImageEncoder_WIC(SkImageEncoder::kPNG_Type);
 #endif
         return -1;
     }
diff --git a/src/images/SkImageEncoder.cpp b/src/images/SkImageEncoder.cpp
index c137bc5..787ff8e 100644
--- a/src/images/SkImageEncoder.cpp
+++ b/src/images/SkImageEncoder.cpp
@@ -5,15 +5,84 @@
  * found in the LICENSE file.
  */
 
-#include "SkImageEncoderPriv.h"
+#include "SkImageEncoder.h"
+#include "SkBitmap.h"
+#include "SkPixelSerializer.h"
+#include "SkPixmap.h"
+#include "SkStream.h"
+#include "SkTemplates.h"
 
-bool SkEncodeImage(SkWStream* dst, const SkPixmap& src,
-                   SkEncodedImageFormat format, int quality) {
+SkImageEncoder::~SkImageEncoder() {}
+
+bool SkImageEncoder::encodeStream(SkWStream* stream, const SkBitmap& bm,
+                                  int quality) {
+    quality = SkMin32(100, SkMax32(0, quality));
+    return this->onEncode(stream, bm, quality);
+}
+
+bool SkImageEncoder::encodeFile(const char file[], const SkBitmap& bm,
+                                int quality) {
+    quality = SkMin32(100, SkMax32(0, quality));
+    SkFILEWStream   stream(file);
+    return this->onEncode(&stream, bm, quality);
+}
+
+SkData* SkImageEncoder::encodeData(const SkBitmap& bm, int quality) {
+    SkDynamicMemoryWStream stream;
+    quality = SkMin32(100, SkMax32(0, quality));
+    if (this->onEncode(&stream, bm, quality)) {
+        return stream.detachAsData().release();
+    }
+    return nullptr;
+}
+
+bool SkImageEncoder::EncodeFile(const char file[], const SkBitmap& bm, Type t,
+                                int quality) {
+    std::unique_ptr<SkImageEncoder> enc(SkImageEncoder::Create(t));
+    return enc.get() && enc.get()->encodeFile(file, bm, quality);
+}
+
+bool SkImageEncoder::EncodeStream(SkWStream* stream, const SkBitmap& bm, Type t,
+                                  int quality) {
+    std::unique_ptr<SkImageEncoder> enc(SkImageEncoder::Create(t));
+    return enc.get() && enc.get()->encodeStream(stream, bm, quality);
+}
+
+SkData* SkImageEncoder::EncodeData(const SkBitmap& bm, Type t, int quality) {
+    std::unique_ptr<SkImageEncoder> enc(SkImageEncoder::Create(t));
+    return enc.get() ? enc.get()->encodeData(bm, quality) : nullptr;
+}
+
+SkData* SkImageEncoder::EncodeData(const SkImageInfo& info, const void* pixels, size_t rowBytes,
+                                   Type t, int quality) {
     SkBitmap bm;
-    if (!bm.installPixels(src)) {
-        return false;
+    if (!bm.installPixels(info, const_cast<void*>(pixels), rowBytes)) {
+        return nullptr;
     }
     bm.setImmutable();
-    std::unique_ptr<SkImageEncoder> enc(SkImageEncoder::Create((SkImageEncoder::Type)format));
-    return enc && enc->encodeStream(dst, bm, quality);
+    return SkImageEncoder::EncodeData(bm, t, quality);
+}
+
+SkData* SkImageEncoder::EncodeData(const SkPixmap& pixmap,
+                                   Type t, int quality) {
+    SkBitmap bm;
+    if (!bm.installPixels(pixmap)) {
+        return nullptr;
+    }
+    bm.setImmutable();
+    return SkImageEncoder::EncodeData(bm, t, quality);
+}
+
+namespace {
+class ImageEncoderPixelSerializer final : public SkPixelSerializer {
+protected:
+    bool onUseEncodedData(const void*, size_t) override { return true; }
+    SkData* onEncode(const SkPixmap& pmap) override {
+        return SkImageEncoder::EncodeData(pmap, SkImageEncoder::kPNG_Type, 100);
+    }
+};
+} // namespace
+
+SkPixelSerializer* SkImageEncoder::CreatePixelSerializer() {
+    return new ImageEncoderPixelSerializer;
 }
diff --git a/src/images/SkImageEncoderPriv.h b/src/images/SkImageEncoderPriv.h
deleted file mode 100644
index 9b632f5..0000000
--- a/src/images/SkImageEncoderPriv.h
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
- * Copyright 2016 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#ifndef SkImageEncoderPriv_DEFINED
-#define SkImageEncoderPriv_DEFINED
-
-#include "SkImageEncoder.h"
-#include "SkTRegistry.h"
-
-#ifndef SK_SUPPORT_LEGACY_IMAGE_ENCODER_CLASS
-
-    // TODO(halcanary): replace this class and registry system with something simpler.
-    class SkImageEncoder {
-    public:
-        typedef SkEncodedImageFormat Type;
-        static SkImageEncoder* Create(SkEncodedImageFormat);
-
-        virtual ~SkImageEncoder() {}
-
-        bool encodeStream(SkWStream* dst, const SkBitmap& src, int quality) {
-            return this->onEncode(dst, src, SkMin32(100, SkMax32(0, quality)));
-        }
-
-    protected:
-        /**
-         * Encode bitmap 'bm' in the desired format, writing results to
-         * stream 'stream', at quality level 'quality' (which can be in
-         * range 0-100).
-         */
-        virtual bool onEncode(SkWStream* stream, const SkBitmap& bm, int quality) = 0;
-    };
-
-#endif  // SK_SUPPORT_LEGACY_IMAGE_ENCODER_CLASS
-
-// This macro declares a global (i.e., non-class owned) creation entry point
-// for each encoder (e.g., CreateJPEGImageEncoder)
-#define DECLARE_ENCODER_CREATOR(codec)          \
-    SK_API SkImageEncoder *Create ## codec ();
-
-// This macro defines the global creation entry point for each encoder. Each
-// encoder implementation that registers with the encoder factory must call it.
-#define DEFINE_ENCODER_CREATOR(codec) \
-    SkImageEncoder* Create##codec() { return new Sk##codec; }
-
-// All the encoders known by Skia. Note that, depending on the compiler settings,
-// not all of these will be available
-DECLARE_ENCODER_CREATOR(JPEGImageEncoder);
-DECLARE_ENCODER_CREATOR(PNGImageEncoder);
-DECLARE_ENCODER_CREATOR(KTXImageEncoder);
-DECLARE_ENCODER_CREATOR(WEBPImageEncoder);
-
-#if defined(SK_BUILD_FOR_MAC) || defined(SK_BUILD_FOR_IOS)
-SkImageEncoder* CreateImageEncoder_CG(SkImageEncoder::Type type);
-#endif
-
-#if defined(SK_BUILD_FOR_WIN)
-SkImageEncoder* CreateImageEncoder_WIC(SkImageEncoder::Type type);
-#endif
-
-// Typedef to make registering encoder callback easier
-// This has to be defined outside SkImageEncoder. :(
-typedef SkTRegistry<SkImageEncoder*(*)(SkImageEncoder::Type)> SkImageEncoder_EncodeReg;
-
-#endif // SkImageEncoderPriv_DEFINED
diff --git a/src/images/SkImageEncoder_Factory.cpp b/src/images/SkImageEncoder_Factory.cpp
index a5ae8d0..887ce55 100644
--- a/src/images/SkImageEncoder_Factory.cpp
+++ b/src/images/SkImageEncoder_Factory.cpp
@@ -5,11 +5,11 @@
  * found in the LICENSE file.
  */
 
-#include "SkImageEncoderPriv.h"
+#include "SkImageEncoder.h"
 
 template SkImageEncoder_EncodeReg* SkImageEncoder_EncodeReg::gHead;
 
-SkImageEncoder* SkImageEncoder::Create(SkImageEncoder::Type t) {
+SkImageEncoder* SkImageEncoder::Create(Type t) {
     SkImageEncoder* codec = nullptr;
     const SkImageEncoder_EncodeReg* curr = SkImageEncoder_EncodeReg::Head();
     while (curr) {
diff --git a/src/images/SkJPEGImageEncoder.cpp b/src/images/SkJPEGImageEncoder.cpp
index 97b8bbc..66b2440 100644
--- a/src/images/SkJPEGImageEncoder.cpp
+++ b/src/images/SkJPEGImageEncoder.cpp
@@ -5,20 +5,20 @@
  * found in the LICENSE file.
  */
 
-#include "SkImageEncoderPriv.h"
 
-#include "SkCanvas.h"
+#include "SkImageEncoder.h"
 #include "SkColorPriv.h"
 #include "SkDither.h"
-#include "SkJPEGWriteUtility.h"
-#include "SkRect.h"
 #include "SkStream.h"
 #include "SkTemplates.h"
 #include "SkTime.h"
 #include "SkUtils.h"
+#include "SkRect.h"
+#include "SkCanvas.h"
+
 
 #include <stdio.h>
-
+#include "SkJPEGWriteUtility.h"
 extern "C" {
     #include "jpeglib.h"
     #include "jerror.h"
@@ -178,7 +178,7 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 static SkImageEncoder* sk_libjpeg_efactory(SkImageEncoder::Type t) {
-    return (SkEncodedImageFormat::kJPEG == (SkEncodedImageFormat)t) ? new SkJPEGImageEncoder : nullptr;
+    return (SkImageEncoder::kJPEG_Type == t) ? new SkJPEGImageEncoder : nullptr;
 }
 
 static SkImageEncoder_EncodeReg gEReg(sk_libjpeg_efactory);
diff --git a/src/images/SkKTXImageEncoder.cpp b/src/images/SkKTXImageEncoder.cpp
index 6717bea..62c0346 100644
--- a/src/images/SkKTXImageEncoder.cpp
+++ b/src/images/SkKTXImageEncoder.cpp
@@ -6,7 +6,7 @@
  */
 
 #include "SkColorPriv.h"
-#include "SkImageEncoderPriv.h"
+#include "SkImageEncoder.h"
 #include "SkImageGenerator.h"
 #include "SkPixelRef.h"
 #include "SkStream.h"
@@ -40,7 +40,7 @@
 DEFINE_ENCODER_CREATOR(KTXImageEncoder);
 
 SkImageEncoder* sk_libktx_efactory(SkImageEncoder::Type t) {
-    return (SkEncodedImageFormat::kKTX == (SkEncodedImageFormat)t) ? new SkKTXImageEncoder : nullptr;
+    return (SkImageEncoder::kKTX_Type == t) ? new SkKTXImageEncoder : nullptr;
 }
 
 static SkImageEncoder_EncodeReg gEReg(sk_libktx_efactory);
diff --git a/src/images/SkPNGImageEncoder.cpp b/src/images/SkPNGImageEncoder.cpp
index 4fc3a10..69a53fb 100644
--- a/src/images/SkPNGImageEncoder.cpp
+++ b/src/images/SkPNGImageEncoder.cpp
@@ -5,7 +5,7 @@
  * found in the LICENSE file.
  */
 
-#include "SkImageEncoderPriv.h"
+#include "SkImageEncoder.h"
 #include "SkColor.h"
 #include "SkColorPriv.h"
 #include "SkDither.h"
@@ -356,7 +356,7 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 SkImageEncoder* sk_libpng_efactory(SkImageEncoder::Type t) {
-    return (SkEncodedImageFormat::kPNG == (SkEncodedImageFormat)t) ? new SkPNGImageEncoder : nullptr;
+    return (SkImageEncoder::kPNG_Type == t) ? new SkPNGImageEncoder : nullptr;
 }
 
 static SkImageEncoder_EncodeReg gEReg(sk_libpng_efactory);
diff --git a/src/images/SkWEBPImageEncoder.cpp b/src/images/SkWEBPImageEncoder.cpp
index 27c984a..116608a 100644
--- a/src/images/SkWEBPImageEncoder.cpp
+++ b/src/images/SkWEBPImageEncoder.cpp
@@ -15,7 +15,7 @@
  */
 
 #include "SkBitmap.h"
-#include "SkImageEncoderPriv.h"
+#include "SkImageEncoder.h"
 #include "SkColorPriv.h"
 #include "SkStream.h"
 #include "SkTemplates.h"
@@ -241,7 +241,7 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 static SkImageEncoder* sk_libwebp_efactory(SkImageEncoder::Type t) {
-    return (SkEncodedImageFormat::kWEBP == (SkEncodedImageFormat)t) ? new SkWEBPImageEncoder : nullptr;
+    return (SkImageEncoder::kWEBP_Type == t) ? new SkWEBPImageEncoder : nullptr;
 }
 
 static SkImageEncoder_EncodeReg gEReg(sk_libwebp_efactory);
diff --git a/src/ports/SkImageEncoder_CG.cpp b/src/ports/SkImageEncoder_CG.cpp
index 0c3d22d..7892856 100644
--- a/src/ports/SkImageEncoder_CG.cpp
+++ b/src/ports/SkImageEncoder_CG.cpp
@@ -12,7 +12,7 @@
 #include "SkCGUtils.h"
 #include "SkColorPriv.h"
 #include "SkData.h"
-#include "SkImageEncoderPriv.h"
+#include "SkImageEncoder.h"
 #include "SkStream.h"
 #include "SkStreamPriv.h"
 #include "SkTemplates.h"
@@ -59,13 +59,13 @@
 
 class SkImageEncoder_CG : public SkImageEncoder {
 public:
-    SkImageEncoder_CG(SkEncodedImageFormat t) : fType(t) {}
+    SkImageEncoder_CG(Type t) : fType(t) {}
 
 protected:
     virtual bool onEncode(SkWStream* stream, const SkBitmap& bm, int quality);
 
 private:
-    SkEncodedImageFormat fType;
+    Type fType;
 };
 
 /*  Encode bitmaps via CGImageDestination. We setup a DataConsumer which writes
@@ -80,19 +80,19 @@
 
     CFStringRef type;
     switch (fType) {
-        case SkEncodedImageFormat::kICO:
+        case kICO_Type:
             type = kUTTypeICO;
             break;
-        case SkEncodedImageFormat::kBMP:
+        case kBMP_Type:
             type = kUTTypeBMP;
             break;
-        case SkEncodedImageFormat::kGIF:
+        case kGIF_Type:
             type = kUTTypeGIF;
             break;
-        case SkEncodedImageFormat::kJPEG:
+        case kJPEG_Type:
             type = kUTTypeJPEG;
             break;
-        case SkEncodedImageFormat::kPNG:
+        case kPNG_Type:
             // PNG encoding an ARGB_4444 bitmap gives the following errors in GM:
             // <Error>: CGImageDestinationAddImage image could not be converted to destination
             // format.
@@ -127,13 +127,13 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 #ifdef SK_USE_CG_ENCODER
-static SkImageEncoder* sk_imageencoder_cg_factory(SkEncodedImageFormat t) {
+static SkImageEncoder* sk_imageencoder_cg_factory(SkImageEncoder::Type t) {
     switch (t) {
-        case SkEncodedImageFormat::kICO:
-        case SkEncodedImageFormat::kBMP:
-        case SkEncodedImageFormat::kGIF:
-        case SkEncodedImageFormat::kJPEG:
-        case SkEncodedImageFormat::kPNG:
+        case SkImageEncoder::kICO_Type:
+        case SkImageEncoder::kBMP_Type:
+        case SkImageEncoder::kGIF_Type:
+        case SkImageEncoder::kJPEG_Type:
+        case SkImageEncoder::kPNG_Type:
             break;
         default:
             return nullptr;
@@ -145,7 +145,7 @@
 #endif
 
 SkImageEncoder* CreateImageEncoder_CG(SkImageEncoder::Type type) {
-    return new SkImageEncoder_CG((SkEncodedImageFormat)type);
+    return new SkImageEncoder_CG(type);
 }
 
 #endif//defined(SK_BUILD_FOR_MAC) || defined(SK_BUILD_FOR_IOS)
diff --git a/src/ports/SkImageEncoder_WIC.cpp b/src/ports/SkImageEncoder_WIC.cpp
index 035359e..6524526 100644
--- a/src/ports/SkImageEncoder_WIC.cpp
+++ b/src/ports/SkImageEncoder_WIC.cpp
@@ -31,7 +31,7 @@
 #include <wincodec.h>
 #include "SkAutoCoInitialize.h"
 #include "SkBitmap.h"
-#include "SkImageEncoderPriv.h"
+#include "SkImageEncoder.h"
 #include "SkIStream.h"
 #include "SkStream.h"
 #include "SkTScopedComPtr.h"
@@ -48,13 +48,13 @@
 
 class SkImageEncoder_WIC : public SkImageEncoder {
 public:
-    SkImageEncoder_WIC(SkEncodedImageFormat t) : fType(t) {}
+    SkImageEncoder_WIC(Type t) : fType(t) {}
 
 protected:
     virtual bool onEncode(SkWStream* stream, const SkBitmap& bm, int quality);
 
 private:
-    SkEncodedImageFormat fType;
+    Type fType;
 };
 
 bool SkImageEncoder_WIC::onEncode(SkWStream* stream
@@ -63,10 +63,10 @@
 {
     GUID type;
     switch (fType) {
-        case SkEncodedImageFormat::kJPEG:
+        case kJPEG_Type:
             type = GUID_ContainerFormatJpeg;
             break;
-        case SkEncodedImageFormat::kPNG:
+        case kPNG_Type:
             type = GUID_ContainerFormatPng;
             break;
         default:
@@ -97,7 +97,7 @@
     size_t rowBytes = bitmap.rowBytes();
     SkAutoMalloc pixelStorage;
     WICPixelFormatGUID formatDesired = GUID_WICPixelFormat32bppBGRA;
-    if (SkEncodedImageFormat::kJPEG == fType) {
+    if (kJPEG_Type == fType) {
         formatDesired = GUID_WICPixelFormat24bppBGR;
         rowBytes = SkAlign4(bitmap.width() * 3);
         pixelStorage.reset(rowBytes * bitmap.height());
@@ -219,10 +219,10 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 #ifdef SK_USE_WIC_ENCODER
-static SkImageEncoder* sk_imageencoder_wic_factory(SkEncodedImageFormat t) {
+static SkImageEncoder* sk_imageencoder_wic_factory(SkImageEncoder::Type t) {
     switch (t) {
-        case SkEncodedImageFormat::kPNG:
-        case SkEncodedImageFormat::kJPEG:
+        case SkImageEncoder::kPNG_Type:
+        case SkImageEncoder::kJPEG_Type:
             break;
         default:
             return nullptr;
@@ -234,7 +234,7 @@
 #endif
 
 SkImageEncoder* CreateImageEncoder_WIC(SkImageEncoder::Type type) {
-    return new SkImageEncoder_WIC((SkEncodedImageFormat)type);
+    return new SkImageEncoder_WIC(type);
 }
 
 #endif // defined(SK_BUILD_FOR_WIN32)
diff --git a/src/ports/SkImageEncoder_none.cpp b/src/ports/SkImageEncoder_none.cpp
index a26698b..327a220 100644
--- a/src/ports/SkImageEncoder_none.cpp
+++ b/src/ports/SkImageEncoder_none.cpp
@@ -5,9 +5,63 @@
  * found in the LICENSE file.
  */
 
+#include "SkBitmap.h"
+#include "SkImage.h"
 #include "SkImageEncoder.h"
+#include "SkPixelSerializer.h"
+#include "SkStream.h"
 
-bool SkEncodeImage(SkWStream*, const SkPixmap&, SkEncodedImageFormat, int) {
+/////////////////////////////////////////////////////////////////////////
+
+// Empty implementations for SkImageEncoder.
+
+SkImageEncoder* SkImageEncoder::Create(Type t) {
+    return nullptr;
+}
+
+bool SkImageEncoder::EncodeFile(const char file[], const SkBitmap&, Type, int quality) {
     return false;
 }
 
+bool SkImageEncoder::EncodeStream(SkWStream*, const SkBitmap&, SkImageEncoder::Type, int) {
+    return false;
+}
+
+SkData* SkImageEncoder::EncodeData(const SkBitmap&, Type, int quality) {
+    return nullptr;
+}
+
+SkData* SkImageEncoder::EncodeData(const SkImageInfo&, const void* pixels, size_t rowBytes,
+                                   Type, int quality) {
+    return nullptr;
+}
+
+SkData* SkImageEncoder::EncodeData(const SkPixmap&, Type, int) {
+    return nullptr;
+}
+
+bool SkImageEncoder::encodeStream(SkWStream*, const SkBitmap&, int) {
+    return false;
+}
+
+SkData* SkImageEncoder::encodeData(const SkBitmap&, int) {
+    return nullptr;
+}
+
+bool SkImageEncoder::encodeFile(const char file[], const SkBitmap& bm, int quality) {
+    return false;
+}
+
+namespace {
+class ImageEncoderPixelSerializer final : public SkPixelSerializer {
+protected:
+    bool onUseEncodedData(const void*, size_t) override { return true; }
+    SkData* onEncode(const SkPixmap&) override { return nullptr; }
+};
+}  // namespace
+
+SkPixelSerializer* SkImageEncoder::CreatePixelSerializer() {
+    return new ImageEncoderPixelSerializer;
+}
+
+/////////////////////////////////////////////////////////////////////////
diff --git a/src/svg/SkSVGDevice.cpp b/src/svg/SkSVGDevice.cpp
index b9f1424..ffdf034 100644
--- a/src/svg/SkSVGDevice.cpp
+++ b/src/svg/SkSVGDevice.cpp
@@ -659,14 +659,10 @@
     }
 }
 
-static sk_sp<SkData> encode(const SkBitmap& src) {
-    SkDynamicMemoryWStream buf;
-    return SkEncodeImage(&buf, src, SkEncodedImageFormat::kPNG, 80) ? buf.detachAsData() : nullptr;
-}
-
 void SkSVGDevice::drawBitmapCommon(const SkDraw& draw, const SkBitmap& bm,
                                    const SkPaint& paint) {
-    sk_sp<SkData> pngData = encode(bm);
+    sk_sp<const SkData> pngData(
+        SkImageEncoder::EncodeData(bm, SkImageEncoder::kPNG_Type, SkImageEncoder::kDefaultQuality));
     if (!pngData) {
         return;
     }
diff --git a/src/xps/SkXPSDevice.cpp b/src/xps/SkXPSDevice.cpp
index 3787433..22c7b24 100644
--- a/src/xps/SkXPSDevice.cpp
+++ b/src/xps/SkXPSDevice.cpp
@@ -658,7 +658,8 @@
         const SkAlpha alpha,
         IXpsOMTileBrush** xpsBrush) {
     SkDynamicMemoryWStream write;
-    if (!SkEncodeImage(&write, bitmap, SkEncodedImageFormat::kPNG, 100)) {
+    if (!SkImageEncoder::EncodeStream(&write, bitmap,
+                                      SkImageEncoder::kPNG_Type, 100)) {
         HRM(E_FAIL, "Unable to encode bitmap as png.");
     }
     SkMemoryStream* read = new SkMemoryStream;
diff --git a/tests/BlitRowTest.cpp b/tests/BlitRowTest.cpp
index 3439a5e..b4a4a64 100644
--- a/tests/BlitRowTest.cpp
+++ b/tests/BlitRowTest.cpp
@@ -12,8 +12,6 @@
 #include "SkRect.h"
 #include "Test.h"
 
-#include "sk_tool_utils.h"
-
 // these are in the same order as the SkColorType enum
 static const char* gColorTypeName[] = {
     "None", "A8", "565", "4444", "RGBA", "BGRA", "Index8"
@@ -180,7 +178,7 @@
 
 #include "SkImageEncoder.h"
 static void save_bm(const SkBitmap& bm, const char name[]) {
-    sk_tool_utils::EncodeImageToFile(name, bm, SkEncodedImageFormat::kPNG, 100);
+    SkImageEncoder::EncodeFile(name, bm, SkImageEncoder::kPNG_Type, 100);
 }
 
 static bool gOnce;
diff --git a/tests/CodecTest.cpp b/tests/CodecTest.cpp
index d15c710..dacabca 100644
--- a/tests/CodecTest.cpp
+++ b/tests/CodecTest.cpp
@@ -23,8 +23,6 @@
 
 #include "png.h"
 
-#include "sk_tool_utils.h"
-
 #if PNG_LIBPNG_VER_MAJOR == 1 && PNG_LIBPNG_VER_MINOR < 5
     // FIXME (scroggo): Google3 needs to be updated to use a newer version of libpng. In
     // the meantime, we had to break some pieces of SkPngCodec in order to support Google3.
@@ -1104,7 +1102,7 @@
 
     // Encode the image to png.
     sk_sp<SkData> data =
-            sk_sp<SkData>(sk_tool_utils::EncodeImageToData(bm1, SkEncodedImageFormat::kPNG, 100));
+            sk_sp<SkData>(SkImageEncoder::EncodeData(bm1, SkImageEncoder::kPNG_Type, 100));
 
     std::unique_ptr<SkCodec> codec(SkCodec::NewFromData(data));
     REPORTER_ASSERT(r, color_type_match(info.colorType(), codec->getInfo().colorType()));
diff --git a/tests/ImageTest.cpp b/tests/ImageTest.cpp
index 020e322f..18883fe 100644
--- a/tests/ImageTest.cpp
+++ b/tests/ImageTest.cpp
@@ -26,8 +26,6 @@
 #include "SkUtils.h"
 #include "Test.h"
 
-#include "sk_tool_utils.h"
-
 #if SK_SUPPORT_GPU
 #include "GrGpu.h"
 #endif
@@ -155,7 +153,7 @@
     sk_sp<SkData> data(create_image_data(&info));
     SkBitmap bitmap;
     bitmap.installPixels(info, data->writable_data(), info.minRowBytes());
-    sk_sp<SkData> src(sk_tool_utils::EncodeImageToData(bitmap, SkEncodedImageFormat::kPNG, 100));
+    sk_sp<SkData> src(SkImageEncoder::EncodeData(bitmap, SkImageEncoder::kPNG_Type, 100));
     return SkImage::MakeFromEncoded(std::move(src));
 }
 #if SK_SUPPORT_GPU
@@ -1028,7 +1026,7 @@
     make_all_premul(&bm0);
 
     auto img0 = SkImage::MakeFromBitmap(bm0);
-    sk_sp<SkData> data(img0->encode(SkEncodedImageFormat::kPNG, 100));
+    sk_sp<SkData> data(img0->encode(SkImageEncoder::kPNG_Type, 100));
     auto img1 = SkImage::MakeFromEncoded(data);
 
     SkBitmap bm1;
diff --git a/tests/PDFDocumentTest.cpp b/tests/PDFDocumentTest.cpp
index b320015..fca8496 100644
--- a/tests/PDFDocumentTest.cpp
+++ b/tests/PDFDocumentTest.cpp
@@ -14,8 +14,6 @@
 #include "SkStream.h"
 #include "SkPixelSerializer.h"
 
-#include "sk_tool_utils.h"
-
 static void test_empty(skiatest::Reporter* reporter) {
     SkDynamicMemoryWStream stream;
 
@@ -121,7 +119,14 @@
 class JPEGSerializer final : public SkPixelSerializer {
     bool onUseEncodedData(const void*, size_t) override { return true; }
     SkData* onEncode(const SkPixmap& pixmap) override {
-        return sk_tool_utils::EncodeImageToData(pixmap, SkEncodedImageFormat::kJPEG, 85).release();
+        SkBitmap bm;
+        return bm.installPixels(pixmap.info(),
+                                pixmap.writable_addr(),
+                                pixmap.rowBytes(),
+                                pixmap.ctable(),
+                                nullptr, nullptr)
+            ? SkImageEncoder::EncodeData(bm, SkImageEncoder::kJPEG_Type, 85)
+            : nullptr;
     }
 };
 }  // namespace
diff --git a/tests/PathOpsConicIntersectionTest.cpp b/tests/PathOpsConicIntersectionTest.cpp
index 1de1583..41c0acb 100644
--- a/tests/PathOpsConicIntersectionTest.cpp
+++ b/tests/PathOpsConicIntersectionTest.cpp
@@ -110,8 +110,8 @@
     canvas.drawPath(path, paint);
     SkString filename("c:\\Users\\caryclark\\Documents\\");
     filename.appendf("%s.png", name);
-    sk_tool_utils::EncodeImageToFile(filename.c_str(), bitmap,
-            SkEncodedImageFormat::kPNG, 100);
+    SkImageEncoder::EncodeFile(filename.c_str(), bitmap,
+            SkImageEncoder::kPNG_Type, 100);
 }
 
 static void writeDPng(const SkDConic& dC, const char* name) {
@@ -152,8 +152,8 @@
     canvas.drawPath(path, paint);
     SkString filename("c:\\Users\\caryclark\\Documents\\");
     filename.appendf("%s.png", name);
-    sk_tool_utils::EncodeImageToFile(filename.c_str(), bitmap,
-            SkEncodedImageFormat::kPNG, 100);
+    SkImageEncoder::EncodeFile(filename.c_str(), bitmap,
+            SkImageEncoder::kPNG_Type, 100);
 }
 #endif
 
@@ -290,7 +290,7 @@
         }
         SkString filename("c:\\Users\\caryclark\\Documents\\");
         filename.appendf("f%d.png", index);
-        sk_tool_utils::EncodeImageToFile(filename.c_str(), bitmap, SkEncodedImageFormat::kPNG, 100);
+        SkImageEncoder::EncodeFile(filename.c_str(), bitmap, SkImageEncoder::kPNG_Type, 100);
     }
 }
 #endif
diff --git a/tests/PathOpsSkpClipTest.cpp b/tests/PathOpsSkpClipTest.cpp
index 57e9bd1..3cbe7ef 100644
--- a/tests/PathOpsSkpClipTest.cpp
+++ b/tests/PathOpsSkpClipTest.cpp
@@ -429,7 +429,7 @@
 static void writePict(const SkBitmap& bitmap, const char* outDir, const char* pngName) {
     SkString outFile = get_sum_path(outDir);
     outFile.appendf("%s%s", PATH_SLASH, pngName);
-    if (!sk_tool_utils::EncodeImageToFile(outFile.c_str(), bitmap, SkEncodedImageFormat::kPNG, 100)) {
+    if (!SkImageEncoder::EncodeFile(outFile.c_str(), bitmap, SkImageEncoder::kPNG_Type, 100)) {
         SkDebugf("unable to encode gr %s (width=%d height=%d)\n", pngName,
                     bitmap.width(), bitmap.height());
     }
diff --git a/tests/SkpSkGrTest.cpp b/tests/SkpSkGrTest.cpp
index 0e425a0..c87926e 100644
--- a/tests/SkpSkGrTest.cpp
+++ b/tests/SkpSkGrTest.cpp
@@ -368,8 +368,8 @@
 
 static void writePict(const SkBitmap& bitmap, const char* outDir, const char* pngName) {
     SkString outFile = make_filepath(0, outDir, pngName);
-    if (!sk_tool_utils::EncodeImageToFile(outFile.c_str(), bitmap,
-            SkEncodedImageFormat::kPNG, 100)) {
+    if (!SkImageEncoder::EncodeFile(outFile.c_str(), bitmap,
+            SkImageEncoder::kPNG_Type, 100)) {
         SkDebugf("unable to encode gr %s (width=%d height=%d)br \n", pngName,
                     bitmap.width(), bitmap.height());
     }
diff --git a/tools/colorspaceinfo.cpp b/tools/colorspaceinfo.cpp
index 945c4a5..301f47d 100644
--- a/tools/colorspaceinfo.cpp
+++ b/tools/colorspaceinfo.cpp
@@ -17,8 +17,6 @@
 #include "SkMatrix44.h"
 #include "SkOSFile.h"
 
-#include "sk_tool_utils.h"
-
 __SK_FORCE_IMAGE_DECODER_LINKING;
 
 DEFINE_string(input, "input.png", "A path to the input image or icc profile.");
@@ -221,7 +219,7 @@
     }
 
     // Finally, encode the result to the output file.
-    sk_sp<SkData> out = sk_tool_utils::EncodeImageToData(gamut, SkEncodedImageFormat::kPNG, 100);
+    sk_sp<SkData> out(SkImageEncoder::EncodeData(gamut, SkImageEncoder::kPNG_Type, 100));
     if (!out) {
         SkDebugf("Failed to encode gamut output.\n");
         return -1;
@@ -245,7 +243,7 @@
             SkDebugf("Could not decode input image.\n");
             return -1;
         }
-        out = sk_tool_utils::EncodeImageToData(bitmap, SkEncodedImageFormat::kPNG, 100);
+        out.reset(SkImageEncoder::EncodeData(bitmap, SkImageEncoder::kPNG_Type, 100));
         if (!out) {
             SkDebugf("Failed to encode uncorrected image.\n");
             return -1;
diff --git a/tools/get_images_from_skps.cpp b/tools/get_images_from_skps.cpp
index d3a2343..6cd3512 100644
--- a/tools/get_images_from_skps.cpp
+++ b/tools/get_images_from_skps.cpp
@@ -65,14 +65,14 @@
         }
         SkString ext;
         switch (codec->getEncodedFormat()) {
-            case SkEncodedImageFormat::kBMP:  ext =  "bmp"; break;
-            case SkEncodedImageFormat::kGIF:  ext =  "gif"; break;
-            case SkEncodedImageFormat::kICO:  ext =  "ico"; break;
-            case SkEncodedImageFormat::kJPEG: ext =  "jpg"; break;
-            case SkEncodedImageFormat::kPNG:  ext =  "png"; break;
-            case SkEncodedImageFormat::kDNG:  ext =  "dng"; break;
-            case SkEncodedImageFormat::kWBMP: ext = "wbmp"; break;
-            case SkEncodedImageFormat::kWEBP: ext = "webp"; break;
+            case SkEncodedFormat::kBMP_SkEncodedFormat:  ext =  "bmp"; break;
+            case SkEncodedFormat::kGIF_SkEncodedFormat:  ext =  "gif"; break;
+            case SkEncodedFormat::kICO_SkEncodedFormat:  ext =  "ico"; break;
+            case SkEncodedFormat::kJPEG_SkEncodedFormat: ext =  "jpg"; break;
+            case SkEncodedFormat::kPNG_SkEncodedFormat:  ext =  "png"; break;
+            case SkEncodedFormat::kDNG_SkEncodedFormat:  ext =  "dng"; break;
+            case SkEncodedFormat::kWBMP_SkEncodedFormat: ext = "wbmp"; break;
+            case SkEncodedFormat::kWEBP_SkEncodedFormat: ext = "webp"; break;
             default:
                 // This should be unreachable because we cannot create a codec if we do not know
                 // the image type.
diff --git a/tools/imgblur.cpp b/tools/imgblur.cpp
index 28d8447..3a0ae00 100644
--- a/tools/imgblur.cpp
+++ b/tools/imgblur.cpp
@@ -66,7 +66,7 @@
 
     SkBitmap dst = sk_tool_utils::slow_blur(src, (float) FLAGS_sigma);
 
-    if (!sk_tool_utils::EncodeImageToFile(FLAGS_out[0], dst, SkEncodedImageFormat::kPNG, 100)) {
+    if (!SkImageEncoder::EncodeFile(FLAGS_out[0], dst, SkImageEncoder::kPNG_Type, 100)) {
         if (!FLAGS_quiet) {
             SkDebugf("Couldn't write to file: %s\n", FLAGS_out[0]);
         }
diff --git a/tools/picture_utils.cpp b/tools/picture_utils.cpp
index 84925b4..43ca2f0 100644
--- a/tools/picture_utils.cpp
+++ b/tools/picture_utils.cpp
@@ -17,8 +17,6 @@
 #include "SkStream.h"
 #include "SkString.h"
 
-#include "sk_tool_utils.h"
-
 namespace sk_tools {
     void force_all_opaque(const SkBitmap& bitmap) {
         SkASSERT(kN32_SkColorType == bitmap.colorType());
@@ -65,7 +63,7 @@
             partialPath.set(dirPath);
         }
         SkString fullPath = SkOSPath::Join(partialPath.c_str(), baseName.c_str());
-        if (sk_tool_utils::EncodeImageToFile(fullPath.c_str(), bm, SkEncodedImageFormat::kPNG, 100)) {
+        if (SkImageEncoder::EncodeFile(fullPath.c_str(), bm, SkImageEncoder::kPNG_Type, 100)) {
             return true;
         } else {
             SkDebugf("Failed to write the bitmap to %s.\n", fullPath.c_str());
diff --git a/tools/sk_tool_utils.h b/tools/sk_tool_utils.h
index 526f0ef..c6abbcf 100644
--- a/tools/sk_tool_utils.h
+++ b/tools/sk_tool_utils.h
@@ -225,31 +225,6 @@
         SkTDArray<TopoTestNode*> fDependencies;
     };
 
-    template <typename T>
-    inline bool EncodeImageToFile(const char* path, const T& src, SkEncodedImageFormat f, int q) {
-        SkFILEWStream file(path);
-        return file.isValid() && SkEncodeImage(&file, src, f, q);
-    }
-
-    template <typename T>
-    inline sk_sp<SkData> EncodeImageToData(const T& src, SkEncodedImageFormat f, int q) {
-        SkDynamicMemoryWStream buf;
-        return SkEncodeImage(&buf, src , f, q) ? buf.detachAsData() : nullptr;
-    }
-
-    /**
-     * Uses SkEncodeImage to serialize images that are not already
-     * encoded as SkEncodedImageFormat::kPNG images.
-     */
-    inline sk_sp<SkPixelSerializer> MakePixelSerializer() {
-        struct EncodeImagePixelSerializer final : SkPixelSerializer {
-            bool onUseEncodedData(const void*, size_t) override { return true; }
-            SkData* onEncode(const SkPixmap& pmap) override {
-                return EncodeImageToData(pmap, SkEncodedImageFormat::kPNG, 100).release();
-            }
-        };
-        return sk_make_sp<EncodeImagePixelSerializer>();
-    }
 }  // namespace sk_tool_utils
 
 #endif  // sk_tool_utils_DEFINED
diff --git a/tools/skdiff/skdiff_utils.cpp b/tools/skdiff/skdiff_utils.cpp
index f8eed90..f788ec8 100644
--- a/tools/skdiff/skdiff_utils.cpp
+++ b/tools/skdiff/skdiff_utils.cpp
@@ -6,7 +6,6 @@
  */
 #include "skdiff.h"
 #include "skdiff_utils.h"
-#include "sk_tool_utils.h"
 #include "SkBitmap.h"
 #include "SkCodec.h"
 #include "SkData.h"
@@ -83,8 +82,8 @@
     SkBitmap copy;
     bitmap.copyTo(&copy, kN32_SkColorType);
     force_all_opaque(copy);
-    return sk_tool_utils::EncodeImageToFile(path.c_str(), copy,
-                                      SkEncodedImageFormat::kPNG, 100);
+    return SkImageEncoder::EncodeFile(path.c_str(), copy,
+                                      SkImageEncoder::kPNG_Type, 100);
 }
 
 /// Return a copy of the "input" string, within which we have replaced all instances
diff --git a/tools/skiaserve/Request.cpp b/tools/skiaserve/Request.cpp
index 2064a46..c1b3b25 100644
--- a/tools/skiaserve/Request.cpp
+++ b/tools/skiaserve/Request.cpp
@@ -11,7 +11,6 @@
 #include "SkPixelSerializer.h"
 #include "SkPM4fPriv.h"
 #include "picture_utils.h"
-#include "sk_tool_utils.h"
 
 using namespace sk_gpu_test;
 
@@ -118,7 +117,7 @@
 
     SkDynamicMemoryWStream outStream;
 
-    sk_sp<SkPixelSerializer> serializer = sk_tool_utils::MakePixelSerializer();
+    sk_sp<SkPixelSerializer> serializer(SkImageEncoder::CreatePixelSerializer());
     picture->serialize(&outStream, serializer.get());
 
     return outStream.detachAsData();