Clean up CPDF_Page.

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 <vector>
 
@@ skipping 110 matching lines @@
 }
 
 CPDF_StreamContentParser::CPDF_StreamContentParser(
     CPDF_Document* pDocument,
     CPDF_Dictionary* pPageResources,
     CPDF_Dictionary* pParentResources,
     CFX_Matrix* pmtContentToUser,
     CPDF_PageObjectHolder* pObjHolder,
     CPDF_Dictionary* pResources,
     CFX_FloatRect* pBBox,
-    CPDF_ParseOptions* pOptions,
     CPDF_AllStates* pStates,
     int level)
     : m_pDocument(pDocument),
       m_pPageResources(pPageResources),
       m_pParentResources(pParentResources),
       m_pResources(pResources),
       m_pObjectHolder(pObjHolder),
       m_Level(level),
       m_ParamStartPos(0),
       m_ParamCount(0),
       m_pCurStates(new CPDF_AllStates),
       m_pLastTextObject(nullptr),
       m_DefFontSize(0),
       m_pPathPoints(nullptr),
       m_PathPointCount(0),
       m_PathAllocSize(0),
       m_PathCurrentX(0.0f),
       m_PathCurrentY(0.0f),
       m_PathClipType(0),
       m_pLastImage(nullptr),
       m_pLastImageDict(nullptr),
       m_pLastCloneImageDict(nullptr),
       m_bReleaseLastDict(TRUE),
       m_bColored(FALSE),
       m_bResourceMissing(FALSE) {
-  if (pmtContentToUser) {
+  if (pmtContentToUser)
     m_mtContentToUser = *pmtContentToUser;
-  }
-  if (pOptions) {
-    m_Options = *pOptions;
-  }
-  if (!m_pResources) {
+  if (!m_pResources)
     m_pResources = m_pParentResources;
-  }
-  if (!m_pResources) {
+  if (!m_pResources)
     m_pResources = m_pPageResources;
-  }
-  if (pBBox) {
+  if (pBBox)
     m_BBox = *pBBox;
-  }
   if (pStates) {
     m_pCurStates->Copy(*pStates);
   } else {
     m_pCurStates->m_GeneralState.New();
     m_pCurStates->m_GraphState.New();
     m_pCurStates->m_TextState.New();
     m_pCurStates->m_ColorState.New();
   }
   for (size_t i = 0; i < FX_ArraySize(m_Type3Data); ++i) {
     m_Type3Data[i] = 0.0;
@@ skipping 303 matching lines @@
   }
 
   static const OpCodes s_OpCodes = InitializeOpCodes();
 
   auto it = s_OpCodes.find(opid);
   if (it != s_OpCodes.end())
     (this->*it->second)();
 }
 
 void CPDF_StreamContentParser::Handle_CloseFillStrokePath() {
-  if (m_Options.m_bTextOnly) {
-    return;
-  }
   Handle_ClosePath();
   AddPathObject(FXFILL_WINDING, TRUE);
 }
 
 void CPDF_StreamContentParser::Handle_FillStrokePath() {
-  if (m_Options.m_bTextOnly) {
-    return;
-  }
   AddPathObject(FXFILL_WINDING, TRUE);
 }
 
 void CPDF_StreamContentParser::Handle_CloseEOFillStrokePath() {
-  if (m_Options.m_bTextOnly) {
-    return;
-  }
   AddPathPoint(m_PathStartX, m_PathStartY, FXPT_LINETO | FXPT_CLOSEFIGURE);
   AddPathObject(FXFILL_ALTERNATE, TRUE);
 }
 
 void CPDF_StreamContentParser::Handle_EOFillStrokePath() {
-  if (m_Options.m_bTextOnly) {
-    return;
-  }
   AddPathObject(FXFILL_ALTERNATE, TRUE);
 }
 
 void CPDF_StreamContentParser::Handle_BeginMarkedContent_Dictionary() {
-  if (!m_Options.m_bMarkedContent) {
-    return;
-  }
   CFX_ByteString tag = GetString(1);
   CPDF_Object* pProperty = GetObject(0);
   if (!pProperty) {
     return;
   }
   FX_BOOL bDirect = TRUE;
   if (pProperty->IsName()) {
     pProperty = FindResourceObj("Properties", pProperty->GetString());
     if (!pProperty)
       return;
@@ skipping 41 matching lines @@
       CFX_ByteString name = pCSObj->GetString();
       if (name != "DeviceRGB" && name != "DeviceGray" && name != "DeviceCMYK") {
         pCSObj = FindResourceObj("ColorSpace", name);
         if (pCSObj && !pCSObj->GetObjNum()) {
           pCSObj = pCSObj->Clone();
           pDict->SetAt("ColorSpace", pCSObj);
         }
       }
     }
   }
-  CPDF_Stream* pStream = m_pSyntax->ReadInlineStream(
-      m_pDocument, pDict, pCSObj, m_Options.m_bDecodeInlineImage);
+  CPDF_Stream* pStream =
+      m_pSyntax->ReadInlineStream(m_pDocument, pDict, pCSObj);
   while (1) {
     CPDF_StreamParser::SyntaxType type = m_pSyntax->ParseNextElement();
     if (type == CPDF_StreamParser::EndOfData) {
       break;
     }
     if (type != CPDF_StreamParser::Keyword) {
       continue;
     }
     if (m_pSyntax->GetWordSize() == 2 && m_pSyntax->GetWordBuf()[0] == 'E' &&
         m_pSyntax->GetWordBuf()[1] == 'I') {
       break;
     }
   }
-  if (m_Options.m_bTextOnly) {
-    if (pStream) {
-      pStream->Release();
-    } else {
-      pDict->Release();
-    }
-    return;
-  }
   pDict->SetAtName("Subtype", "Image");
   CPDF_ImageObject* pImgObj = AddImage(pStream, NULL, TRUE);
   if (!pImgObj) {
     if (pStream) {
       pStream->Release();
     } else {
       pDict->Release();
     }
   }
 }
 
 void CPDF_StreamContentParser::Handle_BeginMarkedContent() {
-  if (!m_Options.m_bMarkedContent) {
-    return;
-  }
   CFX_ByteString tag = GetString(0);
   m_CurContentMark.GetModify()->AddMark(tag, NULL, 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() {
-  if (m_Options.m_bTextOnly) {
-    return;
-  }
   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() {
   FX_FLOAT a2 = GetNumber16(5), b2 = GetNumber16(4), c2 = GetNumber16(3),
            d2 = GetNumber16(2);
   FX_FLOAT e2 = GetNumber(1), f2 = GetNumber(0);
   CFX_Matrix new_matrix(a2, b2, c2, d2, e2, f2);
   new_matrix.Concat(m_pCurStates->m_CTM);
   m_pCurStates->m_CTM = new_matrix;
   OnChangeTextMatrix();
 }
 
 void CPDF_StreamContentParser::Handle_SetColorSpace_Fill() {
-  if (m_Options.m_bTextOnly) {
-    return;
-  }
   CFX_ByteString csname = GetString(0);
   CPDF_ColorSpace* pCS = FindColorSpace(csname);
   if (!pCS) {
     return;
   }
   m_pCurStates->m_ColorState.GetModify()->m_FillColor.SetColorSpace(pCS);
 }
 
 void CPDF_StreamContentParser::Handle_SetColorSpace_Stroke() {
-  if (m_Options.m_bTextOnly) {
-    return;
-  }
   CFX_ByteString csname = GetString(0);
   CPDF_ColorSpace* pCS = FindColorSpace(csname);
   if (!pCS) {
     return;
   }
   m_pCurStates->m_ColorState.GetModify()->m_StrokeColor.SetColorSpace(pCS);
 }
 
 void CPDF_StreamContentParser::Handle_SetDash() {
-  if (m_Options.m_bTextOnly) {
+  CPDF_Array* pArray = GetObject(1) ? GetObject(1)->GetArray() : nullptr;
+  if (!pArray)
     return;
-  }
-  CPDF_Array* pArray = GetObject(1) ? GetObject(1)->GetArray() : NULL;
-  if (!pArray) {
-    return;
-  }
+
   m_pCurStates->SetLineDash(pArray, GetNumber(0), 1.0f);
 }
 
 void CPDF_StreamContentParser::Handle_SetCharWidth() {
   m_Type3Data[0] = GetNumber(1);
   m_Type3Data[1] = GetNumber(0);
   m_bColored = TRUE;
 }
 
 void CPDF_StreamContentParser::Handle_SetCachedDevice() {
   for (int i = 0; i < 6; i++) {
     m_Type3Data[i] = GetNumber(5 - i);
   }
   m_bColored = FALSE;
 }
 
 void CPDF_StreamContentParser::Handle_ExecuteXObject() {
   CFX_ByteString name = GetString(0);
   if (name == m_LastImageName && m_pLastImage && m_pLastImage->GetStream() &&
       m_pLastImage->GetStream()->GetObjNum()) {
     AddImage(nullptr, m_pLastImage, FALSE);
     return;
   }
 
-  if (m_Options.m_bTextOnly) {
-    if (!m_pResources)
-      return;
-
-    CPDF_Dictionary* pList = m_pResources->GetDictBy("XObject");
-    if (!pList && m_pPageResources && m_pResources != m_pPageResources)
-      pList = m_pPageResources->GetDictBy("XObject");
-    if (!pList)
-      return;
-    CPDF_Reference* pRes = ToReference(pList->GetObjectBy(name));
-    if (!pRes)
-      return;
-
-    FX_BOOL bForm;
-    if (m_pDocument->IsFormStream(pRes->GetRefObjNum(), bForm) && !bForm)
-      return;
-  }
-
   CPDF_Stream* pXObject = ToStream(FindResourceObj("XObject", name));
   if (!pXObject) {
     m_bResourceMissing = TRUE;
     return;
   }
 
   CFX_ByteString type;
   if (pXObject->GetDict())
     type = pXObject->GetDict()->GetStringBy("Subtype");
 
   if (type == "Image") {
-    if (m_Options.m_bTextOnly) {
-      return;
-    }
     CPDF_ImageObject* pObj = AddImage(pXObject, NULL, FALSE);
     m_LastImageName = name;
     m_pLastImage = pObj->m_pImage;
     if (!m_pObjectHolder->HasImageMask())
       m_pObjectHolder->SetHasImageMask(m_pLastImage->IsMask());
   } else if (type == "Form") {
     AddForm(pXObject);
-  } else {
-    return;
   }
 }
 
 void CPDF_StreamContentParser::AddForm(CPDF_Stream* pStream) {
-  if (!m_Options.m_bSeparateForm) {
-    CPDF_Dictionary* pResources = pStream->GetDict()->GetDictBy("Resources");
-    CFX_Matrix form_matrix = pStream->GetDict()->GetMatrixBy("Matrix");
-    form_matrix.Concat(m_pCurStates->m_CTM);
-    CPDF_Array* pBBox = pStream->GetDict()->GetArrayBy("BBox");
-    CFX_FloatRect form_bbox;
-    CPDF_Path ClipPath;
-    if (pBBox) {
-      form_bbox = pStream->GetDict()->GetRectBy("BBox");
-      ClipPath.New();
-      ClipPath.AppendRect(form_bbox.left, form_bbox.bottom, form_bbox.right,
-                          form_bbox.top);
-      ClipPath.Transform(&form_matrix);
-      form_bbox.Transform(&form_matrix);
-    }
-    CPDF_StreamContentParser parser(m_pDocument, m_pPageResources, m_pResources,
-                                    &m_mtContentToUser, m_pObjectHolder,
-                                    pResources, &form_bbox, &m_Options,
-                                    m_pCurStates.get(), m_Level + 1);
-    parser.m_pCurStates->m_CTM = form_matrix;
-    if (ClipPath.NotNull()) {
-      parser.m_pCurStates->m_ClipPath.AppendPath(ClipPath, FXFILL_WINDING,
-                                                 TRUE);
-    }
-    CPDF_StreamAcc stream;
-    stream.LoadAllData(pStream, FALSE);
-    if (stream.GetSize() == 0) {
-      return;
-    }
-    parser.Parse(stream.GetData(), stream.GetSize(), 0);
-    return;
-  }
   std::unique_ptr<CPDF_FormObject> pFormObj(new CPDF_FormObject);
   pFormObj->m_pForm =
       new CPDF_Form(m_pDocument, m_pPageResources, pStream, m_pResources);
   pFormObj->m_FormMatrix = m_pCurStates->m_CTM;
   pFormObj->m_FormMatrix.Concat(m_mtContentToUser);
   CPDF_AllStates status;
   status.m_GeneralState = m_pCurStates->m_GeneralState;
   status.m_GraphState = m_pCurStates->m_GraphState;
   status.m_ColorState = m_pCurStates->m_ColorState;
   status.m_TextState = m_pCurStates->m_TextState;
-  pFormObj->m_pForm->ParseContent(&status, NULL, NULL, &m_Options, m_Level + 1);
+  pFormObj->m_pForm->ParseContent(&status, nullptr, nullptr, m_Level + 1);
   if (!m_pObjectHolder->BackgroundAlphaNeeded() &&
       pFormObj->m_pForm->BackgroundAlphaNeeded()) {
     m_pObjectHolder->SetBackgroundAlphaNeeded(TRUE);
   }
   pFormObj->CalcBoundingBox();
   SetGraphicStates(pFormObj.get(), TRUE, TRUE, TRUE);
   m_pObjectHolder->GetPageObjectList()->push_back(std::move(pFormObj));
 }
 
 CPDF_ImageObject* CPDF_StreamContentParser::AddImage(CPDF_Stream* pStream,
@@ skipping 23 matching lines @@
   CPDF_ImageObject* pRet = pImageObj.get();
   m_pObjectHolder->GetPageObjectList()->push_back(std::move(pImageObj));
   return pRet;
 }
 
 void CPDF_StreamContentParser::Handle_MarkPlace_Dictionary() {}
 
 void CPDF_StreamContentParser::Handle_EndImage() {}
 
 void CPDF_StreamContentParser::Handle_EndMarkedContent() {
-  if (!m_Options.m_bMarkedContent) {
+  if (m_CurContentMark.IsNull())
     return;
-  }
-  if (m_CurContentMark.IsNull()) {
-    return;
-  }
+
   int count = m_CurContentMark.GetObject()->CountItems();
   if (count == 1) {
     m_CurContentMark.SetNull();
     return;
   }
   m_CurContentMark.GetModify()->DeleteLastMark();
 }
 
 void CPDF_StreamContentParser::Handle_EndText() {
   int count = m_ClipTextList.GetSize();
   if (count == 0) {
     return;
   }
   if (m_pCurStates->m_TextState.GetObject()->m_TextMode < 4) {
     for (int i = 0; i < count; i++) {
       delete m_ClipTextList.GetAt(i);
     }
   } else {
     m_pCurStates->m_ClipPath.AppendTexts(m_ClipTextList.GetData(), count);
   }
   m_ClipTextList.RemoveAll();
 }
 
 void CPDF_StreamContentParser::Handle_FillPath() {
-  if (m_Options.m_bTextOnly) {
-    return;
-  }
   AddPathObject(FXFILL_WINDING, FALSE);
 }
 
 void CPDF_StreamContentParser::Handle_FillPathOld() {
-  if (m_Options.m_bTextOnly) {
-    return;
-  }
   AddPathObject(FXFILL_WINDING, FALSE);
 }
 
 void CPDF_StreamContentParser::Handle_EOFillPath() {
-  if (m_Options.m_bTextOnly) {
-    return;
-  }
   AddPathObject(FXFILL_ALTERNATE, FALSE);
 }
 
 void CPDF_StreamContentParser::Handle_SetGray_Fill() {
   FX_FLOAT value = GetNumber(0);
   CPDF_ColorSpace* pCS = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICEGRAY);
   m_pCurStates->m_ColorState.SetFillColor(pCS, &value, 1);
 }
 
 void CPDF_StreamContentParser::Handle_SetGray_Stroke() {
   FX_FLOAT value = GetNumber(0);
   CPDF_ColorSpace* pCS = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICEGRAY);
   m_pCurStates->m_ColorState.SetStrokeColor(pCS, &value, 1);
 }
 
 void CPDF_StreamContentParser::Handle_SetExtendGraphState() {
   CFX_ByteString name = GetString(0);
   CPDF_Dictionary* pGS = ToDictionary(FindResourceObj("ExtGState", name));
   if (!pGS) {
     m_bResourceMissing = TRUE;
     return;
   }
   m_pCurStates->ProcessExtGS(pGS, this);
 }
 
 void CPDF_StreamContentParser::Handle_ClosePath() {
-  if (m_Options.m_bTextOnly) {
-    return;
-  }
   if (m_PathPointCount == 0) {
     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;
   }
 }
 
@@ skipping 34 matching lines @@
     values[i] = GetNumber(3 - i);
   }
   CPDF_ColorSpace* pCS = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICECMYK);
   m_pCurStates->m_ColorState.SetStrokeColor(pCS, values, 4);
 }
 
 void CPDF_StreamContentParser::Handle_LineTo() {
   if (m_ParamCount != 2)
     return;
 
-  if (m_Options.m_bTextOnly) {
-    return;
-  }
   AddPathPoint(GetNumber(1), GetNumber(0), FXPT_LINETO);
 }
 
 void CPDF_StreamContentParser::Handle_MoveTo() {
   if (m_ParamCount != 2)
     return;
 
-  if (m_Options.m_bTextOnly) {
-    m_pSyntax->SkipPathObject();
-    return;
-  }
   AddPathPoint(GetNumber(1), GetNumber(0), FXPT_MOVETO);
   ParsePathObject();
 }
 
 void CPDF_StreamContentParser::Handle_SetMiterLimit() {
   m_pCurStates->m_GraphState.GetModify()->m_MiterLimit = GetNumber(0);
 }
 
 void CPDF_StreamContentParser::Handle_MarkPlace() {}
 
 void CPDF_StreamContentParser::Handle_EndPath() {
-  if (m_Options.m_bTextOnly) {
-    return;
-  }
   AddPathObject(0, FALSE);
 }
 
 void CPDF_StreamContentParser::Handle_SaveGraphState() {
   std::unique_ptr<CPDF_AllStates> pStates(new CPDF_AllStates);
   pStates->Copy(*m_pCurStates);
   m_StateStack.push_back(std::move(pStates));
 }
 
 void CPDF_StreamContentParser::Handle_RestoreGraphState() {
   if (m_StateStack.empty())
     return;
   std::unique_ptr<CPDF_AllStates> pStates = std::move(m_StateStack.back());
   m_StateStack.pop_back();
   m_pCurStates->Copy(*pStates);
 }
 
 void CPDF_StreamContentParser::Handle_Rectangle() {
-  if (m_Options.m_bTextOnly) {
-    return;
-  }
   FX_FLOAT x = GetNumber(3), y = GetNumber(2);
   FX_FLOAT w = GetNumber(1), h = GetNumber(0);
   AddPathRect(x, y, w, h);
 }
 
 void CPDF_StreamContentParser::AddPathRect(FX_FLOAT x,
                                            FX_FLOAT y,
                                            FX_FLOAT w,
                                            FX_FLOAT h) {
   AddPathPoint(x, y, FXPT_MOVETO);
@@ skipping 23 matching lines @@
   for (int i = 0; i < 3; i++) {
     values[i] = GetNumber(2 - i);
   }
   CPDF_ColorSpace* pCS = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICERGB);
   m_pCurStates->m_ColorState.SetStrokeColor(pCS, values, 3);
 }
 
 void CPDF_StreamContentParser::Handle_SetRenderIntent() {}
 
 void CPDF_StreamContentParser::Handle_CloseStrokePath() {
-  if (m_Options.m_bTextOnly) {
-    return;
-  }
   Handle_ClosePath();
   AddPathObject(0, TRUE);
 }
 
 void CPDF_StreamContentParser::Handle_StrokePath() {
-  if (m_Options.m_bTextOnly) {
-    return;
-  }
   AddPathObject(0, TRUE);
 }
 
 void CPDF_StreamContentParser::Handle_SetColor_Fill() {
-  if (m_Options.m_bTextOnly) {
-    return;
-  }
   FX_FLOAT values[4];
   int nargs = m_ParamCount;
   if (nargs > 4) {
     nargs = 4;
   }
   for (int i = 0; i < nargs; i++) {
     values[i] = GetNumber(nargs - i - 1);
   }
   m_pCurStates->m_ColorState.SetFillColor(NULL, values, nargs);
 }
 
 void CPDF_StreamContentParser::Handle_SetColor_Stroke() {
-  if (m_Options.m_bTextOnly) {
-    return;
-  }
   FX_FLOAT values[4];
   int nargs = m_ParamCount;
   if (nargs > 4) {
     nargs = 4;
   }
   for (int i = 0; i < nargs; i++) {
     values[i] = GetNumber(nargs - i - 1);
   }
   m_pCurStates->m_ColorState.SetStrokeColor(NULL, values, nargs);
 }
 
 void CPDF_StreamContentParser::Handle_SetColorPS_Fill() {
-  if (m_Options.m_bTextOnly) {
-    return;
-  }
   CPDF_Object* pLastParam = GetObject(0);
   if (!pLastParam) {
     return;
   }
   uint32_t nargs = m_ParamCount;
   uint32_t nvalues = nargs;
   if (pLastParam->IsName())
     nvalues--;
   FX_FLOAT* values = NULL;
   if (nvalues) {
     values = FX_Alloc(FX_FLOAT, nvalues);
     for (uint32_t i = 0; i < nvalues; i++) {
       values[i] = GetNumber(nargs - i - 1);
     }
   }
   if (nvalues != nargs) {
     CPDF_Pattern* pPattern = FindPattern(GetString(0), FALSE);
     if (pPattern) {
       m_pCurStates->m_ColorState.SetFillPattern(pPattern, values, nvalues);
     }
   } else {
     m_pCurStates->m_ColorState.SetFillColor(NULL, values, nvalues);
   }
   FX_Free(values);
 }
 
 void CPDF_StreamContentParser::Handle_SetColorPS_Stroke() {
-  if (m_Options.m_bTextOnly) {
-    return;
-  }
   CPDF_Object* pLastParam = GetObject(0);
   if (!pLastParam) {
     return;
   }
   int nargs = m_ParamCount;
   int nvalues = nargs;
   if (pLastParam->IsName())
     nvalues--;
 
   FX_FLOAT* values = NULL;
@@ skipping 15 matching lines @@
 }
 
 CFX_FloatRect GetShadingBBox(CPDF_Stream* pStream,
                              ShadingType type,
                              const CFX_Matrix* pMatrix,
                              CPDF_Function** pFuncs,
                              int nFuncs,
                              CPDF_ColorSpace* pCS);
 
 void CPDF_StreamContentParser::Handle_ShadeFill() {
-  if (m_Options.m_bTextOnly) {
+  CPDF_Pattern* pPattern = FindPattern(GetString(0), TRUE);
+  if (!pPattern)
     return;
-  }
-  CPDF_Pattern* pPattern = FindPattern(GetString(0), TRUE);
-  if (!pPattern) {
+
+  CPDF_ShadingPattern* pShading = pPattern->AsShadingPattern();
+  if (!pShading)
     return;
-  }
-  if (pPattern->m_PatternType != CPDF_Pattern::SHADING) {
+
+  if (!pShading->m_bShadingObj || !pShading->Load())
     return;
-  }
-  CPDF_ShadingPattern* pShading = static_cast<CPDF_ShadingPattern*>(pPattern);
-  if (!pShading->m_bShadingObj) {
-    return;
-  }
-  if (!pShading->Load()) {
-    return;
-  }
+
   std::unique_ptr<CPDF_ShadingObject> pObj(new CPDF_ShadingObject);
   pObj->m_pShading = pShading;
   SetGraphicStates(pObj.get(), FALSE, FALSE, FALSE);
   pObj->m_Matrix = m_pCurStates->m_CTM;
   pObj->m_Matrix.Concat(m_mtContentToUser);
-  CFX_FloatRect bbox;
-  if (!pObj->m_ClipPath.IsNull()) {
-    bbox = pObj->m_ClipPath.GetClipBox();
-  } else {
-    bbox = m_BBox;
-  }
+  CFX_FloatRect bbox =
+      pObj->m_ClipPath.IsNull() ? m_BBox : pObj->m_ClipPath.GetClipBox();
   if (pShading->IsMeshShading()) {
     bbox.Intersect(GetShadingBBox(ToStream(pShading->m_pShadingObj),
                                   pShading->m_ShadingType, &pObj->m_Matrix,
                                   pShading->m_pFunctions, pShading->m_nFuncs,
                                   pShading->m_pCS));
   }
   pObj->m_Left = bbox.left;
   pObj->m_Right = bbox.right;
   pObj->m_Top = bbox.top;
   pObj->m_Bottom = bbox.bottom;
@@ skipping 292 matching lines @@
   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() {
-  if (m_Options.m_bTextOnly) {
-    return;
-  }
   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() {
   FX_FLOAT width = GetNumber(0);
   m_pCurStates->m_GraphState.GetModify()->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() {
-  if (m_Options.m_bTextOnly) {
-    return;
-  }
   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();
 }
 
@@ skipping 259 matching lines @@
         } else {
           PDF_ReplaceAbbr(pElement);
         }
       }
       break;
     }
     default:
       break;
   }
 }