diff --git a/core/fpdfapi/page/cpdf_textstate.cpp b/core/fpdfapi/page/cpdf_textstate.cpp
index 8b65332..b8019d5 100644
--- a/core/fpdfapi/page/cpdf_textstate.cpp
+++ b/core/fpdfapi/page/cpdf_textstate.cpp
@@ -58,22 +58,10 @@
   m_Ref.GetPrivateCopy()->m_WordSpace = sp;
 }
 
-float CPDF_TextState::GetFontSizeV() const {
-  return m_Ref.GetObject()->GetFontSizeV();
-}
-
 float CPDF_TextState::GetFontSizeH() const {
   return m_Ref.GetObject()->GetFontSizeH();
 }
 
-float CPDF_TextState::GetBaselineAngle() const {
-  return m_Ref.GetObject()->GetBaselineAngle();
-}
-
-float CPDF_TextState::GetShearAngle() const {
-  return m_Ref.GetObject()->GetShearAngle();
-}
-
 TextRenderingMode CPDF_TextState::GetTextMode() const {
   return m_Ref.GetObject()->m_TextMode;
 }
@@ -133,22 +121,10 @@
   m_pFont = pFont;
 }
 
-float CPDF_TextState::TextData::GetFontSizeV() const {
-  return fabs(FXSYS_sqrt2(m_Matrix[1], m_Matrix[3]) * m_FontSize);
-}
-
 float CPDF_TextState::TextData::GetFontSizeH() const {
   return fabs(FXSYS_sqrt2(m_Matrix[0], m_Matrix[2]) * m_FontSize);
 }
 
-float CPDF_TextState::TextData::GetBaselineAngle() const {
-  return atan2(m_Matrix[2], m_Matrix[0]);
-}
-
-float CPDF_TextState::TextData::GetShearAngle() const {
-  return GetBaselineAngle() + atan2(m_Matrix[1], m_Matrix[3]);
-}
-
 bool SetTextRenderingModeFromInt(int iMode, TextRenderingMode* mode) {
   if (iMode < 0 || iMode > 7)
     return false;
diff --git a/core/fpdfapi/page/cpdf_textstate.h b/core/fpdfapi/page/cpdf_textstate.h
index a95e1de..5cc0c1d 100644
--- a/core/fpdfapi/page/cpdf_textstate.h
+++ b/core/fpdfapi/page/cpdf_textstate.h
@@ -50,10 +50,7 @@
   float GetWordSpace() const;
   void SetWordSpace(float sp);
 
-  float GetFontSizeV() const;
   float GetFontSizeH() const;
-  float GetBaselineAngle() const;
-  float GetShearAngle() const;
 
   TextRenderingMode GetTextMode() const;
   void SetTextMode(TextRenderingMode mode);
@@ -72,8 +69,6 @@
     void SetFont(const RetainPtr<CPDF_Font>& pFont);
     float GetFontSizeV() const;
     float GetFontSizeH() const;
-    float GetBaselineAngle() const;
-    float GetShearAngle() const;
 
     RetainPtr<CPDF_Font> m_pFont;
     UnownedPtr<CPDF_Document> m_pDocument;
