diff --git a/core/fpdfapi/font/cpdf_font.cpp b/core/fpdfapi/font/cpdf_font.cpp
index b9ae2d7..50b32e3 100644
--- a/core/fpdfapi/font/cpdf_font.cpp
+++ b/core/fpdfapi/font/cpdf_font.cpp
@@ -202,7 +202,7 @@
     m_FontBBox.top = pBBox->GetIntegerAt(3);
   }
 
-  const CPDF_Stream* pFontFile = pFontDesc->GetStreamFor("FontFile");
+  RetainPtr<const CPDF_Stream> pFontFile = pFontDesc->GetStreamFor("FontFile");
   if (!pFontFile)
     pFontFile = pFontDesc->GetStreamFor("FontFile2");
   if (!pFontFile)
@@ -210,13 +210,13 @@
   if (!pFontFile)
     return;
 
+  const uint64_t key = pFontFile->KeyForCache();
   auto* pData = m_pDocument->GetPageData();
-  m_pFontFile = pData->GetFontFileStreamAcc(pFontFile);
+  m_pFontFile = pData->GetFontFileStreamAcc(std::move(pFontFile));
   if (!m_pFontFile)
     return;
 
-  if (!m_Font.LoadEmbedded(m_pFontFile->GetSpan(), IsVertWriting(),
-                           pFontFile->KeyForCache())) {
+  if (!m_Font.LoadEmbedded(m_pFontFile->GetSpan(), IsVertWriting(), key)) {
     pData->MaybePurgeFontFileStreamAcc(m_pFontFile->GetStream()->AsStream());
     m_pFontFile = nullptr;
   }
@@ -262,11 +262,11 @@
 
 void CPDF_Font::LoadUnicodeMap() const {
   m_bToUnicodeLoaded = true;
-  const CPDF_Stream* pStream = m_pFontDict->GetStreamFor("ToUnicode");
+  RetainPtr<const CPDF_Stream> pStream = m_pFontDict->GetStreamFor("ToUnicode");
   if (!pStream)
     return;
 
-  m_pToUnicodeMap = std::make_unique<CPDF_ToUnicodeMap>(pStream);
+  m_pToUnicodeMap = std::make_unique<CPDF_ToUnicodeMap>(std::move(pStream));
 }
 
 int CPDF_Font::GetStringWidth(ByteStringView pString) {
diff --git a/core/fpdfapi/font/cpdf_tounicodemap.cpp b/core/fpdfapi/font/cpdf_tounicodemap.cpp
index 349783c..5d7428a 100644
--- a/core/fpdfapi/font/cpdf_tounicodemap.cpp
+++ b/core/fpdfapi/font/cpdf_tounicodemap.cpp
@@ -40,8 +40,8 @@
 
 }  // namespace
 
-CPDF_ToUnicodeMap::CPDF_ToUnicodeMap(const CPDF_Stream* pStream) {
-  Load(pStream);
+CPDF_ToUnicodeMap::CPDF_ToUnicodeMap(RetainPtr<const CPDF_Stream> pStream) {
+  Load(std::move(pStream));
 }
 
 CPDF_ToUnicodeMap::~CPDF_ToUnicodeMap() = default;
@@ -120,9 +120,9 @@
   return result;
 }
 
-void CPDF_ToUnicodeMap::Load(const CPDF_Stream* pStream) {
+void CPDF_ToUnicodeMap::Load(RetainPtr<const CPDF_Stream> pStream) {
   CIDSet cid_set = CIDSET_UNKNOWN;
-  auto pAcc = pdfium::MakeRetain<CPDF_StreamAcc>(pStream);
+  auto pAcc = pdfium::MakeRetain<CPDF_StreamAcc>(pStream.Get());
   pAcc->LoadAllDataFiltered();
   CPDF_SimpleParser parser(pAcc->GetSpan());
   while (true) {
diff --git a/core/fpdfapi/font/cpdf_tounicodemap.h b/core/fpdfapi/font/cpdf_tounicodemap.h
index 7935ede..15c2bfe 100644
--- a/core/fpdfapi/font/cpdf_tounicodemap.h
+++ b/core/fpdfapi/font/cpdf_tounicodemap.h
@@ -12,6 +12,7 @@
 #include <vector>
 
 #include "core/fxcrt/fx_string.h"
+#include "core/fxcrt/retain_ptr.h"
 #include "core/fxcrt/unowned_ptr.h"
 #include "third_party/abseil-cpp/absl/types/optional.h"
 
@@ -21,7 +22,7 @@
 
 class CPDF_ToUnicodeMap {
  public:
-  explicit CPDF_ToUnicodeMap(const CPDF_Stream* pStream);
+  explicit CPDF_ToUnicodeMap(RetainPtr<const CPDF_Stream> pStream);
   ~CPDF_ToUnicodeMap();
 
   WideString Lookup(uint32_t charcode) const;
@@ -36,7 +37,7 @@
   static absl::optional<uint32_t> StringToCode(ByteStringView str);
   static WideString StringToWideString(ByteStringView str);
 
-  void Load(const CPDF_Stream* pStream);
+  void Load(RetainPtr<const CPDF_Stream> pStream);
   void HandleBeginBFChar(CPDF_SimpleParser* pParser);
   void HandleBeginBFRange(CPDF_SimpleParser* pParser);
   uint32_t GetMultiCharIndexIndicator() const;
diff --git a/core/fpdfapi/font/cpdf_tounicodemap_unittest.cpp b/core/fpdfapi/font/cpdf_tounicodemap_unittest.cpp
index 74eaa3b..f807379 100644
--- a/core/fpdfapi/font/cpdf_tounicodemap_unittest.cpp
+++ b/core/fpdfapi/font/cpdf_tounicodemap_unittest.cpp
@@ -59,7 +59,7 @@
         "beginbfrange<FFFFFFFF><FFFFFFFF>[<0041>]endbfrange";
     auto stream = pdfium::MakeRetain<CPDF_Stream>();
     stream->SetData(pdfium::make_span(kInput1));
-    CPDF_ToUnicodeMap map(stream.Get());
+    CPDF_ToUnicodeMap map(stream);
     EXPECT_STREQ(L"A", map.Lookup(0xffffffff).c_str());
   }
   {
@@ -67,7 +67,7 @@
         "beginbfrange<FFFFFFFF><FFFFFFFF><0042>endbfrange";
     auto stream = pdfium::MakeRetain<CPDF_Stream>();
     stream->SetData(pdfium::make_span(kInput2));
-    CPDF_ToUnicodeMap map(stream.Get());
+    CPDF_ToUnicodeMap map(stream);
     EXPECT_STREQ(L"B", map.Lookup(0xffffffff).c_str());
   }
   {
@@ -75,7 +75,7 @@
         "beginbfrange<FFFFFFFF><FFFFFFFF><00410042>endbfrange";
     auto stream = pdfium::MakeRetain<CPDF_Stream>();
     stream->SetData(pdfium::make_span(kInput3));
-    CPDF_ToUnicodeMap map(stream.Get());
+    CPDF_ToUnicodeMap map(stream);
     EXPECT_STREQ(L"AB", map.Lookup(0xffffffff).c_str());
   }
 }
@@ -87,7 +87,7 @@
         "beginbfchar<1><0041><2><0042>endbfchar";
     auto stream = pdfium::MakeRetain<CPDF_Stream>();
     stream->SetData(pdfium::make_span(kInput1));
-    CPDF_ToUnicodeMap map(stream.Get());
+    CPDF_ToUnicodeMap map(stream);
     EXPECT_EQ(1u, map.ReverseLookup(0x0041));
     EXPECT_EQ(2u, map.ReverseLookup(0x0042));
     EXPECT_EQ(1u, map.GetUnicodeCountByCharcodeForTesting(1u));
@@ -99,7 +99,7 @@
         "beginbfrange<0><0><0041><0><0><0042>endbfrange";
     auto stream = pdfium::MakeRetain<CPDF_Stream>();
     stream->SetData(pdfium::make_span(kInput2));
-    CPDF_ToUnicodeMap map(stream.Get());
+    CPDF_ToUnicodeMap map(stream);
     EXPECT_EQ(0u, map.ReverseLookup(0x0041));
     EXPECT_EQ(0u, map.ReverseLookup(0x0042));
     EXPECT_EQ(2u, map.GetUnicodeCountByCharcodeForTesting(0u));
@@ -112,7 +112,7 @@
         "beginbfchar<0><0041>endbfchar";
     auto stream = pdfium::MakeRetain<CPDF_Stream>();
     stream->SetData(pdfium::make_span(kInput3));
-    CPDF_ToUnicodeMap map(stream.Get());
+    CPDF_ToUnicodeMap map(stream);
     EXPECT_EQ(0u, map.ReverseLookup(0x0041));
     EXPECT_EQ(1u, map.GetUnicodeCountByCharcodeForTesting(0u));
   }
diff --git a/core/fpdfapi/page/cpdf_dib.cpp b/core/fpdfapi/page/cpdf_dib.cpp
index bf57002..3241e42 100644
--- a/core/fpdfapi/page/cpdf_dib.cpp
+++ b/core/fpdfapi/page/cpdf_dib.cpp
@@ -264,10 +264,10 @@
   if (!m_pJbig2Context) {
     m_pJbig2Context = std::make_unique<Jbig2Context>();
     if (m_pStreamAcc->GetImageParam()) {
-      const CPDF_Stream* pGlobals =
+      RetainPtr<const CPDF_Stream> pGlobals =
           m_pStreamAcc->GetImageParam()->GetStreamFor("JBIG2Globals");
       if (pGlobals) {
-        m_pGlobalAcc = pdfium::MakeRetain<CPDF_StreamAcc>(pGlobals);
+        m_pGlobalAcc = pdfium::MakeRetain<CPDF_StreamAcc>(pGlobals.Get());
         m_pGlobalAcc->LoadAllDataFiltered();
       }
     }
diff --git a/core/fpdfapi/page/cpdf_docpagedata.cpp b/core/fpdfapi/page/cpdf_docpagedata.cpp
index 1a62218..215ec0a 100644
--- a/core/fpdfapi/page/cpdf_docpagedata.cpp
+++ b/core/fpdfapi/page/cpdf_docpagedata.cpp
@@ -417,9 +417,9 @@
 }
 
 RetainPtr<CPDF_StreamAcc> CPDF_DocPageData::GetFontFileStreamAcc(
-    const CPDF_Stream* pFontStream) {
+    RetainPtr<const CPDF_Stream> pFontStream) {
   DCHECK(pFontStream);
-  auto it = m_FontFileMap.find(pFontStream);
+  auto it = m_FontFileMap.find(pFontStream.Get());
   if (it != m_FontFileMap.end())
     return it->second;
 
@@ -435,9 +435,9 @@
     org_size = safe_org_size.ValueOrDefault(0);
   }
 
-  auto pFontAcc = pdfium::MakeRetain<CPDF_StreamAcc>(pFontStream);
+  auto pFontAcc = pdfium::MakeRetain<CPDF_StreamAcc>(pFontStream.Get());
   pFontAcc->LoadAllDataFilteredWithEstimatedSize(org_size);
-  m_FontFileMap[pFontStream] = pFontAcc;
+  m_FontFileMap[pFontStream.Get()] = pFontAcc;
   return pFontAcc;
 }
 
diff --git a/core/fpdfapi/page/cpdf_docpagedata.h b/core/fpdfapi/page/cpdf_docpagedata.h
index 5617d60..c22725b 100644
--- a/core/fpdfapi/page/cpdf_docpagedata.h
+++ b/core/fpdfapi/page/cpdf_docpagedata.h
@@ -41,7 +41,7 @@
   // CPDF_Document::PageDataIface:
   void ClearStockFont() override;
   RetainPtr<CPDF_StreamAcc> GetFontFileStreamAcc(
-      const CPDF_Stream* pFontStream) override;
+      RetainPtr<const CPDF_Stream> pFontStream) override;
   void MaybePurgeFontFileStreamAcc(const CPDF_Stream* pFontStream) override;
 
   // CPDF_Font::FormFactoryIFace:
diff --git a/core/fpdfapi/parser/cpdf_dictionary.cpp b/core/fpdfapi/parser/cpdf_dictionary.cpp
index 27c4c13..e03d286 100644
--- a/core/fpdfapi/parser/cpdf_dictionary.cpp
+++ b/core/fpdfapi/parser/cpdf_dictionary.cpp
@@ -193,13 +193,14 @@
   return pdfium::WrapRetain(SetNewFor<CPDF_Array>(key));
 }
 
-const CPDF_Stream* CPDF_Dictionary::GetStreamFor(const ByteString& key) const {
-  return ToStream(GetDirectObjectFor(key).Get());
+RetainPtr<const CPDF_Stream> CPDF_Dictionary::GetStreamFor(
+    const ByteString& key) const {
+  return ToStream(GetDirectObjectFor(key));
 }
 
 RetainPtr<CPDF_Stream> CPDF_Dictionary::GetMutableStreamFor(
     const ByteString& key) {
-  return pdfium::WrapRetain(const_cast<CPDF_Stream*>(GetStreamFor(key)));
+  return ToStream(GetMutableDirectObjectFor(key));
 }
 
 RetainPtr<const CPDF_Number> CPDF_Dictionary::GetNumberFor(
diff --git a/core/fpdfapi/parser/cpdf_dictionary.h b/core/fpdfapi/parser/cpdf_dictionary.h
index 5837121..a712096 100644
--- a/core/fpdfapi/parser/cpdf_dictionary.h
+++ b/core/fpdfapi/parser/cpdf_dictionary.h
@@ -72,7 +72,7 @@
   const CPDF_Array* GetArrayFor(const ByteString& key) const;
   RetainPtr<CPDF_Array> GetMutableArrayFor(const ByteString& key);
   RetainPtr<CPDF_Array> GetOrCreateArrayFor(const ByteString& key);
-  const CPDF_Stream* GetStreamFor(const ByteString& key) const;
+  RetainPtr<const CPDF_Stream> GetStreamFor(const ByteString& key) const;
   RetainPtr<CPDF_Stream> GetMutableStreamFor(const ByteString& key);
   RetainPtr<const CPDF_Number> GetNumberFor(const ByteString& key) const;
   CFX_FloatRect GetRectFor(const ByteString& key) const;
diff --git a/core/fpdfapi/parser/cpdf_document.h b/core/fpdfapi/parser/cpdf_document.h
index ccd393b..c189316 100644
--- a/core/fpdfapi/parser/cpdf_document.h
+++ b/core/fpdfapi/parser/cpdf_document.h
@@ -53,7 +53,7 @@
 
     virtual void ClearStockFont() = 0;
     virtual RetainPtr<CPDF_StreamAcc> GetFontFileStreamAcc(
-        const CPDF_Stream* pFontStream) = 0;
+        RetainPtr<const CPDF_Stream> pFontStream) = 0;
     virtual void MaybePurgeFontFileStreamAcc(
         const CPDF_Stream* pFontStream) = 0;
 
diff --git a/core/fpdfapi/render/charposlist.cpp b/core/fpdfapi/render/charposlist.cpp
index c07ddbe..71de6cf 100644
--- a/core/fpdfapi/render/charposlist.cpp
+++ b/core/fpdfapi/render/charposlist.cpp
@@ -9,6 +9,7 @@
 #include "build/build_config.h"
 #include "core/fpdfapi/font/cpdf_cidfont.h"
 #include "core/fpdfapi/font/cpdf_font.h"
+#include "core/fpdfapi/parser/cpdf_stream.h"
 #include "core/fxge/cfx_substfont.h"
 #include "core/fxge/text_char_pos.h"
 
diff --git a/core/fpdfdoc/cpdf_filespec.cpp b/core/fpdfdoc/cpdf_filespec.cpp
index fda2978..d05a47e 100644
--- a/core/fpdfdoc/cpdf_filespec.cpp
+++ b/core/fpdfdoc/cpdf_filespec.cpp
@@ -142,9 +142,11 @@
   for (size_t i = 0; i < end; ++i) {
     ByteString key = kKeys[i];
     if (!pDict->GetUnicodeTextFor(key).IsEmpty()) {
-      const CPDF_Stream* pStream = pFiles->GetStreamFor(key);
-      if (pStream)
-        return pStream;
+      RetainPtr<const CPDF_Stream> pStream = pFiles->GetStreamFor(key);
+      if (pStream) {
+        // TODO(tsepez): return retained object.
+        return pStream.Get();
+      }
     }
   }
   return nullptr;
diff --git a/core/fpdfdoc/cpdf_metadata.cpp b/core/fpdfdoc/cpdf_metadata.cpp
index 3759e73..6a8bfec 100644
--- a/core/fpdfdoc/cpdf_metadata.cpp
+++ b/core/fpdfdoc/cpdf_metadata.cpp
@@ -7,6 +7,7 @@
 #include "core/fpdfdoc/cpdf_metadata.h"
 
 #include <memory>
+#include <utility>
 
 #include "core/fpdfapi/parser/cpdf_stream.h"
 #include "core/fpdfapi/parser/cpdf_stream_acc.h"
@@ -61,8 +62,9 @@
 
 }  // namespace
 
-CPDF_Metadata::CPDF_Metadata(const CPDF_Stream* pStream) : stream_(pStream) {
-  DCHECK(pStream);
+CPDF_Metadata::CPDF_Metadata(RetainPtr<const CPDF_Stream> pStream)
+    : stream_(std::move(pStream)) {
+  DCHECK(stream_);
 }
 
 CPDF_Metadata::~CPDF_Metadata() = default;
diff --git a/core/fpdfdoc/cpdf_metadata.h b/core/fpdfdoc/cpdf_metadata.h
index 554492a..58c9a52 100644
--- a/core/fpdfdoc/cpdf_metadata.h
+++ b/core/fpdfdoc/cpdf_metadata.h
@@ -34,7 +34,7 @@
 
 class CPDF_Metadata {
  public:
-  explicit CPDF_Metadata(const CPDF_Stream* pStream);
+  explicit CPDF_Metadata(RetainPtr<const CPDF_Stream> pStream);
   ~CPDF_Metadata();
 
   std::vector<UnsupportedFeature> CheckForSharedForm() const;
diff --git a/core/fpdfdoc/cpdf_metadata_unittest.cpp b/core/fpdfdoc/cpdf_metadata_unittest.cpp
index 41f4b5d..66d9a77 100644
--- a/core/fpdfdoc/cpdf_metadata_unittest.cpp
+++ b/core/fpdfdoc/cpdf_metadata_unittest.cpp
@@ -17,7 +17,7 @@
 
   auto stream = pdfium::MakeRetain<CPDF_Stream>();
   stream->SetData(ByteStringView(data).raw_span());
-  CPDF_Metadata metadata(stream.Get());
+  CPDF_Metadata metadata(stream);
 
   auto results = metadata.CheckForSharedForm();
   ASSERT_EQ(1U, results.size());
@@ -34,7 +34,7 @@
 
   auto stream = pdfium::MakeRetain<CPDF_Stream>();
   stream->SetData(ByteStringView(data).raw_span());
-  CPDF_Metadata metadata(stream.Get());
+  CPDF_Metadata metadata(stream);
 
   auto results = metadata.CheckForSharedForm();
   ASSERT_EQ(1U, results.size());
@@ -51,7 +51,7 @@
 
   auto stream = pdfium::MakeRetain<CPDF_Stream>();
   stream->SetData(ByteStringView(data).raw_span());
-  CPDF_Metadata metadata(stream.Get());
+  CPDF_Metadata metadata(stream);
 
   auto results = metadata.CheckForSharedForm();
   ASSERT_EQ(1U, results.size());
@@ -68,7 +68,7 @@
 
   auto stream = pdfium::MakeRetain<CPDF_Stream>();
   stream->SetData(ByteStringView(data).raw_span());
-  CPDF_Metadata metadata(stream.Get());
+  CPDF_Metadata metadata(stream);
 
   auto results = metadata.CheckForSharedForm();
   EXPECT_EQ(0U, results.size());
@@ -86,7 +86,7 @@
 
   auto stream = pdfium::MakeRetain<CPDF_Stream>();
   stream->SetData(ByteStringView(data).raw_span());
-  CPDF_Metadata metadata(stream.Get());
+  CPDF_Metadata metadata(stream);
 
   auto results = metadata.CheckForSharedForm();
   ASSERT_EQ(1U, results.size());
@@ -100,7 +100,7 @@
 
   auto stream = pdfium::MakeRetain<CPDF_Stream>();
   stream->SetData(ByteStringView(data).raw_span());
-  CPDF_Metadata metadata(stream.Get());
+  CPDF_Metadata metadata(stream);
 
   auto results = metadata.CheckForSharedForm();
   EXPECT_EQ(0U, results.size());
@@ -116,7 +116,7 @@
 
   auto stream = pdfium::MakeRetain<CPDF_Stream>();
   stream->SetData(ByteStringView(data).raw_span());
-  CPDF_Metadata metadata(stream.Get());
+  CPDF_Metadata metadata(stream);
 
   auto results = metadata.CheckForSharedForm();
   EXPECT_EQ(0U, results.size());
@@ -146,7 +146,7 @@
 
   auto stream = pdfium::MakeRetain<CPDF_Stream>();
   stream->SetData(ByteStringView(data).raw_span());
-  CPDF_Metadata metadata(stream.Get());
+  CPDF_Metadata metadata(stream);
 
   auto results = metadata.CheckForSharedForm();
   ASSERT_EQ(3U, results.size());
diff --git a/fpdfsdk/cpdfsdk_helpers.cpp b/fpdfsdk/cpdfsdk_helpers.cpp
index 9d261e8..2cf0dcf 100644
--- a/fpdfsdk/cpdfsdk_helpers.cpp
+++ b/fpdfsdk/cpdfsdk_helpers.cpp
@@ -6,6 +6,8 @@
 
 #include "fpdfsdk/cpdfsdk_helpers.h"
 
+#include <utility>
+
 #include "build/build_config.h"
 #include "constants/form_fields.h"
 #include "constants/stream_dict_common.h"
@@ -375,9 +377,9 @@
   }
 
   // SharedForm
-  const CPDF_Stream* pStream = pRootDict->GetStreamFor("Metadata");
+  RetainPtr<const CPDF_Stream> pStream = pRootDict->GetStreamFor("Metadata");
   if (pStream) {
-    CPDF_Metadata metadata(pStream);
+    CPDF_Metadata metadata(std::move(pStream));
     for (const UnsupportedFeature& feature : metadata.CheckForSharedForm())
       RaiseUnsupportedError(static_cast<int>(feature));
   }
diff --git a/fpdfsdk/fpdf_edit_embeddertest.cpp b/fpdfsdk/fpdf_edit_embeddertest.cpp
index 642fad9..8fd558a 100644
--- a/fpdfsdk/fpdf_edit_embeddertest.cpp
+++ b/fpdfsdk/fpdf_edit_embeddertest.cpp
@@ -135,8 +135,8 @@
     EXPECT_TRUE(font_desc->KeyExist(present));
     EXPECT_FALSE(font_desc->KeyExist(absent));
 
-    auto streamAcc =
-        pdfium::MakeRetain<CPDF_StreamAcc>(font_desc->GetStreamFor(present));
+    auto streamAcc = pdfium::MakeRetain<CPDF_StreamAcc>(
+        font_desc->GetStreamFor(present).Get());
     streamAcc->LoadAllDataRaw();
 
     // Check that the font stream is the one that was provided
diff --git a/fpdfsdk/fpdf_thumbnail.cpp b/fpdfsdk/fpdf_thumbnail.cpp
index cb87152..eaef5ae 100644
--- a/fpdfsdk/fpdf_thumbnail.cpp
+++ b/fpdfsdk/fpdf_thumbnail.cpp
@@ -24,7 +24,8 @@
   if (!page_dict->KeyExist("Type"))
     return nullptr;
 
-  return page_dict->GetStreamFor("Thumb");
+  // TODO(tsepez): return retained objects.
+  return page_dict->GetStreamFor("Thumb").Get();
 }
 
 }  // namespace
diff --git a/testing/fuzzers/pdf_cpdf_tounicodemap_fuzzer.cc b/testing/fuzzers/pdf_cpdf_tounicodemap_fuzzer.cc
index 60ff1fc..e4ecbf7 100644
--- a/testing/fuzzers/pdf_cpdf_tounicodemap_fuzzer.cc
+++ b/testing/fuzzers/pdf_cpdf_tounicodemap_fuzzer.cc
@@ -5,6 +5,7 @@
 #include <fuzzer/FuzzedDataProvider.h>
 
 #include <memory>
+#include <utility>
 #include <vector>
 
 #include "core/fpdfapi/font/cpdf_tounicodemap.h"
@@ -30,7 +31,7 @@
   auto stream = pdfium::MakeRetain<CPDF_Stream>();
   stream->SetData(remaining);
 
-  auto to_unicode_map = std::make_unique<CPDF_ToUnicodeMap>(stream.Get());
+  auto to_unicode_map = std::make_unique<CPDF_ToUnicodeMap>(std::move(stream));
   to_unicode_map->Lookup(charcode_to_lookup);
   to_unicode_map->ReverseLookup(char_for_reverse_lookup);
   return 0;
