Remove CFX_Matrix::Copy() in favor of assignment

core/fpdftext/cpdf_textpage.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 "core/fpdftext/include/cpdf_textpage.h"
 
 #include <algorithm>
 #include <utility>
@@ skipping 369 matching lines @@
   info->m_OriginX = charinfo.m_OriginX;
   info->m_OriginY = charinfo.m_OriginY;
   info->m_Unicode = charinfo.m_Unicode;
   info->m_Flag = charinfo.m_Flag;
   info->m_CharBox = charinfo.m_CharBox;
   info->m_pTextObj = charinfo.m_pTextObj;
   if (charinfo.m_pTextObj && charinfo.m_pTextObj->GetFont())
     info->m_FontSize = charinfo.m_pTextObj->GetFontSize();
   else
     info->m_FontSize = kDefaultFontSize;
-  info->m_Matrix.Copy(charinfo.m_Matrix);
+  info->m_Matrix = charinfo.m_Matrix;
 }
 
 void CPDF_TextPage::CheckMarkedContentObject(int32_t& start,
                                              int32_t& nCount) const {
   PAGECHAR_INFO charinfo = m_CharList[start];
   PAGECHAR_INFO charinfo2 = m_CharList[start + nCount - 1];
   if (FPDFTEXT_CHAR_PIECE != charinfo.m_Flag &&
       FPDFTEXT_CHAR_PIECE != charinfo2.m_Flag) {
     return;
   }
@@ skipping 157 matching lines @@
 }
 
 void CPDF_TextPage::AppendGeneratedCharacter(FX_WCHAR unicode,
                                              const CFX_Matrix& formMatrix) {
   PAGECHAR_INFO generateChar;
   if (!GenerateCharInfo(unicode, generateChar))
     return;
 
   m_TextBuf.AppendChar(unicode);
   if (!formMatrix.IsIdentity())
-    generateChar.m_Matrix.Copy(formMatrix);
+    generateChar.m_Matrix = formMatrix;
   m_CharList.push_back(generateChar);
 }
 
 void CPDF_TextPage::ProcessObject() {
   if (m_pPage->GetPageObjectList()->empty())
     return;
 
   m_TextlineDir = FindTextlineFlowOrientation();
   const CPDF_PageObjectList* pObjList = m_pPage->GetPageObjectList();
   for (auto it = pObjList->begin(); it != pObjList->end(); ++it) {
@@ skipping 14 matching lines @@
   CloseTempLine();
 }
 
 void CPDF_TextPage::ProcessFormObject(CPDF_FormObject* pFormObj,
                                       const CFX_Matrix& formMatrix) {
   CPDF_PageObjectList* pObjectList = pFormObj->m_pForm->GetPageObjectList();
   if (pObjectList->empty())
     return;
 
   CFX_Matrix curFormMatrix;
-  curFormMatrix.Copy(pFormObj->m_FormMatrix);
+  curFormMatrix = pFormObj->m_FormMatrix;
   curFormMatrix.Concat(formMatrix);
 
   for (auto it = pObjectList->begin(); it != pObjectList->end(); ++it) {
     if (CPDF_PageObject* pPageObj = it->get()) {
       if (pPageObj->IsText())
         ProcessTextObject(pPageObj->AsText(), curFormMatrix, pObjectList, it);
       else if (pPageObj->IsForm())
         ProcessFormObject(pPageObj->AsForm(), curFormMatrix);
     }
   }
@@ skipping 300 matching lines @@
     charinfo.m_OriginY = fPosY;
     charinfo.m_Index = nCharInfoIndex;
     charinfo.m_Unicode = wChar;
     charinfo.m_CharCode = pFont->CharCodeFromUnicode(wChar);
     charinfo.m_Flag = FPDFTEXT_CHAR_PIECE;
     charinfo.m_pTextObj = pTextObj;
     charinfo.m_CharBox.top = charBox.top;
     charinfo.m_CharBox.left = charBox.left;
     charinfo.m_CharBox.right = charBox.right;
     charinfo.m_CharBox.bottom = charBox.bottom;
-    charinfo.m_Matrix.Copy(matrix);
+    charinfo.m_Matrix = matrix;
     m_TempTextBuf.AppendChar(wChar);
     m_TempCharList.push_back(charinfo);
   }
 }
 
 void CPDF_TextPage::FindPreviousTextObject() {
   if (m_TempCharList.empty() && m_CharList.empty())
     return;
 
   PAGECHAR_INFO preChar =
@@ skipping 42 matching lines @@
   if (FXSYS_fabs(pTextObj->m_Right - pTextObj->m_Left) < 0.01f)
     return;
   CFX_Matrix formMatrix = Obj.m_formMatrix;
   CPDF_Font* pFont = pTextObj->GetFont();
   CFX_Matrix matrix;
   pTextObj->GetTextMatrix(&matrix);
   matrix.Concat(formMatrix);
   FPDFText_MarkedContent ePreMKC = PreMarkedContent(Obj);
   if (ePreMKC == FPDFText_MarkedContent::Done) {
     m_pPreTextObj = pTextObj;
-    m_perMatrix.Copy(formMatrix);
+    m_perMatrix = formMatrix;
     return;
   }
   GenerateCharacter result = GenerateCharacter::None;
   if (m_pPreTextObj) {
     result = ProcessInsertObject(pTextObj, formMatrix);
     if (result == GenerateCharacter::LineBreak) {
       m_CurlineRect =
           CFX_FloatRect(Obj.m_pTextObj->m_Left, Obj.m_pTextObj->m_Bottom,
                         Obj.m_pTextObj->m_Right, Obj.m_pTextObj->m_Top);
     } else {
       m_CurlineRect.Union(
           CFX_FloatRect(Obj.m_pTextObj->m_Left, Obj.m_pTextObj->m_Bottom,
                         Obj.m_pTextObj->m_Right, Obj.m_pTextObj->m_Top));
     }
     switch (result) {
       case GenerateCharacter::None:
         break;
       case GenerateCharacter::Space: {
         PAGECHAR_INFO generateChar;
         if (GenerateCharInfo(TEXT_SPACE_CHAR, generateChar)) {
           if (!formMatrix.IsIdentity())
-            generateChar.m_Matrix.Copy(formMatrix);
+            generateChar.m_Matrix = formMatrix;
           m_TempTextBuf.AppendChar(TEXT_SPACE_CHAR);
           m_TempCharList.push_back(generateChar);
         }
         break;
       }
       case GenerateCharacter::LineBreak:
         CloseTempLine();
         if (m_TextBuf.GetSize()) {
           AppendGeneratedCharacter(TEXT_RETURN_CHAR, formMatrix);
           AppendGeneratedCharacter(TEXT_LINEFEED_CHAR, formMatrix);
@@ skipping 25 matching lines @@
         break;
     }
   } else {
     m_CurlineRect =
         CFX_FloatRect(Obj.m_pTextObj->m_Left, Obj.m_pTextObj->m_Bottom,
                       Obj.m_pTextObj->m_Right, Obj.m_pTextObj->m_Top);
   }
   if (ePreMKC == FPDFText_MarkedContent::Delay) {
     ProcessMarkedContent(Obj);
     m_pPreTextObj = pTextObj;
-    m_perMatrix.Copy(formMatrix);
+    m_perMatrix = formMatrix;
     return;
   }
   m_pPreTextObj = pTextObj;
-  m_perMatrix.Copy(formMatrix);
+  m_perMatrix = formMatrix;
   int nItems = pTextObj->CountItems();
   FX_FLOAT baseSpace = CalculateBaseSpace(pTextObj, matrix);
 
   const FX_BOOL bR2L = IsRightToLeft(pTextObj, pFont, nItems);
   const FX_BOOL bIsBidiAndMirrorInverse =
       bR2L && (matrix.a * matrix.d - matrix.b * matrix.c) < 0;
   int32_t iBufStartAppend = m_TempTextBuf.GetLength();
   int32_t iCharListStartAppend =
       pdfium::CollectionSize<int32_t>(m_TempCharList);
 
@@ skipping 40 matching lines @@
         threshold = NormalizeThreshold(threshold);
         threshold = fontsize_h * threshold / 1000;
       }
       if (threshold && (spacing && spacing >= threshold)) {
         charinfo.m_Unicode = TEXT_SPACE_CHAR;
         charinfo.m_Flag = FPDFTEXT_CHAR_GENERATED;
         charinfo.m_pTextObj = pTextObj;
         charinfo.m_Index = m_TextBuf.GetLength();
         m_TempTextBuf.AppendChar(TEXT_SPACE_CHAR);
         charinfo.m_CharCode = CPDF_Font::kInvalidCharCode;
-        charinfo.m_Matrix.Copy(formMatrix);
+        charinfo.m_Matrix = formMatrix;
         matrix.Transform(item.m_OriginX, item.m_OriginY, charinfo.m_OriginX,
                          charinfo.m_OriginY);
         charinfo.m_CharBox =
             CFX_FloatRect(charinfo.m_OriginX, charinfo.m_OriginY,
                           charinfo.m_OriginX, charinfo.m_OriginY);
         m_TempCharList.push_back(charinfo);
       }
       if (item.m_CharCode == CPDF_Font::kInvalidCharCode)
         continue;
     }
@@ skipping 30 matching lines @@
         rect.bottom * pTextObj->GetFontSize() / 1000 + item.m_OriginY;
     if (fabsf(charinfo.m_CharBox.top - charinfo.m_CharBox.bottom) < 0.01f) {
       charinfo.m_CharBox.top =
           charinfo.m_CharBox.bottom + pTextObj->GetFontSize();
     }
     if (fabsf(charinfo.m_CharBox.right - charinfo.m_CharBox.left) < 0.01f) {
       charinfo.m_CharBox.right =
           charinfo.m_CharBox.left + pTextObj->GetCharWidth(charinfo.m_CharCode);
     }
     matrix.TransformRect(charinfo.m_CharBox);
-    charinfo.m_Matrix.Copy(matrix);
+    charinfo.m_Matrix = matrix;
     if (wstrItem.IsEmpty()) {
       charinfo.m_Unicode = 0;
       m_TempCharList.push_back(charinfo);
       m_TempTextBuf.AppendChar(0xfffe);
       continue;
     } else {
       int nTotal = wstrItem.GetLength();
       bool bDel = false;
       const int count =
           std::min(pdfium::CollectionSize<int>(m_TempCharList), 7);
@@ skipping 355 matching lines @@
                                  info.m_OriginY);
   return TRUE;
 }
 
 FX_BOOL CPDF_TextPage::IsRectIntersect(const CFX_FloatRect& rect1,
                                        const CFX_FloatRect& rect2) {
   CFX_FloatRect rect = rect1;
   rect.Intersect(rect2);
   return !rect.IsEmpty();
 }