Pass CFX_*StringCs to FX_HashCode_GETA and _GETW hash functions.

xfa/fxfa/app/xfa_textlayout.cpp

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #include "xfa/fxfa/app/xfa_textlayout.h"
 
 #include <algorithm>
 
@@ skipping 94 matching lines @@
   CXFA_Para para = pTextProvider->GetParaNode();
   IFDE_CSSComputedStyle* pStyle = m_pSelector->CreateComputedStyle(NULL);
   IFDE_CSSFontStyle* pFontStyle = pStyle->GetFontStyles();
   IFDE_CSSParagraphStyle* pParaStyle = pStyle->GetParagraphStyles();
   FX_FLOAT fLineHeight = 0, fFontSize = 10;
   if (para) {
     fLineHeight = para.GetLineHeight();
     FDE_CSSLENGTH indent;
     indent.Set(FDE_CSSLENGTHUNIT_Point, para.GetTextIndent());
     pParaStyle->SetTextIndent(indent);
-    FDE_CSSTEXTALIGN hAlgin = FDE_CSSTEXTALIGN_Left;
+    FDE_CSSTEXTALIGN hAlign = FDE_CSSTEXTALIGN_Left;
     switch (para.GetHorizontalAlign()) {
       case XFA_ATTRIBUTEENUM_Center:
-        hAlgin = FDE_CSSTEXTALIGN_Center;
+        hAlign = FDE_CSSTEXTALIGN_Center;
         break;
       case XFA_ATTRIBUTEENUM_Right:
-        hAlgin = FDE_CSSTEXTALIGN_Right;
+        hAlign = FDE_CSSTEXTALIGN_Right;
         break;
       case XFA_ATTRIBUTEENUM_Justify:
-        hAlgin = FDE_CSSTEXTALIGN_Justify;
+        hAlign = FDE_CSSTEXTALIGN_Justify;
         break;
       case XFA_ATTRIBUTEENUM_JustifyAll:
-        hAlgin = FDE_CSSTEXTALIGN_JustifyAll;
+        hAlign = FDE_CSSTEXTALIGN_JustifyAll;
         break;
     }
-    pParaStyle->SetTextAlign(hAlgin);
+    pParaStyle->SetTextAlign(hAlign);
     FDE_CSSRECT rtMarginWidth;
     rtMarginWidth.left.Set(FDE_CSSLENGTHUNIT_Point, para.GetMarginLeft());
     rtMarginWidth.top.Set(FDE_CSSLENGTHUNIT_Point, para.GetSpaceAbove());
     rtMarginWidth.right.Set(FDE_CSSLENGTHUNIT_Point, para.GetMarginRight());
     rtMarginWidth.bottom.Set(FDE_CSSLENGTHUNIT_Point, para.GetSpaceBelow());
     pStyle->GetBoundaryStyles()->SetMarginWidth(rtMarginWidth);
   }
   if (font) {
     pFontStyle->SetColor(font.GetColor());
     pFontStyle->SetFontStyle(font.IsItalic() ? FDE_CSSFONTSTYLE_Italic
@@ skipping 127 matching lines @@
   static const uint32_t s_XFATagName[] = {
       0x61,       0x62,       0x69,       0x70,       0x0001f714,
       0x00022a55, 0x000239bb, 0x00025881, 0x0bd37faa, 0x0bd37fb8,
       0xa73e3af2, 0xb182eaae, 0xdb8ac455,
   };
   CFX_WideString wsName;
   if (pXMLNode->GetType() == FDE_XMLNODE_Element) {
     CFDE_XMLElement* pXMLElement = static_cast<CFDE_XMLElement*>(pXMLNode);
     pXMLElement->GetLocalTagName(wsName);
     tagProvider.SetTagNameObj(wsName);
-    uint32_t dwHashCode =
-        FX_HashCode_String_GetW(wsName.c_str(), wsName.GetLength(), TRUE);
+    uint32_t dwHashCode = FX_HashCode_GetW(wsName.AsStringC(), true);
     static const int32_t s_iCount = sizeof(s_XFATagName) / sizeof(uint32_t);
     CFX_DSPATemplate<uint32_t> lookup;
     tagProvider.m_bTagAviliable =
         lookup.Lookup(dwHashCode, s_XFATagName, s_iCount) > -1;
     CFX_WideString wsValue;
     pXMLElement->GetString(FX_WSTRC(L"style").c_str(), wsValue);
     if (!wsValue.IsEmpty()) {
       tagProvider.SetAttribute(FX_WSTRC(L"style"), wsValue);
     }
   } else if (pXMLNode->GetType() == FDE_XMLNODE_Text) {
     tagProvider.m_bTagAviliable = TRUE;
     tagProvider.m_bContent = TRUE;
   }
 }
 
-int32_t CXFA_TextParser::GetVAlgin(CXFA_TextProvider* pTextProvider) const {
+int32_t CXFA_TextParser::GetVAlign(CXFA_TextProvider* pTextProvider) const {
   CXFA_Para para = pTextProvider->GetParaNode();
   return para ? para.GetVerticalAlign() : XFA_ATTRIBUTEENUM_Top;
 }
 
 FX_FLOAT CXFA_TextParser::GetTabInterval(IFDE_CSSComputedStyle* pStyle) const {
   CFX_WideString wsValue;
   if (pStyle && pStyle->GetCustomStyle(FX_WSTRC(L"tab-interval"), wsValue))
     return CXFA_Measurement(wsValue.AsStringC()).ToUnit(XFA_UNIT_Pt);
   return 36;
 }
@@ skipping 300 matching lines @@
           }
           while (iCur < iLength && pTabStops[iCur] <= ' ') {
             iCur++;
           }
           iLast = iCur;
           eStatus = XFA_TABSTOPSSTATUS_Location;
         }
         break;
       case XFA_TABSTOPSSTATUS_Location:
         if (ch == ' ') {
-          uint32_t dwHashCode = FX_HashCode_String_GetW(
-              wsAlign.c_str(), wsAlign.GetLength(), TRUE);
+          uint32_t dwHashCode = FX_HashCode_GetW(wsAlign.AsStringC(), true);
           CXFA_Measurement ms(CFX_WideStringC(pTabStops + iLast, iCur - iLast));
           FX_FLOAT fPos = ms.ToUnit(XFA_UNIT_Pt);
           pTabstopContext->Append(dwHashCode, fPos);
           wsAlign.clear();
           eStatus = XFA_TABSTOPSSTATUS_None;
         }
         iCur++;
         break;
       default:
         break;
     }
   }
   if (!wsAlign.IsEmpty()) {
-    uint32_t dwHashCode =
-        FX_HashCode_String_GetW(wsAlign.c_str(), wsAlign.GetLength(), TRUE);
+    uint32_t dwHashCode = FX_HashCode_GetW(wsAlign.AsStringC(), true);
     CXFA_Measurement ms(CFX_WideStringC(pTabStops + iLast, iCur - iLast));
     FX_FLOAT fPos = ms.ToUnit(XFA_UNIT_Pt);
     pTabstopContext->Append(dwHashCode, fPos);
   }
   return TRUE;
 }
 CXFA_TextLayout::CXFA_TextLayout(CXFA_TextProvider* pTextProvider)
     : m_bHasBlock(FALSE),
       m_pTextProvider(pTextProvider),
       m_pTextDataNode(nullptr),
@@ skipping 284 matching lines @@
     fHeight = GetLayoutHeight();
   }
   m_pLoader->m_fHeight = fHeight;
   if (fContentAreaHeight < 0) {
     return FALSE;
   }
   m_bHasBlock = TRUE;
   if (iBlockCount == 0 && fHeight > 0) {
     fHeight = fTextHeight - GetLayoutHeight();
     if (fHeight > 0) {
-      int32_t iAlign = m_textParser.GetVAlgin(m_pTextProvider);
+      int32_t iAlign = m_textParser.GetVAlign(m_pTextProvider);
       if (iAlign == XFA_ATTRIBUTEENUM_Middle) {
         fHeight /= 2.0f;
       } else if (iAlign != XFA_ATTRIBUTEENUM_Bottom) {
         fHeight = 0;
       }
       m_pLoader->m_fStartLineOffset = fHeight;
     }
   }
   FX_FLOAT fLinePos = m_pLoader->m_fStartLineOffset;
   int32_t iLineIndex = 0;
@@ skipping 298 matching lines @@
   delete pSolidBrush;
   delete pPen;
   pDevice->Release();
   return iPieceLines;
 }
 void CXFA_TextLayout::UpdateAlign(FX_FLOAT fHeight, FX_FLOAT fBottom) {
   fHeight -= fBottom;
   if (fHeight < 0.1f) {
     return;
   }
-  switch (m_textParser.GetVAlgin(m_pTextProvider)) {
+  switch (m_textParser.GetVAlign(m_pTextProvider)) {
     case XFA_ATTRIBUTEENUM_Middle:
       fHeight /= 2.0f;
       break;
     case XFA_ATTRIBUTEENUM_Bottom:
       break;
     default:
       return;
   }
   int32_t iCount = m_pieceLines.GetSize();
   for (int32_t i = 0; i < iCount; i++) {
@@ skipping 369 matching lines @@
       XFA_TextPiece* p = pPieceLine->m_textPieces.GetAt(iPieces - 2);
       fRight = p->rtPiece.right();
     }
     m_pTabstopContext->m_fTabWidth =
         pPiece->rtPiece.width + pPiece->rtPiece.left - fRight;
   } else if (iTabstopsIndex > -1) {
     FX_FLOAT fLeft = 0;
     if (m_pTabstopContext->m_bTabstops) {
       XFA_TABSTOPS* pTabstops =
           m_pTabstopContext->m_tabstops.GetDataPtr(iTabstopsIndex);
-      uint32_t dwAlgin = pTabstops->dwAlign;
-      if (dwAlgin == FX_HashCode_String_GetW(L"center", 6)) {
+      uint32_t dwAlign = pTabstops->dwAlign;
+      if (dwAlign == FX_HashCode_GetW(L"center", false)) {
         fLeft = pPiece->rtPiece.width / 2.0f;
-      } else if (dwAlgin == FX_HashCode_String_GetW(L"right", 5) ||
-                 dwAlgin == FX_HashCode_String_GetW(L"before", 6)) {
+      } else if (dwAlign == FX_HashCode_GetW(L"right", false) ||
+                 dwAlign == FX_HashCode_GetW(L"before", false)) {
         fLeft = pPiece->rtPiece.width;
-      } else if (dwAlgin == FX_HashCode_String_GetW(L"decimal", 7)) {
+      } else if (dwAlign == FX_HashCode_GetW(L"decimal", false)) {
         int32_t iChars = pPiece->iChars;
         for (int32_t i = 0; i < iChars; i++) {
           if (pPiece->pszText[i] == L'.') {
             break;
           }
           fLeft += pPiece->pWidths[i] / 20000.0f;
         }
       }
       m_pTabstopContext->m_fLeft =
           std::min(fLeft, m_pTabstopContext->m_fTabWidth);
@@ skipping 300 matching lines @@
   tr.iLength = iLength;
   tr.fFontSize = pPiece->fFontSize;
   tr.iBidiLevel = pPiece->iBidiLevel;
   tr.iCharRotation = 0;
   tr.wLineBreakChar = L'\n';
   tr.iVerticalScale = pPiece->iVerScale;
   tr.dwLayoutStyles = FX_RTFLAYOUTSTYLE_ExpandTab;
   tr.iHorizontalScale = pPiece->iHorScale;
   return TRUE;
 }