Revert "Add -> operators to CFX_CountRef."

core/fpdfapi/fpdf_page/fpdf_page_parser.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/fpdfapi/fpdf_page/pageint.h"
 
 #include <memory>
 #include <utility>
@@ skipping 565 matching lines @@
     return;
   }
   FX_BOOL bDirect = TRUE;
   if (pProperty->IsName()) {
     pProperty = FindResourceObj("Properties", pProperty->GetString());
     if (!pProperty)
       return;
     bDirect = FALSE;
   }
   if (CPDF_Dictionary* pDict = pProperty->AsDictionary()) {
-    m_CurContentMark.MakePrivateCopy();
-    m_CurContentMark->AddMark(tag, pDict, bDirect);
+    m_CurContentMark.GetPrivateCopy()->AddMark(tag, pDict, bDirect);
   }
 }
 
 void CPDF_StreamContentParser::Handle_BeginImage() {
   FX_FILESIZE savePos = m_pSyntax->GetPos();
   CPDF_Dictionary* pDict = new CPDF_Dictionary;
   while (1) {
     CPDF_StreamParser::SyntaxType type = m_pSyntax->ParseNextElement();
     if (type == CPDF_StreamParser::Keyword) {
       CFX_ByteString bsKeyword(m_pSyntax->GetWordBuf(),
@@ skipping 54 matching lines @@
   if (!pImgObj) {
     if (pStream) {
       pStream->Release();
     } else {
       pDict->Release();
     }
   }
 }
 
 void CPDF_StreamContentParser::Handle_BeginMarkedContent() {
-  m_CurContentMark.MakePrivateCopy();
-  m_CurContentMark->AddMark(GetString(0), nullptr, FALSE);
+  CFX_ByteString tag = GetString(0);
+  m_CurContentMark.GetPrivateCopy()->AddMark(tag, nullptr, FALSE);
 }
 
 void CPDF_StreamContentParser::Handle_BeginText() {
   m_pCurStates->m_TextMatrix.Set(1.0f, 0, 0, 1.0f, 0, 0);
   OnChangeTextMatrix();
   m_pCurStates->m_TextX = 0;
   m_pCurStates->m_TextY = 0;
   m_pCurStates->m_TextLineX = 0;
   m_pCurStates->m_TextLineY = 0;
 }
 
 void CPDF_StreamContentParser::Handle_CurveTo_123() {
   AddPathPoint(GetNumber(5), GetNumber(4), FXPT_BEZIERTO);
   AddPathPoint(GetNumber(3), GetNumber(2), FXPT_BEZIERTO);
   AddPathPoint(GetNumber(1), GetNumber(0), FXPT_BEZIERTO);
 }
 
 void CPDF_StreamContentParser::Handle_ConcatMatrix() {
   CFX_Matrix new_matrix(GetNumber(5), GetNumber(4), GetNumber(3), GetNumber(2),
                         GetNumber(1), GetNumber(0));
   new_matrix.Concat(m_pCurStates->m_CTM);
   m_pCurStates->m_CTM = new_matrix;
   OnChangeTextMatrix();
 }
 
 void CPDF_StreamContentParser::Handle_SetColorSpace_Fill() {
-  CPDF_ColorSpace* pCS = FindColorSpace(GetString(0));
-  if (!pCS)
+  CFX_ByteString csname = GetString(0);
+  CPDF_ColorSpace* pCS = FindColorSpace(csname);
+  if (!pCS) {
     return;
-
-  m_pCurStates->m_ColorState.MakePrivateCopy();
-  m_pCurStates->m_ColorState->m_FillColor.SetColorSpace(pCS);
+  }
+  m_pCurStates->m_ColorState.GetPrivateCopy()->m_FillColor.SetColorSpace(pCS);
 }
 
 void CPDF_StreamContentParser::Handle_SetColorSpace_Stroke() {
-  CPDF_ColorSpace* pCS = FindColorSpace(GetString(0));
-  if (!pCS)
+  CFX_ByteString csname = GetString(0);
+  CPDF_ColorSpace* pCS = FindColorSpace(csname);
+  if (!pCS) {
     return;
-
-  m_pCurStates->m_ColorState.MakePrivateCopy();
-  m_pCurStates->m_ColorState->m_StrokeColor.SetColorSpace(pCS);
+  }
+  m_pCurStates->m_ColorState.GetPrivateCopy()->m_StrokeColor.SetColorSpace(pCS);
 }
 
 void CPDF_StreamContentParser::Handle_SetDash() {
   CPDF_Array* pArray = ToArray(GetObject(1));
   if (!pArray)
     return;
 
   m_pCurStates->SetLineDash(pArray, GetNumber(0), 1.0f);
 }
 
@@ skipping 90 matching lines @@
 }
 
 void CPDF_StreamContentParser::Handle_MarkPlace_Dictionary() {}
 
 void CPDF_StreamContentParser::Handle_EndImage() {}
 
 void CPDF_StreamContentParser::Handle_EndMarkedContent() {
   if (!m_CurContentMark)
     return;
 
-  if (m_CurContentMark->CountItems() == 1) {
-    m_CurContentMark.Clear();
+  int count = m_CurContentMark.GetObject()->CountItems();
+  if (count == 1) {
+    m_CurContentMark.SetNull();
     return;
   }
-
-  m_CurContentMark.MakePrivateCopy();
-  m_CurContentMark->DeleteLastMark();
+  m_CurContentMark.GetPrivateCopy()->DeleteLastMark();
 }
 
 void CPDF_StreamContentParser::Handle_EndText() {
   if (m_ClipTextList.empty())
     return;
 
-  if (TextRenderingModeIsClipMode(m_pCurStates->m_TextState->m_TextMode))
+  if (TextRenderingModeIsClipMode(
+          m_pCurStates->m_TextState.GetObject()->m_TextMode)) {
     m_pCurStates->m_ClipPath.AppendTexts(&m_ClipTextList);
-
+  }
   m_ClipTextList.clear();
 }
 
 void CPDF_StreamContentParser::Handle_FillPath() {
   AddPathObject(FXFILL_WINDING, FALSE);
 }
 
 void CPDF_StreamContentParser::Handle_FillPathOld() {
   AddPathObject(FXFILL_WINDING, FALSE);
 }
@@ skipping 29 matching lines @@
     return;
   }
   if (m_PathStartX != m_PathCurrentX || m_PathStartY != m_PathCurrentY) {
     AddPathPoint(m_PathStartX, m_PathStartY, FXPT_LINETO | FXPT_CLOSEFIGURE);
   } else if (m_pPathPoints[m_PathPointCount - 1].m_Flag != FXPT_MOVETO) {
     m_pPathPoints[m_PathPointCount - 1].m_Flag |= FXPT_CLOSEFIGURE;
   }
 }
 
 void CPDF_StreamContentParser::Handle_SetFlat() {
-  m_pCurStates->m_GeneralState.MakePrivateCopy();
-  m_pCurStates->m_GeneralState->m_Flatness = GetNumber(0);
+  m_pCurStates->m_GeneralState.GetPrivateCopy()->m_Flatness = GetNumber(0);
 }
 
 void CPDF_StreamContentParser::Handle_BeginImageData() {}
 
 void CPDF_StreamContentParser::Handle_SetLineJoin() {
-  m_pCurStates->m_GraphState.MakePrivateCopy();
-  m_pCurStates->m_GraphState->m_LineJoin =
-      static_cast<CFX_GraphStateData::LineJoin>(GetInteger(0));
+  m_pCurStates->m_GraphState.GetPrivateCopy()->m_LineJoin =
+      (CFX_GraphStateData::LineJoin)GetInteger(0);
 }
 
 void CPDF_StreamContentParser::Handle_SetLineCap() {
-  m_pCurStates->m_GraphState.MakePrivateCopy();
-  m_pCurStates->m_GraphState->m_LineCap =
-      static_cast<CFX_GraphStateData::LineCap>(GetInteger(0));
+  m_pCurStates->m_GraphState.GetPrivateCopy()->m_LineCap =
+      (CFX_GraphStateData::LineCap)GetInteger(0);
 }
 
 void CPDF_StreamContentParser::Handle_SetCMYKColor_Fill() {
   if (m_ParamCount != 4)
     return;
 
   FX_FLOAT values[4];
   for (int i = 0; i < 4; i++) {
     values[i] = GetNumber(3 - i);
   }
@@ skipping 22 matching lines @@
 
 void CPDF_StreamContentParser::Handle_MoveTo() {
   if (m_ParamCount != 2)
     return;
 
   AddPathPoint(GetNumber(1), GetNumber(0), FXPT_MOVETO);
   ParsePathObject();
 }
 
 void CPDF_StreamContentParser::Handle_SetMiterLimit() {
-  m_pCurStates->m_GraphState.MakePrivateCopy();
-  m_pCurStates->m_GraphState->m_MiterLimit = GetNumber(0);
+  m_pCurStates->m_GraphState.GetPrivateCopy()->m_MiterLimit = GetNumber(0);
 }
 
 void CPDF_StreamContentParser::Handle_MarkPlace() {}
 
 void CPDF_StreamContentParser::Handle_EndPath() {
   AddPathObject(0, FALSE);
 }
 
 void CPDF_StreamContentParser::Handle_SaveGraphState() {
   std::unique_ptr<CPDF_AllStates> pStates(new CPDF_AllStates);
@@ skipping 162 matching lines @@
   if (pShading->IsMeshShading())
     bbox.Intersect(GetShadingBBox(pShading, pObj->m_Matrix));
   pObj->m_Left = bbox.left;
   pObj->m_Right = bbox.right;
   pObj->m_Top = bbox.top;
   pObj->m_Bottom = bbox.bottom;
   m_pObjectHolder->GetPageObjectList()->push_back(std::move(pObj));
 }
 
 void CPDF_StreamContentParser::Handle_SetCharSpace() {
-  m_pCurStates->m_TextState.MakePrivateCopy();
-  m_pCurStates->m_TextState->m_CharSpace = GetNumber(0);
+  m_pCurStates->m_TextState.GetPrivateCopy()->m_CharSpace = GetNumber(0);
 }
 
 void CPDF_StreamContentParser::Handle_MoveTextPoint() {
   m_pCurStates->m_TextLineX += GetNumber(1);
   m_pCurStates->m_TextLineY += GetNumber(0);
   m_pCurStates->m_TextX = m_pCurStates->m_TextLineX;
   m_pCurStates->m_TextY = m_pCurStates->m_TextLineY;
 }
 
 void CPDF_StreamContentParser::Handle_MoveTextPoint_SetLeading() {
   Handle_MoveTextPoint();
   m_pCurStates->m_TextLeading = -GetNumber(0);
 }
 
 void CPDF_StreamContentParser::Handle_SetFont() {
   FX_FLOAT fs = GetNumber(0);
-  if (fs == 0)
+  if (fs == 0) {
     fs = m_DefFontSize;
-
-  m_pCurStates->m_TextState.MakePrivateCopy();
-  m_pCurStates->m_TextState->m_FontSize = fs;
+  }
+  m_pCurStates->m_TextState.GetPrivateCopy()->m_FontSize = fs;
   CPDF_Font* pFont = FindFont(GetString(1));
-  if (pFont)
+  if (pFont) {
     m_pCurStates->m_TextState.SetFont(pFont);
+  }
 }
 
 CPDF_Object* CPDF_StreamContentParser::FindResourceObj(
     const CFX_ByteString& type,
     const CFX_ByteString& name) {
   if (!m_pResources)
     return nullptr;
   CPDF_Dictionary* pDict = m_pResources->GetDictBy(type);
   if (pDict)
     return pDict->GetDirectObjectBy(name);
@@ skipping 84 matching lines @@
     } else {
       m_pCurStates->m_TextY -=
           (fInitKerning * m_pCurStates->m_TextState.GetFontSize()) / 1000;
     }
   }
   if (nsegs == 0) {
     return;
   }
   const TextRenderingMode text_mode =
       pFont->IsType3Font() ? TextRenderingMode::MODE_FILL
-                           : m_pCurStates->m_TextState->m_TextMode;
+                           : m_pCurStates->m_TextState.GetObject()->m_TextMode;
   {
     std::unique_ptr<CPDF_TextObject> pText(new CPDF_TextObject);
     m_pLastTextObject = pText.get();
     SetGraphicStates(m_pLastTextObject, TRUE, TRUE, TRUE);
     if (TextRenderingModeIsStrokeMode(text_mode)) {
-      pText->m_TextState.MakePrivateCopy();
-      FX_FLOAT* pCTM = pText->m_TextState->m_CTM;
+      FX_FLOAT* pCTM = pText->m_TextState.GetPrivateCopy()->m_CTM;
       pCTM[0] = m_pCurStates->m_CTM.a;
       pCTM[1] = m_pCurStates->m_CTM.c;
       pCTM[2] = m_pCurStates->m_CTM.b;
       pCTM[3] = m_pCurStates->m_CTM.d;
     }
     pText->SetSegments(pStrs, pKerning, nsegs);
     pText->m_PosX = m_pCurStates->m_TextX;
     pText->m_PosY = m_pCurStates->m_TextY + m_pCurStates->m_TextRise;
     ConvertTextSpace(pText->m_PosX, pText->m_PosY);
     FX_FLOAT x_advance;
@@ skipping 88 matching lines @@
   m_pCurStates->m_TextLineX = 0;
   m_pCurStates->m_TextLineY = 0;
 }
 
 void CPDF_StreamContentParser::OnChangeTextMatrix() {
   CFX_Matrix text_matrix(m_pCurStates->m_TextHorzScale, 0.0f, 0.0f, 1.0f, 0.0f,
                          0.0f);
   text_matrix.Concat(m_pCurStates->m_TextMatrix);
   text_matrix.Concat(m_pCurStates->m_CTM);
   text_matrix.Concat(m_mtContentToUser);
-  m_pCurStates->m_TextState.MakePrivateCopy();
-  FX_FLOAT* pTextMatrix = m_pCurStates->m_TextState->m_Matrix;
+  FX_FLOAT* pTextMatrix = m_pCurStates->m_TextState.GetPrivateCopy()->m_Matrix;
   pTextMatrix[0] = text_matrix.a;
   pTextMatrix[1] = text_matrix.c;
   pTextMatrix[2] = text_matrix.b;
   pTextMatrix[3] = text_matrix.d;
 }
 
 void CPDF_StreamContentParser::Handle_SetTextRenderMode() {
-  m_pCurStates->m_TextState.MakePrivateCopy();
-  SetTextRenderingModeFromInt(GetInteger(0),
-                              &m_pCurStates->m_TextState->m_TextMode);
+  int mode = GetInteger(0);
+  SetTextRenderingModeFromInt(
+      mode, &m_pCurStates->m_TextState.GetPrivateCopy()->m_TextMode);
 }
 
 void CPDF_StreamContentParser::Handle_SetTextRise() {
   m_pCurStates->m_TextRise = GetNumber(0);
 }
 
 void CPDF_StreamContentParser::Handle_SetWordSpace() {
-  m_pCurStates->m_TextState.MakePrivateCopy();
-  m_pCurStates->m_TextState->m_WordSpace = GetNumber(0);
+  m_pCurStates->m_TextState.GetPrivateCopy()->m_WordSpace = GetNumber(0);
 }
 
 void CPDF_StreamContentParser::Handle_SetHorzScale() {
-  if (m_ParamCount != 1)
+  if (m_ParamCount != 1) {
     return;
-
+  }
   m_pCurStates->m_TextHorzScale = GetNumber(0) / 100;
   OnChangeTextMatrix();
 }
 
 void CPDF_StreamContentParser::Handle_MoveToNextLine() {
   m_pCurStates->m_TextLineY -= m_pCurStates->m_TextLeading;
   m_pCurStates->m_TextX = m_pCurStates->m_TextLineX;
   m_pCurStates->m_TextY = m_pCurStates->m_TextLineY;
 }
 
 void CPDF_StreamContentParser::Handle_CurveTo_23() {
   AddPathPoint(m_PathCurrentX, m_PathCurrentY, FXPT_BEZIERTO);
   AddPathPoint(GetNumber(3), GetNumber(2), FXPT_BEZIERTO);
   AddPathPoint(GetNumber(1), GetNumber(0), FXPT_BEZIERTO);
 }
 
 void CPDF_StreamContentParser::Handle_SetLineWidth() {
-  m_pCurStates->m_GraphState.MakePrivateCopy();
-  m_pCurStates->m_GraphState->m_LineWidth = GetNumber(0);
+  FX_FLOAT width = GetNumber(0);
+  m_pCurStates->m_GraphState.GetPrivateCopy()->m_LineWidth = width;
 }
 
 void CPDF_StreamContentParser::Handle_Clip() {
   m_PathClipType = FXFILL_WINDING;
 }
 
 void CPDF_StreamContentParser::Handle_EOClip() {
   m_PathClipType = FXFILL_ALTERNATE;
 }
 
 void CPDF_StreamContentParser::Handle_CurveTo_13() {
   AddPathPoint(GetNumber(3), GetNumber(2), FXPT_BEZIERTO);
   AddPathPoint(GetNumber(1), GetNumber(0), FXPT_BEZIERTO);
   AddPathPoint(GetNumber(1), GetNumber(0), FXPT_BEZIERTO);
 }
 
 void CPDF_StreamContentParser::Handle_NextLineShowText() {
   Handle_MoveToNextLine();
   Handle_ShowText();
 }
 
 void CPDF_StreamContentParser::Handle_NextLineShowText_Space() {
-  m_pCurStates->m_TextState.MakePrivateCopy();
-  m_pCurStates->m_TextState->m_WordSpace = GetNumber(2);
-  m_pCurStates->m_TextState->m_CharSpace = GetNumber(1);
+  m_pCurStates->m_TextState.GetPrivateCopy()->m_WordSpace = GetNumber(2);
+  m_pCurStates->m_TextState.GetPrivateCopy()->m_CharSpace = GetNumber(1);
   Handle_NextLineShowText();
 }
 
 void CPDF_StreamContentParser::Handle_Invalid() {}
 
 void CPDF_StreamContentParser::AddPathPoint(FX_FLOAT x, FX_FLOAT y, int flag) {
   m_PathCurrentX = x;
   m_PathCurrentY = y;
   if (flag == FXPT_MOVETO) {
     m_PathStartX = x;
@@ skipping 246 matching lines @@
         } else {
           PDF_ReplaceAbbr(pElement);
         }
       }
       break;
     }
     default:
       break;
   }
 }