diff --git a/core/fxcrt/cfx_utf8decoder.cpp b/core/fxcrt/cfx_utf8decoder.cpp
index 9661745..a36f072 100644
--- a/core/fxcrt/cfx_utf8decoder.cpp
+++ b/core/fxcrt/cfx_utf8decoder.cpp
@@ -11,6 +11,8 @@
 #include <utility>
 
 #include "build/build_config.h"
+#include "core/fxcrt/string_view_template.h"
+#include "core/fxcrt/widestring.h"
 
 CFX_UTF8Decoder::CFX_UTF8Decoder(ByteStringView input) {
   int remaining = 0;
diff --git a/core/fxcrt/cfx_utf8encoder.cpp b/core/fxcrt/cfx_utf8encoder.cpp
index e0b7ee5..05f50e1 100644
--- a/core/fxcrt/cfx_utf8encoder.cpp
+++ b/core/fxcrt/cfx_utf8encoder.cpp
@@ -8,33 +8,56 @@
 
 #include <stdint.h>
 
-#include "build/build_config.h"
+#include <utility>
 
-CFX_UTF8Encoder::CFX_UTF8Encoder() = default;
+#include "build/build_config.h"
+#include "core/fxcrt/bytestring.h"
+#include "core/fxcrt/string_view_template.h"
+
+CFX_UTF8Encoder::CFX_UTF8Encoder(WideStringView input) {
+#if defined(WCHAR_T_IS_UTF16)
+  char16_t high_surrogate = 0;
+
+  for (wchar_t code_unit : input) {
+    if (high_surrogate) {
+      if (code_unit >= 0xdc00 && code_unit < 0xe000) {
+        // Paired low surrogate.
+        char32_t code_point = code_unit & 0x3ff;
+        code_point |= (high_surrogate & 0x3ff) << 10;
+        code_point += 0x10000;
+        high_surrogate = 0;
+        AppendCodePoint(code_point);
+        continue;
+      }
+
+      // Unpaired high surrogate.
+      AppendCodePoint(high_surrogate);
+    }
+
+    if (code_unit >= 0xd800 && code_unit < 0xdc00) {
+      // Pending high surrogate.
+      high_surrogate = code_unit;
+    } else {
+      high_surrogate = 0;
+      AppendCodePoint(code_unit);
+    }
+  }
+
+  if (high_surrogate) {
+    // Unpaired high surrogate.
+    AppendCodePoint(high_surrogate);
+  }
+#else
+  for (wchar_t code_unit : input) {
+    AppendCodePoint(code_unit);
+  }
+#endif  // defined(WCHAR_T_IS_UTF16)
+}
 
 CFX_UTF8Encoder::~CFX_UTF8Encoder() = default;
 
-void CFX_UTF8Encoder::Input(wchar_t code_unit) {
-#if defined(WCHAR_T_IS_UTF16)
-  if (code_unit >= 0xd800 && code_unit < 0xdc00) {
-    // High surrogate.
-    high_surrogate_ = code_unit;
-  } else if (code_unit >= 0xdc00 && code_unit <= 0xdfff) {
-    // Low surrogate.
-    if (high_surrogate_) {
-      char32_t code_point = code_unit & 0x3ff;
-      code_point |= (high_surrogate_ & 0x3ff) << 10;
-      code_point += 0x10000;
-      high_surrogate_ = 0;
-      AppendCodePoint(code_point);
-    }
-  } else {
-    high_surrogate_ = 0;
-    AppendCodePoint(code_unit);
-  }
-#else
-  AppendCodePoint(code_unit);
-#endif  // defined(WCHAR_T_IS_UTF16)
+ByteString CFX_UTF8Encoder::TakeResult() {
+  return std::move(buffer_);
 }
 
 void CFX_UTF8Encoder::AppendCodePoint(char32_t code_point) {
@@ -45,7 +68,7 @@
 
   if (code_point < 0x80) {
     // 7-bit code points are unchanged in UTF-8.
-    buffer_.push_back(code_point);
+    buffer_ += code_point;
     return;
   }
 
@@ -60,10 +83,10 @@
 
   static constexpr uint8_t kPrefix[] = {0xc0, 0xe0, 0xf0};
   int order = 1 << ((byte_size - 1) * 6);
-  buffer_.push_back(kPrefix[byte_size - 2] | (code_point / order));
+  buffer_ += kPrefix[byte_size - 2] | (code_point / order);
   for (int i = 0; i < byte_size - 1; i++) {
     code_point = code_point % order;
     order >>= 6;
-    buffer_.push_back(0x80 | (code_point / order));
+    buffer_ += 0x80 | (code_point / order);
   }
 }
diff --git a/core/fxcrt/cfx_utf8encoder.h b/core/fxcrt/cfx_utf8encoder.h
index 71b9ac3..bc3ddfb 100644
--- a/core/fxcrt/cfx_utf8encoder.h
+++ b/core/fxcrt/cfx_utf8encoder.h
@@ -7,33 +7,22 @@
 #ifndef CORE_FXCRT_CFX_UTF8ENCODER_H_
 #define CORE_FXCRT_CFX_UTF8ENCODER_H_
 
-#include "build/build_config.h"
-#include "core/fxcrt/data_vector.h"
+#include "core/fxcrt/bytestring.h"
 #include "core/fxcrt/string_view_template.h"
 
 class CFX_UTF8Encoder {
  public:
-  CFX_UTF8Encoder();
+  // `input` may be UTF-16 or UTF-32, depending on the platform.
+  // TODO(crbug.com/pdfium/2031): Always use UTF-16.
+  explicit CFX_UTF8Encoder(WideStringView input);
   ~CFX_UTF8Encoder();
 
-  // `code_unit` may be UTF-16 or UTF-32, depending on the platform.
-  // TODO(crbug.com/pdfium/2031): Accept `char16_t` instead of `wchar_t`.
-  void Input(wchar_t code_unit);
-
-  // The data returned by `GetResult()` is invalidated when this is modified by
-  // appending any data.
-  ByteStringView GetResult() const {
-    return ByteStringView(buffer_.data(), buffer_.size());
-  }
+  ByteString TakeResult();
 
  private:
   void AppendCodePoint(char32_t code_point);
 
-  DataVector<char> buffer_;
-
-#if defined(WCHAR_T_IS_UTF16)
-  char16_t high_surrogate_ = 0;
-#endif  // defined(WCHAR_T_IS_UTF16)
+  ByteString buffer_;
 };
 
 #endif  // CORE_FXCRT_CFX_UTF8ENCODER_H_
diff --git a/core/fxcrt/fx_string.cpp b/core/fxcrt/fx_string.cpp
index 76773a8..c1c25bd 100644
--- a/core/fxcrt/fx_string.cpp
+++ b/core/fxcrt/fx_string.cpp
@@ -8,24 +8,22 @@
 
 #include <iterator>
 
+#include "core/fxcrt/bytestring.h"
 #include "core/fxcrt/cfx_utf8decoder.h"
 #include "core/fxcrt/cfx_utf8encoder.h"
 #include "core/fxcrt/fx_extension.h"
 #include "core/fxcrt/span_util.h"
+#include "core/fxcrt/string_view_template.h"
+#include "core/fxcrt/widestring.h"
 #include "third_party/base/compiler_specific.h"
 #include "third_party/base/span.h"
 
 ByteString FX_UTF8Encode(WideStringView wsStr) {
-  CFX_UTF8Encoder encoder;
-  for (size_t i = 0; i < wsStr.GetLength(); ++i)
-    encoder.Input(wsStr[i]);
-
-  return ByteString(encoder.GetResult());
+  return CFX_UTF8Encoder(wsStr).TakeResult();
 }
 
 WideString FX_UTF8Decode(ByteStringView bsStr) {
-  CFX_UTF8Decoder decoder(bsStr);
-  return decoder.TakeResult();
+  return CFX_UTF8Decoder(bsStr).TakeResult();
 }
 
 namespace {
diff --git a/core/fxcrt/fx_string_unittest.cpp b/core/fxcrt/fx_string_unittest.cpp
index 34ffcee..f877aa7 100644
--- a/core/fxcrt/fx_string_unittest.cpp
+++ b/core/fxcrt/fx_string_unittest.cpp
@@ -25,12 +25,12 @@
   EXPECT_EQ("", FX_UTF8Encode(WideStringView()));
   EXPECT_EQ(
       "x"
-      "\xc2\x80"
-      "\xc3\xbf"
-      "\xed\x9f\xbf"
-      "\xee\x80\x80"
-      "\xef\xbc\xac"
-      "\xef\xbf\xbf"
+      "\u0080"
+      "\u00ff"
+      "\ud7ff"
+      "\ue000"
+      "\uff2c"
+      "\uffff"
       "y",
       FX_UTF8Encode(L"x"
                     L"\u0080"
@@ -44,9 +44,9 @@
 
 TEST(fxstring, FXUTF8EncodeSupplementary) {
   EXPECT_EQ(
-      "\xf0\x90\x80\x80"
+      "\U00010000"
       "🎨"
-      "\xf4\x8f\xbf\xbf",
+      "\U0010ffff",
       FX_UTF8Encode(L"\U00010000"
                     L"\U0001f3a8"
                     L"\U0010ffff"));
@@ -54,10 +54,12 @@
 
 #if defined(WCHAR_T_IS_UTF16)
 TEST(fxstring, FXUTF8EncodeSurrogateErrorRecovery) {
-  EXPECT_EQ("()", FX_UTF8Encode(L"(\xd800)")) << "High";
-  EXPECT_EQ("()", FX_UTF8Encode(L"(\xdc00)")) << "Low";
-  EXPECT_EQ("(🎨)", FX_UTF8Encode(L"(\xd800\xd83c\xdfa8)")) << "High-high";
-  EXPECT_EQ("(🎨)", FX_UTF8Encode(L"(\xd83c\xdfa8\xdc00)")) << "Low-low";
+  EXPECT_EQ("(\xed\xa0\x80)", FX_UTF8Encode(L"(\xd800)")) << "High";
+  EXPECT_EQ("(\xed\xb0\x80)", FX_UTF8Encode(L"(\xdc00)")) << "Low";
+  EXPECT_EQ("(\xed\xa0\x80🎨)", FX_UTF8Encode(L"(\xd800\xd83c\xdfa8)"))
+      << "High-high";
+  EXPECT_EQ("(🎨\xed\xb0\x80)", FX_UTF8Encode(L"(\xd83c\xdfa8\xdc00)"))
+      << "Low-low";
 }
 #endif  // defined(WCHAR_T_IS_UTF16)
 
@@ -73,12 +75,12 @@
       L"\uffff"
       L"y",
       FX_UTF8Decode("x"
-                    "\xc2\x80"
-                    "\xc3\xbf"
-                    "\xed\x9f\xbf"
-                    "\xee\x80\x80"
-                    "\xef\xbc\xac"
-                    "\xef\xbf\xbf"
+                    "\u0080"
+                    "\u00ff"
+                    "\ud7ff"
+                    "\ue000"
+                    "\uff2c"
+                    "\uffff"
                     "y"));
 }
 
@@ -87,9 +89,9 @@
       L"\U00010000"
       L"\U0001f3a8"
       L"\U0010ffff",
-      FX_UTF8Decode("\xf0\x90\x80\x80"
+      FX_UTF8Decode("\U00010000"
                     "🎨"
-                    "\xf4\x8f\xbf\xbf"));
+                    "\U0010ffff"));
 }
 
 TEST(fxstring, FXUTF8DecodeErrorRecovery) {
@@ -111,11 +113,37 @@
   wstr.Reserve(0x10000);
   for (int w = 0; w < 0x10000; ++w) {
     // Skip UTF-16 surrogates.
-    if (w < 0xD800 || w >= 0xE000) {
+    if (w < 0xd800 || w >= 0xe000) {
       wstr += static_cast<wchar_t>(w);
     }
   }
-  ASSERT_EQ(0xF800u, wstr.GetLength());
+  ASSERT_EQ(0xf800u, wstr.GetLength());
+
+  ByteString bstr = FX_UTF8Encode(wstr.AsStringView());
+  WideString wstr2 = FX_UTF8Decode(bstr.AsStringView());
+  EXPECT_EQ(wstr, wstr2);
+}
+
+TEST(fxstring, FXUTF8EncodeDecodeConsistencyUnpairedHighSurrogates) {
+  WideString wstr;
+  wstr.Reserve(0x400);
+  for (wchar_t w = 0xd800; w < 0xdc00; ++w) {
+    wstr += w;
+  }
+  ASSERT_EQ(0x400u, wstr.GetLength());
+
+  ByteString bstr = FX_UTF8Encode(wstr.AsStringView());
+  WideString wstr2 = FX_UTF8Decode(bstr.AsStringView());
+  EXPECT_EQ(wstr, wstr2);
+}
+
+TEST(fxstring, FXUTF8EncodeDecodeConsistencyUnpairedLowSurrogates) {
+  WideString wstr;
+  wstr.Reserve(0x400);
+  for (wchar_t w = 0xdc00; w < 0xe000; ++w) {
+    wstr += w;
+  }
+  ASSERT_EQ(0x400u, wstr.GetLength());
 
   ByteString bstr = FX_UTF8Encode(wstr.AsStringView());
   WideString wstr2 = FX_UTF8Decode(bstr.AsStringView());