1 // Copyright 2016 PDFium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
6 
7 #include "core/fpdfapi/page/cpdf_streamcontentparser.h"
8 
9 #include <algorithm>
10 #include <memory>
11 #include <utility>
12 #include <vector>
13 
14 #include "core/fpdfapi/font/cpdf_font.h"
15 #include "core/fpdfapi/font/cpdf_type3font.h"
16 #include "core/fpdfapi/page/cpdf_allstates.h"
17 #include "core/fpdfapi/page/cpdf_docpagedata.h"
18 #include "core/fpdfapi/page/cpdf_form.h"
19 #include "core/fpdfapi/page/cpdf_formobject.h"
20 #include "core/fpdfapi/page/cpdf_image.h"
21 #include "core/fpdfapi/page/cpdf_imageobject.h"
22 #include "core/fpdfapi/page/cpdf_meshstream.h"
23 #include "core/fpdfapi/page/cpdf_pageobject.h"
24 #include "core/fpdfapi/page/cpdf_pathobject.h"
25 #include "core/fpdfapi/page/cpdf_shadingobject.h"
26 #include "core/fpdfapi/page/cpdf_shadingpattern.h"
27 #include "core/fpdfapi/page/cpdf_streamparser.h"
28 #include "core/fpdfapi/page/cpdf_textobject.h"
29 #include "core/fpdfapi/parser/cpdf_array.h"
30 #include "core/fpdfapi/parser/cpdf_dictionary.h"
31 #include "core/fpdfapi/parser/cpdf_document.h"
32 #include "core/fpdfapi/parser/cpdf_name.h"
33 #include "core/fpdfapi/parser/cpdf_number.h"
34 #include "core/fpdfapi/parser/cpdf_reference.h"
35 #include "core/fpdfapi/parser/cpdf_stream.h"
36 #include "core/fpdfapi/parser/fpdf_parser_utility.h"
37 #include "core/fxcrt/autonuller.h"
38 #include "core/fxcrt/fx_safe_types.h"
39 #include "core/fxge/cfx_graphstatedata.h"
40 #include "third_party/base/notreached.h"
41 #include "third_party/base/span.h"
42 #include "third_party/base/stl_util.h"
43 
44 namespace {
45 
46 const int kMaxFormLevel = 40;
47 
48 const int kSingleCoordinatePair = 1;
49 const int kTensorCoordinatePairs = 16;
50 const int kCoonsCoordinatePairs = 12;
51 const int kSingleColorPerPatch = 1;
52 const int kQuadColorsPerPatch = 4;
53 
54 const char kPathOperatorSubpath = 'm';
55 const char kPathOperatorLine = 'l';
56 const char kPathOperatorCubicBezier1 = 'c';
57 const char kPathOperatorCubicBezier2 = 'v';
58 const char kPathOperatorCubicBezier3 = 'y';
59 const char kPathOperatorClosePath = 'h';
60 const char kPathOperatorRectangle[] = "re";
61 
GetShadingBBox(CPDF_ShadingPattern * pShading,const CFX_Matrix & matrix)62 CFX_FloatRect GetShadingBBox(CPDF_ShadingPattern* pShading,
63                              const CFX_Matrix& matrix) {
64   ShadingType type = pShading->GetShadingType();
65   const CPDF_Stream* pStream = ToStream(pShading->GetShadingObject());
66   RetainPtr<CPDF_ColorSpace> pCS = pShading->GetCS();
67   if (!pStream || !pCS)
68     return CFX_FloatRect();
69 
70   CPDF_MeshStream stream(type, pShading->GetFuncs(), pStream, pCS);
71   if (!stream.Load())
72     return CFX_FloatRect();
73 
74   CFX_FloatRect rect;
75   bool bStarted = false;
76   bool bGouraud = type == kFreeFormGouraudTriangleMeshShading ||
77                   type == kLatticeFormGouraudTriangleMeshShading;
78 
79   int point_count = kSingleCoordinatePair;
80   if (type == kTensorProductPatchMeshShading)
81     point_count = kTensorCoordinatePairs;
82   else if (type == kCoonsPatchMeshShading)
83     point_count = kCoonsCoordinatePairs;
84 
85   int color_count = kSingleColorPerPatch;
86   if (type == kCoonsPatchMeshShading || type == kTensorProductPatchMeshShading)
87     color_count = kQuadColorsPerPatch;
88 
89   while (!stream.BitStream()->IsEOF()) {
90     uint32_t flag = 0;
91     if (type != kLatticeFormGouraudTriangleMeshShading) {
92       if (!stream.CanReadFlag())
93         break;
94       flag = stream.ReadFlag();
95     }
96 
97     if (!bGouraud && flag) {
98       point_count -= 4;
99       color_count -= 2;
100     }
101 
102     for (int i = 0; i < point_count; i++) {
103       if (!stream.CanReadCoords())
104         break;
105       CFX_PointF origin = stream.ReadCoords();
106       if (bStarted) {
107         rect.UpdateRect(origin);
108       } else {
109         rect.InitRect(origin);
110         bStarted = true;
111       }
112     }
113     FX_SAFE_UINT32 nBits = stream.Components();
114     nBits *= stream.ComponentBits();
115     nBits *= color_count;
116     if (!nBits.IsValid())
117       break;
118 
119     stream.BitStream()->SkipBits(nBits.ValueOrDie());
120     if (bGouraud)
121       stream.BitStream()->ByteAlign();
122   }
123   return matrix.TransformRect(rect);
124 }
125 
126 struct AbbrPair {
127   const char* abbr;
128   const char* full_name;
129 };
130 
131 const AbbrPair kInlineKeyAbbr[] = {
132     {"BPC", "BitsPerComponent"}, {"CS", "ColorSpace"}, {"D", "Decode"},
133     {"DP", "DecodeParms"},       {"F", "Filter"},      {"H", "Height"},
134     {"IM", "ImageMask"},         {"I", "Interpolate"}, {"W", "Width"},
135 };
136 
137 const AbbrPair kInlineValueAbbr[] = {
138     {"G", "DeviceGray"},       {"RGB", "DeviceRGB"},
139     {"CMYK", "DeviceCMYK"},    {"I", "Indexed"},
140     {"AHx", "ASCIIHexDecode"}, {"A85", "ASCII85Decode"},
141     {"LZW", "LZWDecode"},      {"Fl", "FlateDecode"},
142     {"RL", "RunLengthDecode"}, {"CCF", "CCITTFaxDecode"},
143     {"DCT", "DCTDecode"},
144 };
145 
146 struct AbbrReplacementOp {
147   bool is_replace_key;
148   ByteString key;
149   ByteStringView replacement;
150 };
151 
FindFullName(const AbbrPair * table,size_t count,ByteStringView abbr)152 ByteStringView FindFullName(const AbbrPair* table,
153                             size_t count,
154                             ByteStringView abbr) {
155   auto* it = std::find_if(table, table + count, [abbr](const AbbrPair& pair) {
156     return pair.abbr == abbr;
157   });
158   return it != table + count ? ByteStringView(it->full_name) : ByteStringView();
159 }
160 
161 void ReplaceAbbr(CPDF_Object* pObj);
162 
ReplaceAbbrInDictionary(CPDF_Dictionary * pDict)163 void ReplaceAbbrInDictionary(CPDF_Dictionary* pDict) {
164   std::vector<AbbrReplacementOp> replacements;
165   {
166     CPDF_DictionaryLocker locker(pDict);
167     for (const auto& it : locker) {
168       ByteString key = it.first;
169       CPDF_Object* value = it.second.Get();
170       ByteStringView fullname = FindFullName(
171           kInlineKeyAbbr, pdfium::size(kInlineKeyAbbr), key.AsStringView());
172       if (!fullname.IsEmpty()) {
173         AbbrReplacementOp op;
174         op.is_replace_key = true;
175         op.key = std::move(key);
176         op.replacement = fullname;
177         replacements.push_back(op);
178         key = fullname;
179       }
180 
181       if (value->IsName()) {
182         ByteString name = value->GetString();
183         fullname =
184             FindFullName(kInlineValueAbbr, pdfium::size(kInlineValueAbbr),
185                          name.AsStringView());
186         if (!fullname.IsEmpty()) {
187           AbbrReplacementOp op;
188           op.is_replace_key = false;
189           op.key = key;
190           op.replacement = fullname;
191           replacements.push_back(op);
192         }
193       } else {
194         ReplaceAbbr(value);
195       }
196     }
197   }
198   for (const auto& op : replacements) {
199     if (op.is_replace_key)
200       pDict->ReplaceKey(op.key, ByteString(op.replacement));
201     else
202       pDict->SetNewFor<CPDF_Name>(op.key, ByteString(op.replacement));
203   }
204 }
205 
ReplaceAbbrInArray(CPDF_Array * pArray)206 void ReplaceAbbrInArray(CPDF_Array* pArray) {
207   for (size_t i = 0; i < pArray->size(); ++i) {
208     CPDF_Object* pElement = pArray->GetObjectAt(i);
209     if (pElement->IsName()) {
210       ByteString name = pElement->GetString();
211       ByteStringView fullname =
212           FindFullName(kInlineValueAbbr, pdfium::size(kInlineValueAbbr),
213                        name.AsStringView());
214       if (!fullname.IsEmpty())
215         pArray->SetNewAt<CPDF_Name>(i, ByteString(fullname));
216     } else {
217       ReplaceAbbr(pElement);
218     }
219   }
220 }
221 
ReplaceAbbr(CPDF_Object * pObj)222 void ReplaceAbbr(CPDF_Object* pObj) {
223   CPDF_Dictionary* pDict = pObj->AsDictionary();
224   if (pDict) {
225     ReplaceAbbrInDictionary(pDict);
226     return;
227   }
228 
229   CPDF_Array* pArray = pObj->AsArray();
230   if (pArray)
231     ReplaceAbbrInArray(pArray);
232 }
233 
234 }  // namespace
235 
CPDF_StreamContentParser(CPDF_Document * pDocument,CPDF_Dictionary * pPageResources,CPDF_Dictionary * pParentResources,const CFX_Matrix * pmtContentToUser,CPDF_PageObjectHolder * pObjHolder,CPDF_Dictionary * pResources,const CFX_FloatRect & rcBBox,const CPDF_AllStates * pStates,std::set<const uint8_t * > * pParsedSet)236 CPDF_StreamContentParser::CPDF_StreamContentParser(
237     CPDF_Document* pDocument,
238     CPDF_Dictionary* pPageResources,
239     CPDF_Dictionary* pParentResources,
240     const CFX_Matrix* pmtContentToUser,
241     CPDF_PageObjectHolder* pObjHolder,
242     CPDF_Dictionary* pResources,
243     const CFX_FloatRect& rcBBox,
244     const CPDF_AllStates* pStates,
245     std::set<const uint8_t*>* pParsedSet)
246     : m_pDocument(pDocument),
247       m_pPageResources(pPageResources),
248       m_pParentResources(pParentResources),
249       m_pResources(CPDF_Form::ChooseResourcesDict(pResources,
250                                                   pParentResources,
251                                                   pPageResources)),
252       m_pObjectHolder(pObjHolder),
253       m_ParsedSet(pParsedSet),
254       m_BBox(rcBBox),
255       m_pCurStates(std::make_unique<CPDF_AllStates>()) {
256   if (pmtContentToUser)
257     m_mtContentToUser = *pmtContentToUser;
258   if (pStates) {
259     m_pCurStates->Copy(*pStates);
260   } else {
261     m_pCurStates->m_GeneralState.Emplace();
262     m_pCurStates->m_GraphState.Emplace();
263     m_pCurStates->m_TextState.Emplace();
264     m_pCurStates->m_ColorState.Emplace();
265   }
266 
267   // Add the sentinel.
268   m_ContentMarksStack.push(std::make_unique<CPDF_ContentMarks>());
269 }
270 
~CPDF_StreamContentParser()271 CPDF_StreamContentParser::~CPDF_StreamContentParser() {
272   ClearAllParams();
273 }
274 
GetNextParamPos()275 int CPDF_StreamContentParser::GetNextParamPos() {
276   if (m_ParamCount == kParamBufSize) {
277     m_ParamStartPos++;
278     if (m_ParamStartPos == kParamBufSize) {
279       m_ParamStartPos = 0;
280     }
281     if (m_ParamBuf[m_ParamStartPos].m_Type == ContentParam::OBJECT)
282       m_ParamBuf[m_ParamStartPos].m_pObject.Reset();
283 
284     return m_ParamStartPos;
285   }
286   int index = m_ParamStartPos + m_ParamCount;
287   if (index >= kParamBufSize) {
288     index -= kParamBufSize;
289   }
290   m_ParamCount++;
291   return index;
292 }
293 
AddNameParam(ByteStringView bsName)294 void CPDF_StreamContentParser::AddNameParam(ByteStringView bsName) {
295   ContentParam& param = m_ParamBuf[GetNextParamPos()];
296   param.m_Type = ContentParam::NAME;
297   param.m_Name = PDF_NameDecode(bsName);
298 }
299 
AddNumberParam(ByteStringView str)300 void CPDF_StreamContentParser::AddNumberParam(ByteStringView str) {
301   ContentParam& param = m_ParamBuf[GetNextParamPos()];
302   param.m_Type = ContentParam::NUMBER;
303   param.m_Number = FX_Number(str);
304 }
305 
AddObjectParam(RetainPtr<CPDF_Object> pObj)306 void CPDF_StreamContentParser::AddObjectParam(RetainPtr<CPDF_Object> pObj) {
307   ContentParam& param = m_ParamBuf[GetNextParamPos()];
308   param.m_Type = ContentParam::OBJECT;
309   param.m_pObject = std::move(pObj);
310 }
311 
ClearAllParams()312 void CPDF_StreamContentParser::ClearAllParams() {
313   uint32_t index = m_ParamStartPos;
314   for (uint32_t i = 0; i < m_ParamCount; i++) {
315     if (m_ParamBuf[index].m_Type == ContentParam::OBJECT)
316       m_ParamBuf[index].m_pObject.Reset();
317     index++;
318     if (index == kParamBufSize)
319       index = 0;
320   }
321   m_ParamStartPos = 0;
322   m_ParamCount = 0;
323 }
324 
GetObject(uint32_t index)325 CPDF_Object* CPDF_StreamContentParser::GetObject(uint32_t index) {
326   if (index >= m_ParamCount) {
327     return nullptr;
328   }
329   int real_index = m_ParamStartPos + m_ParamCount - index - 1;
330   if (real_index >= kParamBufSize) {
331     real_index -= kParamBufSize;
332   }
333   ContentParam& param = m_ParamBuf[real_index];
334   if (param.m_Type == ContentParam::NUMBER) {
335     param.m_Type = ContentParam::OBJECT;
336     param.m_pObject =
337         param.m_Number.IsInteger()
338             ? pdfium::MakeRetain<CPDF_Number>(param.m_Number.GetSigned())
339             : pdfium::MakeRetain<CPDF_Number>(param.m_Number.GetFloat());
340     return param.m_pObject.Get();
341   }
342   if (param.m_Type == ContentParam::NAME) {
343     param.m_Type = ContentParam::OBJECT;
344     param.m_pObject = m_pDocument->New<CPDF_Name>(param.m_Name);
345     return param.m_pObject.Get();
346   }
347   if (param.m_Type == ContentParam::OBJECT)
348     return param.m_pObject.Get();
349 
350   NOTREACHED();
351   return nullptr;
352 }
353 
GetString(uint32_t index) const354 ByteString CPDF_StreamContentParser::GetString(uint32_t index) const {
355   if (index >= m_ParamCount)
356     return ByteString();
357 
358   int real_index = m_ParamStartPos + m_ParamCount - index - 1;
359   if (real_index >= kParamBufSize)
360     real_index -= kParamBufSize;
361 
362   const ContentParam& param = m_ParamBuf[real_index];
363   if (param.m_Type == ContentParam::NAME)
364     return param.m_Name;
365 
366   if (param.m_Type == 0 && param.m_pObject)
367     return param.m_pObject->GetString();
368 
369   return ByteString();
370 }
371 
GetNumber(uint32_t index) const372 float CPDF_StreamContentParser::GetNumber(uint32_t index) const {
373   if (index >= m_ParamCount)
374     return 0;
375 
376   int real_index = m_ParamStartPos + m_ParamCount - index - 1;
377   if (real_index >= kParamBufSize)
378     real_index -= kParamBufSize;
379 
380   const ContentParam& param = m_ParamBuf[real_index];
381   if (param.m_Type == ContentParam::NUMBER)
382     return param.m_Number.GetFloat();
383 
384   if (param.m_Type == 0 && param.m_pObject)
385     return param.m_pObject->GetNumber();
386 
387   return 0;
388 }
389 
GetNumbers(size_t count) const390 std::vector<float> CPDF_StreamContentParser::GetNumbers(size_t count) const {
391   std::vector<float> values(count);
392   for (size_t i = 0; i < count; ++i)
393     values[i] = GetNumber(count - i - 1);
394   return values;
395 }
396 
SetGraphicStates(CPDF_PageObject * pObj,bool bColor,bool bText,bool bGraph)397 void CPDF_StreamContentParser::SetGraphicStates(CPDF_PageObject* pObj,
398                                                 bool bColor,
399                                                 bool bText,
400                                                 bool bGraph) {
401   pObj->m_GeneralState = m_pCurStates->m_GeneralState;
402   pObj->m_ClipPath = m_pCurStates->m_ClipPath;
403   pObj->m_ContentMarks = *m_ContentMarksStack.top();
404   if (bColor) {
405     pObj->m_ColorState = m_pCurStates->m_ColorState;
406   }
407   if (bGraph) {
408     pObj->m_GraphState = m_pCurStates->m_GraphState;
409   }
410   if (bText) {
411     pObj->m_TextState = m_pCurStates->m_TextState;
412   }
413 }
414 
415 // static
416 CPDF_StreamContentParser::OpCodes
InitializeOpCodes()417 CPDF_StreamContentParser::InitializeOpCodes() {
418   return OpCodes({
419       {FXBSTR_ID('"', 0, 0, 0),
420        &CPDF_StreamContentParser::Handle_NextLineShowText_Space},
421       {FXBSTR_ID('\'', 0, 0, 0),
422        &CPDF_StreamContentParser::Handle_NextLineShowText},
423       {FXBSTR_ID('B', 0, 0, 0),
424        &CPDF_StreamContentParser::Handle_FillStrokePath},
425       {FXBSTR_ID('B', '*', 0, 0),
426        &CPDF_StreamContentParser::Handle_EOFillStrokePath},
427       {FXBSTR_ID('B', 'D', 'C', 0),
428        &CPDF_StreamContentParser::Handle_BeginMarkedContent_Dictionary},
429       {FXBSTR_ID('B', 'I', 0, 0), &CPDF_StreamContentParser::Handle_BeginImage},
430       {FXBSTR_ID('B', 'M', 'C', 0),
431        &CPDF_StreamContentParser::Handle_BeginMarkedContent},
432       {FXBSTR_ID('B', 'T', 0, 0), &CPDF_StreamContentParser::Handle_BeginText},
433       {FXBSTR_ID('C', 'S', 0, 0),
434        &CPDF_StreamContentParser::Handle_SetColorSpace_Stroke},
435       {FXBSTR_ID('D', 'P', 0, 0),
436        &CPDF_StreamContentParser::Handle_MarkPlace_Dictionary},
437       {FXBSTR_ID('D', 'o', 0, 0),
438        &CPDF_StreamContentParser::Handle_ExecuteXObject},
439       {FXBSTR_ID('E', 'I', 0, 0), &CPDF_StreamContentParser::Handle_EndImage},
440       {FXBSTR_ID('E', 'M', 'C', 0),
441        &CPDF_StreamContentParser::Handle_EndMarkedContent},
442       {FXBSTR_ID('E', 'T', 0, 0), &CPDF_StreamContentParser::Handle_EndText},
443       {FXBSTR_ID('F', 0, 0, 0), &CPDF_StreamContentParser::Handle_FillPathOld},
444       {FXBSTR_ID('G', 0, 0, 0),
445        &CPDF_StreamContentParser::Handle_SetGray_Stroke},
446       {FXBSTR_ID('I', 'D', 0, 0),
447        &CPDF_StreamContentParser::Handle_BeginImageData},
448       {FXBSTR_ID('J', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetLineCap},
449       {FXBSTR_ID('K', 0, 0, 0),
450        &CPDF_StreamContentParser::Handle_SetCMYKColor_Stroke},
451       {FXBSTR_ID('M', 0, 0, 0),
452        &CPDF_StreamContentParser::Handle_SetMiterLimit},
453       {FXBSTR_ID('M', 'P', 0, 0), &CPDF_StreamContentParser::Handle_MarkPlace},
454       {FXBSTR_ID('Q', 0, 0, 0),
455        &CPDF_StreamContentParser::Handle_RestoreGraphState},
456       {FXBSTR_ID('R', 'G', 0, 0),
457        &CPDF_StreamContentParser::Handle_SetRGBColor_Stroke},
458       {FXBSTR_ID('S', 0, 0, 0), &CPDF_StreamContentParser::Handle_StrokePath},
459       {FXBSTR_ID('S', 'C', 0, 0),
460        &CPDF_StreamContentParser::Handle_SetColor_Stroke},
461       {FXBSTR_ID('S', 'C', 'N', 0),
462        &CPDF_StreamContentParser::Handle_SetColorPS_Stroke},
463       {FXBSTR_ID('T', '*', 0, 0),
464        &CPDF_StreamContentParser::Handle_MoveToNextLine},
465       {FXBSTR_ID('T', 'D', 0, 0),
466        &CPDF_StreamContentParser::Handle_MoveTextPoint_SetLeading},
467       {FXBSTR_ID('T', 'J', 0, 0),
468        &CPDF_StreamContentParser::Handle_ShowText_Positioning},
469       {FXBSTR_ID('T', 'L', 0, 0),
470        &CPDF_StreamContentParser::Handle_SetTextLeading},
471       {FXBSTR_ID('T', 'c', 0, 0),
472        &CPDF_StreamContentParser::Handle_SetCharSpace},
473       {FXBSTR_ID('T', 'd', 0, 0),
474        &CPDF_StreamContentParser::Handle_MoveTextPoint},
475       {FXBSTR_ID('T', 'f', 0, 0), &CPDF_StreamContentParser::Handle_SetFont},
476       {FXBSTR_ID('T', 'j', 0, 0), &CPDF_StreamContentParser::Handle_ShowText},
477       {FXBSTR_ID('T', 'm', 0, 0),
478        &CPDF_StreamContentParser::Handle_SetTextMatrix},
479       {FXBSTR_ID('T', 'r', 0, 0),
480        &CPDF_StreamContentParser::Handle_SetTextRenderMode},
481       {FXBSTR_ID('T', 's', 0, 0),
482        &CPDF_StreamContentParser::Handle_SetTextRise},
483       {FXBSTR_ID('T', 'w', 0, 0),
484        &CPDF_StreamContentParser::Handle_SetWordSpace},
485       {FXBSTR_ID('T', 'z', 0, 0),
486        &CPDF_StreamContentParser::Handle_SetHorzScale},
487       {FXBSTR_ID('W', 0, 0, 0), &CPDF_StreamContentParser::Handle_Clip},
488       {FXBSTR_ID('W', '*', 0, 0), &CPDF_StreamContentParser::Handle_EOClip},
489       {FXBSTR_ID('b', 0, 0, 0),
490        &CPDF_StreamContentParser::Handle_CloseFillStrokePath},
491       {FXBSTR_ID('b', '*', 0, 0),
492        &CPDF_StreamContentParser::Handle_CloseEOFillStrokePath},
493       {FXBSTR_ID('c', 0, 0, 0), &CPDF_StreamContentParser::Handle_CurveTo_123},
494       {FXBSTR_ID('c', 'm', 0, 0),
495        &CPDF_StreamContentParser::Handle_ConcatMatrix},
496       {FXBSTR_ID('c', 's', 0, 0),
497        &CPDF_StreamContentParser::Handle_SetColorSpace_Fill},
498       {FXBSTR_ID('d', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetDash},
499       {FXBSTR_ID('d', '0', 0, 0),
500        &CPDF_StreamContentParser::Handle_SetCharWidth},
501       {FXBSTR_ID('d', '1', 0, 0),
502        &CPDF_StreamContentParser::Handle_SetCachedDevice},
503       {FXBSTR_ID('f', 0, 0, 0), &CPDF_StreamContentParser::Handle_FillPath},
504       {FXBSTR_ID('f', '*', 0, 0), &CPDF_StreamContentParser::Handle_EOFillPath},
505       {FXBSTR_ID('g', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetGray_Fill},
506       {FXBSTR_ID('g', 's', 0, 0),
507        &CPDF_StreamContentParser::Handle_SetExtendGraphState},
508       {FXBSTR_ID('h', 0, 0, 0), &CPDF_StreamContentParser::Handle_ClosePath},
509       {FXBSTR_ID('i', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetFlat},
510       {FXBSTR_ID('j', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetLineJoin},
511       {FXBSTR_ID('k', 0, 0, 0),
512        &CPDF_StreamContentParser::Handle_SetCMYKColor_Fill},
513       {FXBSTR_ID('l', 0, 0, 0), &CPDF_StreamContentParser::Handle_LineTo},
514       {FXBSTR_ID('m', 0, 0, 0), &CPDF_StreamContentParser::Handle_MoveTo},
515       {FXBSTR_ID('n', 0, 0, 0), &CPDF_StreamContentParser::Handle_EndPath},
516       {FXBSTR_ID('q', 0, 0, 0),
517        &CPDF_StreamContentParser::Handle_SaveGraphState},
518       {FXBSTR_ID('r', 'e', 0, 0), &CPDF_StreamContentParser::Handle_Rectangle},
519       {FXBSTR_ID('r', 'g', 0, 0),
520        &CPDF_StreamContentParser::Handle_SetRGBColor_Fill},
521       {FXBSTR_ID('r', 'i', 0, 0),
522        &CPDF_StreamContentParser::Handle_SetRenderIntent},
523       {FXBSTR_ID('s', 0, 0, 0),
524        &CPDF_StreamContentParser::Handle_CloseStrokePath},
525       {FXBSTR_ID('s', 'c', 0, 0),
526        &CPDF_StreamContentParser::Handle_SetColor_Fill},
527       {FXBSTR_ID('s', 'c', 'n', 0),
528        &CPDF_StreamContentParser::Handle_SetColorPS_Fill},
529       {FXBSTR_ID('s', 'h', 0, 0), &CPDF_StreamContentParser::Handle_ShadeFill},
530       {FXBSTR_ID('v', 0, 0, 0), &CPDF_StreamContentParser::Handle_CurveTo_23},
531       {FXBSTR_ID('w', 0, 0, 0), &CPDF_StreamContentParser::Handle_SetLineWidth},
532       {FXBSTR_ID('y', 0, 0, 0), &CPDF_StreamContentParser::Handle_CurveTo_13},
533   });
534 }
535 
OnOperator(ByteStringView op)536 void CPDF_StreamContentParser::OnOperator(ByteStringView op) {
537   static const OpCodes s_OpCodes = InitializeOpCodes();
538 
539   auto it = s_OpCodes.find(op.GetID());
540   if (it != s_OpCodes.end())
541     (this->*it->second)();
542 }
543 
Handle_CloseFillStrokePath()544 void CPDF_StreamContentParser::Handle_CloseFillStrokePath() {
545   Handle_ClosePath();
546   AddPathObject(CFX_FillRenderOptions::FillType::kWinding, true);
547 }
548 
Handle_FillStrokePath()549 void CPDF_StreamContentParser::Handle_FillStrokePath() {
550   AddPathObject(CFX_FillRenderOptions::FillType::kWinding, true);
551 }
552 
Handle_CloseEOFillStrokePath()553 void CPDF_StreamContentParser::Handle_CloseEOFillStrokePath() {
554   AddPathPoint(m_PathStartX, m_PathStartY, FXPT_TYPE::LineTo, true);
555   AddPathObject(CFX_FillRenderOptions::FillType::kEvenOdd, true);
556 }
557 
Handle_EOFillStrokePath()558 void CPDF_StreamContentParser::Handle_EOFillStrokePath() {
559   AddPathObject(CFX_FillRenderOptions::FillType::kEvenOdd, true);
560 }
561 
Handle_BeginMarkedContent_Dictionary()562 void CPDF_StreamContentParser::Handle_BeginMarkedContent_Dictionary() {
563   CPDF_Object* pProperty = GetObject(0);
564   if (!pProperty)
565     return;
566 
567   ByteString tag = GetString(1);
568   std::unique_ptr<CPDF_ContentMarks> new_marks =
569       m_ContentMarksStack.top()->Clone();
570 
571   if (pProperty->IsName()) {
572     ByteString property_name = pProperty->GetString();
573     CPDF_Dictionary* pHolder = FindResourceHolder("Properties");
574     if (!pHolder || !pHolder->GetDictFor(property_name))
575       return;
576     new_marks->AddMarkWithPropertiesHolder(tag, pHolder, property_name);
577   } else if (pProperty->IsDictionary()) {
578     new_marks->AddMarkWithDirectDict(tag, pProperty->AsDictionary());
579   } else {
580     return;
581   }
582   m_ContentMarksStack.push(std::move(new_marks));
583 }
584 
Handle_BeginImage()585 void CPDF_StreamContentParser::Handle_BeginImage() {
586   FX_FILESIZE savePos = m_pSyntax->GetPos();
587   auto pDict = m_pDocument->New<CPDF_Dictionary>();
588   while (1) {
589     CPDF_StreamParser::SyntaxType type = m_pSyntax->ParseNextElement();
590     if (type == CPDF_StreamParser::Keyword) {
591       if (m_pSyntax->GetWord() != "ID") {
592         m_pSyntax->SetPos(savePos);
593         return;
594       }
595     }
596     if (type != CPDF_StreamParser::Name) {
597       break;
598     }
599     auto word = m_pSyntax->GetWord();
600     ByteString key(word.Last(word.GetLength() - 1));
601     auto pObj = m_pSyntax->ReadNextObject(false, false, 0);
602     if (!key.IsEmpty()) {
603       if (pObj && !pObj->IsInline()) {
604         pDict->SetNewFor<CPDF_Reference>(key, m_pDocument.Get(),
605                                          pObj->GetObjNum());
606       } else {
607         pDict->SetFor(key, std::move(pObj));
608       }
609     }
610   }
611   ReplaceAbbr(pDict.Get());
612   CPDF_Object* pCSObj = nullptr;
613   if (pDict->KeyExist("ColorSpace")) {
614     pCSObj = pDict->GetDirectObjectFor("ColorSpace");
615     if (pCSObj->IsName()) {
616       ByteString name = pCSObj->GetString();
617       if (name != "DeviceRGB" && name != "DeviceGray" && name != "DeviceCMYK") {
618         pCSObj = FindResourceObj("ColorSpace", name);
619         if (pCSObj && pCSObj->IsInline())
620           pDict->SetFor("ColorSpace", pCSObj->Clone());
621       }
622     }
623   }
624   pDict->SetNewFor<CPDF_Name>("Subtype", "Image");
625   RetainPtr<CPDF_Stream> pStream =
626       m_pSyntax->ReadInlineStream(m_pDocument.Get(), std::move(pDict), pCSObj);
627   while (1) {
628     CPDF_StreamParser::SyntaxType type = m_pSyntax->ParseNextElement();
629     if (type == CPDF_StreamParser::EndOfData) {
630       break;
631     }
632     if (type != CPDF_StreamParser::Keyword) {
633       continue;
634     }
635     if (m_pSyntax->GetWord() == "EI") {
636       break;
637     }
638   }
639   CPDF_ImageObject* pObj = AddImage(std::move(pStream));
640   // Record the bounding box of this image, so rendering code can draw it
641   // properly.
642   if (pObj && pObj->GetImage()->IsMask())
643     m_pObjectHolder->AddImageMaskBoundingBox(pObj->GetRect());
644 }
645 
Handle_BeginMarkedContent()646 void CPDF_StreamContentParser::Handle_BeginMarkedContent() {
647   std::unique_ptr<CPDF_ContentMarks> new_marks =
648       m_ContentMarksStack.top()->Clone();
649   new_marks->AddMark(GetString(0));
650   m_ContentMarksStack.push(std::move(new_marks));
651 }
652 
Handle_BeginText()653 void CPDF_StreamContentParser::Handle_BeginText() {
654   m_pCurStates->m_TextMatrix = CFX_Matrix();
655   OnChangeTextMatrix();
656   m_pCurStates->m_TextPos = CFX_PointF();
657   m_pCurStates->m_TextLinePos = CFX_PointF();
658 }
659 
Handle_CurveTo_123()660 void CPDF_StreamContentParser::Handle_CurveTo_123() {
661   AddPathPoint(GetNumber(5), GetNumber(4), FXPT_TYPE::BezierTo, false);
662   AddPathPoint(GetNumber(3), GetNumber(2), FXPT_TYPE::BezierTo, false);
663   AddPathPoint(GetNumber(1), GetNumber(0), FXPT_TYPE::BezierTo, false);
664 }
665 
Handle_ConcatMatrix()666 void CPDF_StreamContentParser::Handle_ConcatMatrix() {
667   CFX_Matrix new_matrix(GetNumber(5), GetNumber(4), GetNumber(3), GetNumber(2),
668                         GetNumber(1), GetNumber(0));
669   m_pCurStates->m_CTM = new_matrix * m_pCurStates->m_CTM;
670   OnChangeTextMatrix();
671 }
672 
Handle_SetColorSpace_Fill()673 void CPDF_StreamContentParser::Handle_SetColorSpace_Fill() {
674   RetainPtr<CPDF_ColorSpace> pCS = FindColorSpace(GetString(0));
675   if (!pCS)
676     return;
677 
678   m_pCurStates->m_ColorState.GetMutableFillColor()->SetColorSpace(pCS);
679 }
680 
Handle_SetColorSpace_Stroke()681 void CPDF_StreamContentParser::Handle_SetColorSpace_Stroke() {
682   RetainPtr<CPDF_ColorSpace> pCS = FindColorSpace(GetString(0));
683   if (!pCS)
684     return;
685 
686   m_pCurStates->m_ColorState.GetMutableStrokeColor()->SetColorSpace(pCS);
687 }
688 
Handle_SetDash()689 void CPDF_StreamContentParser::Handle_SetDash() {
690   CPDF_Array* pArray = ToArray(GetObject(1));
691   if (!pArray)
692     return;
693 
694   m_pCurStates->SetLineDash(pArray, GetNumber(0), 1.0f);
695 }
696 
Handle_SetCharWidth()697 void CPDF_StreamContentParser::Handle_SetCharWidth() {
698   m_Type3Data[0] = GetNumber(1);
699   m_Type3Data[1] = GetNumber(0);
700   m_bColored = true;
701 }
702 
Handle_SetCachedDevice()703 void CPDF_StreamContentParser::Handle_SetCachedDevice() {
704   for (int i = 0; i < 6; i++) {
705     m_Type3Data[i] = GetNumber(5 - i);
706   }
707   m_bColored = false;
708 }
709 
Handle_ExecuteXObject()710 void CPDF_StreamContentParser::Handle_ExecuteXObject() {
711   ByteString name = GetString(0);
712   if (name == m_LastImageName && m_pLastImage && m_pLastImage->GetStream() &&
713       m_pLastImage->GetStream()->GetObjNum()) {
714     CPDF_ImageObject* pObj = AddImage(m_pLastImage);
715     // Record the bounding box of this image, so rendering code can draw it
716     // properly.
717     if (pObj && pObj->GetImage()->IsMask())
718       m_pObjectHolder->AddImageMaskBoundingBox(pObj->GetRect());
719     return;
720   }
721 
722   CPDF_Stream* pXObject = ToStream(FindResourceObj("XObject", name));
723   if (!pXObject) {
724     m_bResourceMissing = true;
725     return;
726   }
727 
728   ByteString type;
729   if (pXObject->GetDict())
730     type = pXObject->GetDict()->GetStringFor("Subtype");
731 
732   if (type == "Form") {
733     AddForm(pXObject);
734     return;
735   }
736 
737   if (type == "Image") {
738     CPDF_ImageObject* pObj = pXObject->IsInline()
739                                  ? AddImage(ToStream(pXObject->Clone()))
740                                  : AddImage(pXObject->GetObjNum());
741 
742     m_LastImageName = std::move(name);
743     if (pObj) {
744       m_pLastImage = pObj->GetImage();
745       if (m_pLastImage->IsMask())
746         m_pObjectHolder->AddImageMaskBoundingBox(pObj->GetRect());
747     }
748   }
749 }
750 
AddForm(CPDF_Stream * pStream)751 void CPDF_StreamContentParser::AddForm(CPDF_Stream* pStream) {
752   CPDF_AllStates status;
753   status.m_GeneralState = m_pCurStates->m_GeneralState;
754   status.m_GraphState = m_pCurStates->m_GraphState;
755   status.m_ColorState = m_pCurStates->m_ColorState;
756   status.m_TextState = m_pCurStates->m_TextState;
757   auto form = std::make_unique<CPDF_Form>(
758       m_pDocument.Get(), m_pPageResources.Get(), pStream, m_pResources.Get());
759   form->ParseContent(&status, nullptr, m_ParsedSet.Get());
760 
761   CFX_Matrix matrix = m_pCurStates->m_CTM * m_mtContentToUser;
762 
763   auto pFormObj = std::make_unique<CPDF_FormObject>(GetCurrentStreamIndex(),
764                                                     std::move(form), matrix);
765   if (!m_pObjectHolder->BackgroundAlphaNeeded() &&
766       pFormObj->form()->BackgroundAlphaNeeded()) {
767     m_pObjectHolder->SetBackgroundAlphaNeeded(true);
768   }
769   pFormObj->CalcBoundingBox();
770   SetGraphicStates(pFormObj.get(), true, true, true);
771   m_pObjectHolder->AppendPageObject(std::move(pFormObj));
772 }
773 
AddImage(RetainPtr<CPDF_Stream> pStream)774 CPDF_ImageObject* CPDF_StreamContentParser::AddImage(
775     RetainPtr<CPDF_Stream> pStream) {
776   if (!pStream)
777     return nullptr;
778 
779   auto pImageObj = std::make_unique<CPDF_ImageObject>(GetCurrentStreamIndex());
780   pImageObj->SetImage(
781       pdfium::MakeRetain<CPDF_Image>(m_pDocument.Get(), std::move(pStream)));
782 
783   return AddImageObject(std::move(pImageObj));
784 }
785 
AddImage(uint32_t streamObjNum)786 CPDF_ImageObject* CPDF_StreamContentParser::AddImage(uint32_t streamObjNum) {
787   auto pImageObj = std::make_unique<CPDF_ImageObject>(GetCurrentStreamIndex());
788   pImageObj->SetImage(CPDF_DocPageData::FromDocument(m_pDocument.Get())
789                           ->GetImage(streamObjNum));
790 
791   return AddImageObject(std::move(pImageObj));
792 }
793 
AddImage(const RetainPtr<CPDF_Image> & pImage)794 CPDF_ImageObject* CPDF_StreamContentParser::AddImage(
795     const RetainPtr<CPDF_Image>& pImage) {
796   if (!pImage)
797     return nullptr;
798 
799   auto pImageObj = std::make_unique<CPDF_ImageObject>(GetCurrentStreamIndex());
800   pImageObj->SetImage(CPDF_DocPageData::FromDocument(m_pDocument.Get())
801                           ->GetImage(pImage->GetStream()->GetObjNum()));
802 
803   return AddImageObject(std::move(pImageObj));
804 }
805 
AddImageObject(std::unique_ptr<CPDF_ImageObject> pImageObj)806 CPDF_ImageObject* CPDF_StreamContentParser::AddImageObject(
807     std::unique_ptr<CPDF_ImageObject> pImageObj) {
808   SetGraphicStates(pImageObj.get(), pImageObj->GetImage()->IsMask(), false,
809                    false);
810 
811   CFX_Matrix ImageMatrix = m_pCurStates->m_CTM * m_mtContentToUser;
812   pImageObj->set_matrix(ImageMatrix);
813   pImageObj->CalcBoundingBox();
814 
815   CPDF_ImageObject* pRet = pImageObj.get();
816   m_pObjectHolder->AppendPageObject(std::move(pImageObj));
817   return pRet;
818 }
819 
GetColors() const820 std::vector<float> CPDF_StreamContentParser::GetColors() const {
821   ASSERT(m_ParamCount > 0);
822   return GetNumbers(m_ParamCount);
823 }
824 
GetNamedColors() const825 std::vector<float> CPDF_StreamContentParser::GetNamedColors() const {
826   ASSERT(m_ParamCount > 0);
827   const uint32_t nvalues = m_ParamCount - 1;
828   std::vector<float> values(nvalues);
829   for (size_t i = 0; i < nvalues; ++i)
830     values[i] = GetNumber(m_ParamCount - i - 1);
831   return values;
832 }
833 
Handle_MarkPlace_Dictionary()834 void CPDF_StreamContentParser::Handle_MarkPlace_Dictionary() {}
835 
Handle_EndImage()836 void CPDF_StreamContentParser::Handle_EndImage() {}
837 
Handle_EndMarkedContent()838 void CPDF_StreamContentParser::Handle_EndMarkedContent() {
839   // First element is a sentinel, so do not pop it, ever. This may come up if
840   // the EMCs are mismatched with the BMC/BDCs.
841   if (m_ContentMarksStack.size() > 1)
842     m_ContentMarksStack.pop();
843 }
844 
Handle_EndText()845 void CPDF_StreamContentParser::Handle_EndText() {
846   if (m_ClipTextList.empty())
847     return;
848 
849   if (TextRenderingModeIsClipMode(m_pCurStates->m_TextState.GetTextMode()))
850     m_pCurStates->m_ClipPath.AppendTexts(&m_ClipTextList);
851 
852   m_ClipTextList.clear();
853 }
854 
Handle_FillPath()855 void CPDF_StreamContentParser::Handle_FillPath() {
856   AddPathObject(CFX_FillRenderOptions::FillType::kWinding, false);
857 }
858 
Handle_FillPathOld()859 void CPDF_StreamContentParser::Handle_FillPathOld() {
860   AddPathObject(CFX_FillRenderOptions::FillType::kWinding, false);
861 }
862 
Handle_EOFillPath()863 void CPDF_StreamContentParser::Handle_EOFillPath() {
864   AddPathObject(CFX_FillRenderOptions::FillType::kEvenOdd, false);
865 }
866 
Handle_SetGray_Fill()867 void CPDF_StreamContentParser::Handle_SetGray_Fill() {
868   RetainPtr<CPDF_ColorSpace> pCS =
869       CPDF_ColorSpace::GetStockCS(PDFCS_DEVICEGRAY);
870   m_pCurStates->m_ColorState.SetFillColor(pCS, GetNumbers(1));
871 }
872 
Handle_SetGray_Stroke()873 void CPDF_StreamContentParser::Handle_SetGray_Stroke() {
874   RetainPtr<CPDF_ColorSpace> pCS =
875       CPDF_ColorSpace::GetStockCS(PDFCS_DEVICEGRAY);
876   m_pCurStates->m_ColorState.SetStrokeColor(pCS, GetNumbers(1));
877 }
878 
Handle_SetExtendGraphState()879 void CPDF_StreamContentParser::Handle_SetExtendGraphState() {
880   ByteString name = GetString(0);
881   CPDF_Dictionary* pGS = ToDictionary(FindResourceObj("ExtGState", name));
882   if (!pGS) {
883     m_bResourceMissing = true;
884     return;
885   }
886   m_pCurStates->ProcessExtGS(pGS, this);
887 }
888 
Handle_ClosePath()889 void CPDF_StreamContentParser::Handle_ClosePath() {
890   if (m_PathPoints.empty())
891     return;
892 
893   if (m_PathStartX != m_PathCurrentX || m_PathStartY != m_PathCurrentY)
894     AddPathPoint(m_PathStartX, m_PathStartY, FXPT_TYPE::LineTo, true);
895   else if (m_PathPoints.back().m_Type != FXPT_TYPE::MoveTo)
896     m_PathPoints.back().m_CloseFigure = true;
897 }
898 
Handle_SetFlat()899 void CPDF_StreamContentParser::Handle_SetFlat() {
900   m_pCurStates->m_GeneralState.SetFlatness(GetNumber(0));
901 }
902 
Handle_BeginImageData()903 void CPDF_StreamContentParser::Handle_BeginImageData() {}
904 
Handle_SetLineJoin()905 void CPDF_StreamContentParser::Handle_SetLineJoin() {
906   m_pCurStates->m_GraphState.SetLineJoin(
907       static_cast<CFX_GraphStateData::LineJoin>(GetInteger(0)));
908 }
909 
Handle_SetLineCap()910 void CPDF_StreamContentParser::Handle_SetLineCap() {
911   m_pCurStates->m_GraphState.SetLineCap(
912       static_cast<CFX_GraphStateData::LineCap>(GetInteger(0)));
913 }
914 
Handle_SetCMYKColor_Fill()915 void CPDF_StreamContentParser::Handle_SetCMYKColor_Fill() {
916   if (m_ParamCount != 4)
917     return;
918 
919   RetainPtr<CPDF_ColorSpace> pCS =
920       CPDF_ColorSpace::GetStockCS(PDFCS_DEVICECMYK);
921   m_pCurStates->m_ColorState.SetFillColor(pCS, GetNumbers(4));
922 }
923 
Handle_SetCMYKColor_Stroke()924 void CPDF_StreamContentParser::Handle_SetCMYKColor_Stroke() {
925   if (m_ParamCount != 4)
926     return;
927 
928   RetainPtr<CPDF_ColorSpace> pCS =
929       CPDF_ColorSpace::GetStockCS(PDFCS_DEVICECMYK);
930   m_pCurStates->m_ColorState.SetStrokeColor(pCS, GetNumbers(4));
931 }
932 
Handle_LineTo()933 void CPDF_StreamContentParser::Handle_LineTo() {
934   if (m_ParamCount != 2)
935     return;
936 
937   AddPathPoint(GetNumber(1), GetNumber(0), FXPT_TYPE::LineTo, false);
938 }
939 
Handle_MoveTo()940 void CPDF_StreamContentParser::Handle_MoveTo() {
941   if (m_ParamCount != 2)
942     return;
943 
944   AddPathPoint(GetNumber(1), GetNumber(0), FXPT_TYPE::MoveTo, false);
945   ParsePathObject();
946 }
947 
Handle_SetMiterLimit()948 void CPDF_StreamContentParser::Handle_SetMiterLimit() {
949   m_pCurStates->m_GraphState.SetMiterLimit(GetNumber(0));
950 }
951 
Handle_MarkPlace()952 void CPDF_StreamContentParser::Handle_MarkPlace() {}
953 
Handle_EndPath()954 void CPDF_StreamContentParser::Handle_EndPath() {
955   AddPathObject(CFX_FillRenderOptions::FillType::kNoFill, false);
956 }
957 
Handle_SaveGraphState()958 void CPDF_StreamContentParser::Handle_SaveGraphState() {
959   auto pStates = std::make_unique<CPDF_AllStates>();
960   pStates->Copy(*m_pCurStates);
961   m_StateStack.push_back(std::move(pStates));
962 }
963 
Handle_RestoreGraphState()964 void CPDF_StreamContentParser::Handle_RestoreGraphState() {
965   if (m_StateStack.empty())
966     return;
967   std::unique_ptr<CPDF_AllStates> pStates = std::move(m_StateStack.back());
968   m_StateStack.pop_back();
969   m_pCurStates->Copy(*pStates);
970 }
971 
Handle_Rectangle()972 void CPDF_StreamContentParser::Handle_Rectangle() {
973   float x = GetNumber(3), y = GetNumber(2);
974   float w = GetNumber(1), h = GetNumber(0);
975   AddPathRect(x, y, w, h);
976 }
977 
AddPathRect(float x,float y,float w,float h)978 void CPDF_StreamContentParser::AddPathRect(float x, float y, float w, float h) {
979   AddPathPoint(x, y, FXPT_TYPE::MoveTo, false);
980   AddPathPoint(x + w, y, FXPT_TYPE::LineTo, false);
981   AddPathPoint(x + w, y + h, FXPT_TYPE::LineTo, false);
982   AddPathPoint(x, y + h, FXPT_TYPE::LineTo, false);
983   AddPathPoint(x, y, FXPT_TYPE::LineTo, true);
984 }
985 
Handle_SetRGBColor_Fill()986 void CPDF_StreamContentParser::Handle_SetRGBColor_Fill() {
987   if (m_ParamCount != 3)
988     return;
989 
990   RetainPtr<CPDF_ColorSpace> pCS = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICERGB);
991   m_pCurStates->m_ColorState.SetFillColor(pCS, GetNumbers(3));
992 }
993 
Handle_SetRGBColor_Stroke()994 void CPDF_StreamContentParser::Handle_SetRGBColor_Stroke() {
995   if (m_ParamCount != 3)
996     return;
997 
998   RetainPtr<CPDF_ColorSpace> pCS = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICERGB);
999   m_pCurStates->m_ColorState.SetStrokeColor(pCS, GetNumbers(3));
1000 }
1001 
Handle_SetRenderIntent()1002 void CPDF_StreamContentParser::Handle_SetRenderIntent() {}
1003 
Handle_CloseStrokePath()1004 void CPDF_StreamContentParser::Handle_CloseStrokePath() {
1005   Handle_ClosePath();
1006   AddPathObject(CFX_FillRenderOptions::FillType::kNoFill, true);
1007 }
1008 
Handle_StrokePath()1009 void CPDF_StreamContentParser::Handle_StrokePath() {
1010   AddPathObject(CFX_FillRenderOptions::FillType::kNoFill, true);
1011 }
1012 
Handle_SetColor_Fill()1013 void CPDF_StreamContentParser::Handle_SetColor_Fill() {
1014   int nargs = std::min(m_ParamCount, 4U);
1015   m_pCurStates->m_ColorState.SetFillColor(nullptr, GetNumbers(nargs));
1016 }
1017 
Handle_SetColor_Stroke()1018 void CPDF_StreamContentParser::Handle_SetColor_Stroke() {
1019   int nargs = std::min(m_ParamCount, 4U);
1020   m_pCurStates->m_ColorState.SetStrokeColor(nullptr, GetNumbers(nargs));
1021 }
1022 
Handle_SetColorPS_Fill()1023 void CPDF_StreamContentParser::Handle_SetColorPS_Fill() {
1024   CPDF_Object* pLastParam = GetObject(0);
1025   if (!pLastParam)
1026     return;
1027 
1028   if (!pLastParam->IsName()) {
1029     m_pCurStates->m_ColorState.SetFillColor(nullptr, GetColors());
1030     return;
1031   }
1032 
1033   // A valid |pLastParam| implies |m_ParamCount| > 0, so GetNamedColors() call
1034   // below is safe.
1035   RetainPtr<CPDF_Pattern> pPattern = FindPattern(GetString(0), false);
1036   if (pPattern)
1037     m_pCurStates->m_ColorState.SetFillPattern(pPattern, GetNamedColors());
1038 }
1039 
Handle_SetColorPS_Stroke()1040 void CPDF_StreamContentParser::Handle_SetColorPS_Stroke() {
1041   CPDF_Object* pLastParam = GetObject(0);
1042   if (!pLastParam)
1043     return;
1044 
1045   if (!pLastParam->IsName()) {
1046     m_pCurStates->m_ColorState.SetStrokeColor(nullptr, GetColors());
1047     return;
1048   }
1049 
1050   // A valid |pLastParam| implies |m_ParamCount| > 0, so GetNamedColors() call
1051   // below is safe.
1052   RetainPtr<CPDF_Pattern> pPattern = FindPattern(GetString(0), false);
1053   if (pPattern)
1054     m_pCurStates->m_ColorState.SetStrokePattern(pPattern, GetNamedColors());
1055 }
1056 
Handle_ShadeFill()1057 void CPDF_StreamContentParser::Handle_ShadeFill() {
1058   RetainPtr<CPDF_Pattern> pPattern = FindPattern(GetString(0), true);
1059   if (!pPattern)
1060     return;
1061 
1062   CPDF_ShadingPattern* pShading = pPattern->AsShadingPattern();
1063   if (!pShading)
1064     return;
1065 
1066   if (!pShading->IsShadingObject() || !pShading->Load())
1067     return;
1068 
1069   CFX_Matrix matrix = m_pCurStates->m_CTM * m_mtContentToUser;
1070   auto pObj = std::make_unique<CPDF_ShadingObject>(GetCurrentStreamIndex(),
1071                                                    pShading, matrix);
1072   SetGraphicStates(pObj.get(), false, false, false);
1073   CFX_FloatRect bbox =
1074       pObj->m_ClipPath.HasRef() ? pObj->m_ClipPath.GetClipBox() : m_BBox;
1075   if (pShading->IsMeshShading())
1076     bbox.Intersect(GetShadingBBox(pShading, pObj->matrix()));
1077   pObj->SetRect(bbox);
1078   m_pObjectHolder->AppendPageObject(std::move(pObj));
1079 }
1080 
Handle_SetCharSpace()1081 void CPDF_StreamContentParser::Handle_SetCharSpace() {
1082   m_pCurStates->m_TextState.SetCharSpace(GetNumber(0));
1083 }
1084 
Handle_MoveTextPoint()1085 void CPDF_StreamContentParser::Handle_MoveTextPoint() {
1086   m_pCurStates->m_TextLinePos += CFX_PointF(GetNumber(1), GetNumber(0));
1087   m_pCurStates->m_TextPos = m_pCurStates->m_TextLinePos;
1088 }
1089 
Handle_MoveTextPoint_SetLeading()1090 void CPDF_StreamContentParser::Handle_MoveTextPoint_SetLeading() {
1091   Handle_MoveTextPoint();
1092   m_pCurStates->m_TextLeading = -GetNumber(0);
1093 }
1094 
Handle_SetFont()1095 void CPDF_StreamContentParser::Handle_SetFont() {
1096   float fs = GetNumber(0);
1097   if (fs == 0) {
1098     constexpr float kDefaultFontSize = 0.0f;
1099     fs = kDefaultFontSize;
1100   }
1101 
1102   m_pCurStates->m_TextState.SetFontSize(fs);
1103   RetainPtr<CPDF_Font> pFont = FindFont(GetString(1));
1104   if (pFont)
1105     m_pCurStates->m_TextState.SetFont(pFont);
1106 }
1107 
FindResourceHolder(const ByteString & type)1108 CPDF_Dictionary* CPDF_StreamContentParser::FindResourceHolder(
1109     const ByteString& type) {
1110   if (!m_pResources)
1111     return nullptr;
1112 
1113   CPDF_Dictionary* pDict = m_pResources->GetDictFor(type);
1114   if (pDict)
1115     return pDict;
1116 
1117   if (m_pResources == m_pPageResources || !m_pPageResources)
1118     return nullptr;
1119 
1120   return m_pPageResources->GetDictFor(type);
1121 }
1122 
FindResourceObj(const ByteString & type,const ByteString & name)1123 CPDF_Object* CPDF_StreamContentParser::FindResourceObj(const ByteString& type,
1124                                                        const ByteString& name) {
1125   CPDF_Dictionary* pHolder = FindResourceHolder(type);
1126   return pHolder ? pHolder->GetDirectObjectFor(name) : nullptr;
1127 }
1128 
FindFont(const ByteString & name)1129 RetainPtr<CPDF_Font> CPDF_StreamContentParser::FindFont(
1130     const ByteString& name) {
1131   CPDF_Dictionary* pFontDict = ToDictionary(FindResourceObj("Font", name));
1132   if (!pFontDict) {
1133     m_bResourceMissing = true;
1134     return CPDF_Font::GetStockFont(m_pDocument.Get(),
1135                                    CFX_Font::kDefaultAnsiFontName);
1136   }
1137   RetainPtr<CPDF_Font> pFont =
1138       CPDF_DocPageData::FromDocument(m_pDocument.Get())->GetFont(pFontDict);
1139   if (pFont && pFont->IsType3Font()) {
1140     pFont->AsType3Font()->SetPageResources(m_pResources.Get());
1141     pFont->AsType3Font()->CheckType3FontMetrics();
1142   }
1143   return pFont;
1144 }
1145 
FindColorSpace(const ByteString & name)1146 RetainPtr<CPDF_ColorSpace> CPDF_StreamContentParser::FindColorSpace(
1147     const ByteString& name) {
1148   if (name == "Pattern")
1149     return CPDF_ColorSpace::GetStockCS(PDFCS_PATTERN);
1150 
1151   if (name == "DeviceGray" || name == "DeviceCMYK" || name == "DeviceRGB") {
1152     ByteString defname = "Default";
1153     defname += name.Last(name.GetLength() - 7);
1154     const CPDF_Object* pDefObj = FindResourceObj("ColorSpace", defname);
1155     if (!pDefObj) {
1156       if (name == "DeviceGray")
1157         return CPDF_ColorSpace::GetStockCS(PDFCS_DEVICEGRAY);
1158 
1159       if (name == "DeviceRGB")
1160         return CPDF_ColorSpace::GetStockCS(PDFCS_DEVICERGB);
1161 
1162       return CPDF_ColorSpace::GetStockCS(PDFCS_DEVICECMYK);
1163     }
1164     return CPDF_DocPageData::FromDocument(m_pDocument.Get())
1165         ->GetColorSpace(pDefObj, nullptr);
1166   }
1167   const CPDF_Object* pCSObj = FindResourceObj("ColorSpace", name);
1168   if (!pCSObj) {
1169     m_bResourceMissing = true;
1170     return nullptr;
1171   }
1172   return CPDF_DocPageData::FromDocument(m_pDocument.Get())
1173       ->GetColorSpace(pCSObj, nullptr);
1174 }
1175 
FindPattern(const ByteString & name,bool bShading)1176 RetainPtr<CPDF_Pattern> CPDF_StreamContentParser::FindPattern(
1177     const ByteString& name,
1178     bool bShading) {
1179   CPDF_Object* pPattern =
1180       FindResourceObj(bShading ? "Shading" : "Pattern", name);
1181   if (!pPattern || (!pPattern->IsDictionary() && !pPattern->IsStream())) {
1182     m_bResourceMissing = true;
1183     return nullptr;
1184   }
1185   return CPDF_DocPageData::FromDocument(m_pDocument.Get())
1186       ->GetPattern(pPattern, bShading, m_pCurStates->m_ParentMatrix);
1187 }
1188 
AddTextObject(const ByteString * pStrs,float fInitKerning,const std::vector<float> & kernings,size_t nSegs)1189 void CPDF_StreamContentParser::AddTextObject(const ByteString* pStrs,
1190                                              float fInitKerning,
1191                                              const std::vector<float>& kernings,
1192                                              size_t nSegs) {
1193   RetainPtr<CPDF_Font> pFont = m_pCurStates->m_TextState.GetFont();
1194   if (!pFont)
1195     return;
1196 
1197   if (fInitKerning != 0) {
1198     if (pFont->IsVertWriting())
1199       m_pCurStates->m_TextPos.y -= GetVerticalTextSize(fInitKerning);
1200     else
1201       m_pCurStates->m_TextPos.x -= GetHorizontalTextSize(fInitKerning);
1202   }
1203   if (nSegs == 0)
1204     return;
1205 
1206   const TextRenderingMode text_mode =
1207       pFont->IsType3Font() ? TextRenderingMode::MODE_FILL
1208                            : m_pCurStates->m_TextState.GetTextMode();
1209   {
1210     auto pText = std::make_unique<CPDF_TextObject>(GetCurrentStreamIndex());
1211     m_pLastTextObject = pText.get();
1212     SetGraphicStates(m_pLastTextObject.Get(), true, true, true);
1213     if (TextRenderingModeIsStrokeMode(text_mode)) {
1214       float* pCTM = pText->m_TextState.GetMutableCTM();
1215       pCTM[0] = m_pCurStates->m_CTM.a;
1216       pCTM[1] = m_pCurStates->m_CTM.c;
1217       pCTM[2] = m_pCurStates->m_CTM.b;
1218       pCTM[3] = m_pCurStates->m_CTM.d;
1219     }
1220     pText->SetSegments(pStrs, kernings, nSegs);
1221     pText->SetPosition(
1222         m_mtContentToUser.Transform(m_pCurStates->m_CTM.Transform(
1223             m_pCurStates->m_TextMatrix.Transform(CFX_PointF(
1224                 m_pCurStates->m_TextPos.x,
1225                 m_pCurStates->m_TextPos.y + m_pCurStates->m_TextRise)))));
1226 
1227     m_pCurStates->m_TextPos +=
1228         pText->CalcPositionData(m_pCurStates->m_TextHorzScale);
1229     if (TextRenderingModeIsClipMode(text_mode)) {
1230       m_ClipTextList.push_back(
1231           std::unique_ptr<CPDF_TextObject>(pText->Clone()));
1232     }
1233     m_pObjectHolder->AppendPageObject(std::move(pText));
1234   }
1235   if (!kernings.empty() && kernings[nSegs - 1] != 0) {
1236     if (pFont->IsVertWriting())
1237       m_pCurStates->m_TextPos.y -= GetVerticalTextSize(kernings[nSegs - 1]);
1238     else
1239       m_pCurStates->m_TextPos.x -= GetHorizontalTextSize(kernings[nSegs - 1]);
1240   }
1241 }
1242 
GetHorizontalTextSize(float fKerning) const1243 float CPDF_StreamContentParser::GetHorizontalTextSize(float fKerning) const {
1244   return GetVerticalTextSize(fKerning) * m_pCurStates->m_TextHorzScale;
1245 }
1246 
GetVerticalTextSize(float fKerning) const1247 float CPDF_StreamContentParser::GetVerticalTextSize(float fKerning) const {
1248   return fKerning * m_pCurStates->m_TextState.GetFontSize() / 1000;
1249 }
1250 
GetCurrentStreamIndex()1251 int32_t CPDF_StreamContentParser::GetCurrentStreamIndex() {
1252   auto it =
1253       std::upper_bound(m_StreamStartOffsets.begin(), m_StreamStartOffsets.end(),
1254                        m_pSyntax->GetPos() + m_StartParseOffset);
1255   return (it - m_StreamStartOffsets.begin()) - 1;
1256 }
1257 
Handle_ShowText()1258 void CPDF_StreamContentParser::Handle_ShowText() {
1259   ByteString str = GetString(0);
1260   if (!str.IsEmpty())
1261     AddTextObject(&str, 0, std::vector<float>(), 1);
1262 }
1263 
Handle_ShowText_Positioning()1264 void CPDF_StreamContentParser::Handle_ShowText_Positioning() {
1265   CPDF_Array* pArray = ToArray(GetObject(0));
1266   if (!pArray)
1267     return;
1268 
1269   size_t n = pArray->size();
1270   size_t nsegs = 0;
1271   for (size_t i = 0; i < n; i++) {
1272     const CPDF_Object* pDirectObject = pArray->GetDirectObjectAt(i);
1273     if (pDirectObject && pDirectObject->IsString())
1274       nsegs++;
1275   }
1276   if (nsegs == 0) {
1277     for (size_t i = 0; i < n; i++) {
1278       float fKerning = pArray->GetNumberAt(i);
1279       if (fKerning != 0)
1280         m_pCurStates->m_TextPos.x -= GetHorizontalTextSize(fKerning);
1281     }
1282     return;
1283   }
1284   std::vector<ByteString> strs(nsegs);
1285   std::vector<float> kernings(nsegs);
1286   size_t iSegment = 0;
1287   float fInitKerning = 0;
1288   for (size_t i = 0; i < n; i++) {
1289     CPDF_Object* pObj = pArray->GetDirectObjectAt(i);
1290     if (!pObj)
1291       continue;
1292 
1293     if (pObj->IsString()) {
1294       ByteString str = pObj->GetString();
1295       if (str.IsEmpty())
1296         continue;
1297       strs[iSegment] = std::move(str);
1298       kernings[iSegment++] = 0;
1299     } else {
1300       float num = pObj->GetNumber();
1301       if (iSegment == 0)
1302         fInitKerning += num;
1303       else
1304         kernings[iSegment - 1] += num;
1305     }
1306   }
1307   AddTextObject(strs.data(), fInitKerning, kernings, iSegment);
1308 }
1309 
Handle_SetTextLeading()1310 void CPDF_StreamContentParser::Handle_SetTextLeading() {
1311   m_pCurStates->m_TextLeading = GetNumber(0);
1312 }
1313 
Handle_SetTextMatrix()1314 void CPDF_StreamContentParser::Handle_SetTextMatrix() {
1315   m_pCurStates->m_TextMatrix =
1316       CFX_Matrix(GetNumber(5), GetNumber(4), GetNumber(3), GetNumber(2),
1317                  GetNumber(1), GetNumber(0));
1318   OnChangeTextMatrix();
1319   m_pCurStates->m_TextPos = CFX_PointF();
1320   m_pCurStates->m_TextLinePos = CFX_PointF();
1321 }
1322 
OnChangeTextMatrix()1323 void CPDF_StreamContentParser::OnChangeTextMatrix() {
1324   CFX_Matrix text_matrix(m_pCurStates->m_TextHorzScale, 0.0f, 0.0f, 1.0f, 0.0f,
1325                          0.0f);
1326   text_matrix.Concat(m_pCurStates->m_TextMatrix);
1327   text_matrix.Concat(m_pCurStates->m_CTM);
1328   text_matrix.Concat(m_mtContentToUser);
1329   float* pTextMatrix = m_pCurStates->m_TextState.GetMutableMatrix();
1330   pTextMatrix[0] = text_matrix.a;
1331   pTextMatrix[1] = text_matrix.c;
1332   pTextMatrix[2] = text_matrix.b;
1333   pTextMatrix[3] = text_matrix.d;
1334 }
1335 
Handle_SetTextRenderMode()1336 void CPDF_StreamContentParser::Handle_SetTextRenderMode() {
1337   TextRenderingMode mode;
1338   if (SetTextRenderingModeFromInt(GetInteger(0), &mode))
1339     m_pCurStates->m_TextState.SetTextMode(mode);
1340 }
1341 
Handle_SetTextRise()1342 void CPDF_StreamContentParser::Handle_SetTextRise() {
1343   m_pCurStates->m_TextRise = GetNumber(0);
1344 }
1345 
Handle_SetWordSpace()1346 void CPDF_StreamContentParser::Handle_SetWordSpace() {
1347   m_pCurStates->m_TextState.SetWordSpace(GetNumber(0));
1348 }
1349 
Handle_SetHorzScale()1350 void CPDF_StreamContentParser::Handle_SetHorzScale() {
1351   if (m_ParamCount != 1) {
1352     return;
1353   }
1354   m_pCurStates->m_TextHorzScale = GetNumber(0) / 100;
1355   OnChangeTextMatrix();
1356 }
1357 
Handle_MoveToNextLine()1358 void CPDF_StreamContentParser::Handle_MoveToNextLine() {
1359   m_pCurStates->m_TextLinePos.y -= m_pCurStates->m_TextLeading;
1360   m_pCurStates->m_TextPos = m_pCurStates->m_TextLinePos;
1361 }
1362 
Handle_CurveTo_23()1363 void CPDF_StreamContentParser::Handle_CurveTo_23() {
1364   AddPathPoint(m_PathCurrentX, m_PathCurrentY, FXPT_TYPE::BezierTo, false);
1365   AddPathPoint(GetNumber(3), GetNumber(2), FXPT_TYPE::BezierTo, false);
1366   AddPathPoint(GetNumber(1), GetNumber(0), FXPT_TYPE::BezierTo, false);
1367 }
1368 
Handle_SetLineWidth()1369 void CPDF_StreamContentParser::Handle_SetLineWidth() {
1370   m_pCurStates->m_GraphState.SetLineWidth(GetNumber(0));
1371 }
1372 
Handle_Clip()1373 void CPDF_StreamContentParser::Handle_Clip() {
1374   m_PathClipType = CFX_FillRenderOptions::FillType::kWinding;
1375 }
1376 
Handle_EOClip()1377 void CPDF_StreamContentParser::Handle_EOClip() {
1378   m_PathClipType = CFX_FillRenderOptions::FillType::kEvenOdd;
1379 }
1380 
Handle_CurveTo_13()1381 void CPDF_StreamContentParser::Handle_CurveTo_13() {
1382   AddPathPoint(GetNumber(3), GetNumber(2), FXPT_TYPE::BezierTo, false);
1383   AddPathPoint(GetNumber(1), GetNumber(0), FXPT_TYPE::BezierTo, false);
1384   AddPathPoint(GetNumber(1), GetNumber(0), FXPT_TYPE::BezierTo, false);
1385 }
1386 
Handle_NextLineShowText()1387 void CPDF_StreamContentParser::Handle_NextLineShowText() {
1388   Handle_MoveToNextLine();
1389   Handle_ShowText();
1390 }
1391 
Handle_NextLineShowText_Space()1392 void CPDF_StreamContentParser::Handle_NextLineShowText_Space() {
1393   m_pCurStates->m_TextState.SetWordSpace(GetNumber(2));
1394   m_pCurStates->m_TextState.SetCharSpace(GetNumber(1));
1395   Handle_NextLineShowText();
1396 }
1397 
Handle_Invalid()1398 void CPDF_StreamContentParser::Handle_Invalid() {}
1399 
AddPathPoint(float x,float y,FXPT_TYPE type,bool close)1400 void CPDF_StreamContentParser::AddPathPoint(float x,
1401                                             float y,
1402                                             FXPT_TYPE type,
1403                                             bool close) {
1404   // If the path point is the same move as the previous one and neither of them
1405   // closes the path, then just skip it.
1406   if (!close && type == FXPT_TYPE::MoveTo && !m_PathPoints.empty() &&
1407       !m_PathPoints.back().m_CloseFigure &&
1408       m_PathPoints.back().m_Type == type && m_PathCurrentX == x &&
1409       m_PathCurrentY == y) {
1410     return;
1411   }
1412 
1413   m_PathCurrentX = x;
1414   m_PathCurrentY = y;
1415   if (type == FXPT_TYPE::MoveTo && !close) {
1416     m_PathStartX = x;
1417     m_PathStartY = y;
1418     if (!m_PathPoints.empty() &&
1419         m_PathPoints.back().IsTypeAndOpen(FXPT_TYPE::MoveTo)) {
1420       m_PathPoints.back().m_Point = CFX_PointF(x, y);
1421       return;
1422     }
1423   } else if (m_PathPoints.empty()) {
1424     return;
1425   }
1426   m_PathPoints.push_back(FX_PATHPOINT(CFX_PointF(x, y), type, close));
1427 }
1428 
AddPathObject(CFX_FillRenderOptions::FillType fill_type,bool bStroke)1429 void CPDF_StreamContentParser::AddPathObject(
1430     CFX_FillRenderOptions::FillType fill_type,
1431     bool bStroke) {
1432   std::vector<FX_PATHPOINT> path_points;
1433   path_points.swap(m_PathPoints);
1434   CFX_FillRenderOptions::FillType path_clip_type = m_PathClipType;
1435   m_PathClipType = CFX_FillRenderOptions::FillType::kNoFill;
1436 
1437   if (path_points.empty())
1438     return;
1439 
1440   if (path_points.size() == 1) {
1441     if (path_clip_type != CFX_FillRenderOptions::FillType::kNoFill) {
1442       CPDF_Path path;
1443       path.AppendRect(0, 0, 0, 0);
1444       m_pCurStates->m_ClipPath.AppendPath(
1445           path, CFX_FillRenderOptions::FillType::kWinding, true);
1446     }
1447     return;
1448   }
1449 
1450   if (path_points.back().IsTypeAndOpen(FXPT_TYPE::MoveTo))
1451     path_points.pop_back();
1452 
1453   CPDF_Path path;
1454   for (const auto& point : path_points) {
1455     if (point.m_CloseFigure)
1456       path.AppendPointAndClose(point.m_Point, point.m_Type);
1457     else
1458       path.AppendPoint(point.m_Point, point.m_Type);
1459   }
1460 
1461   CFX_Matrix matrix = m_pCurStates->m_CTM * m_mtContentToUser;
1462   if (bStroke || fill_type != CFX_FillRenderOptions::FillType::kNoFill) {
1463     auto pPathObj = std::make_unique<CPDF_PathObject>(GetCurrentStreamIndex());
1464     pPathObj->set_stroke(bStroke);
1465     pPathObj->set_filltype(fill_type);
1466     pPathObj->path() = path;
1467     pPathObj->set_matrix(matrix);
1468     SetGraphicStates(pPathObj.get(), true, false, true);
1469     pPathObj->CalcBoundingBox();
1470     m_pObjectHolder->AppendPageObject(std::move(pPathObj));
1471   }
1472   if (path_clip_type != CFX_FillRenderOptions::FillType::kNoFill) {
1473     if (!matrix.IsIdentity())
1474       path.Transform(matrix);
1475     m_pCurStates->m_ClipPath.AppendPath(path, path_clip_type, true);
1476   }
1477 }
1478 
Parse(const uint8_t * pData,uint32_t dwSize,uint32_t start_offset,uint32_t max_cost,const std::vector<uint32_t> & stream_start_offsets)1479 uint32_t CPDF_StreamContentParser::Parse(
1480     const uint8_t* pData,
1481     uint32_t dwSize,
1482     uint32_t start_offset,
1483     uint32_t max_cost,
1484     const std::vector<uint32_t>& stream_start_offsets) {
1485   ASSERT(start_offset < dwSize);
1486 
1487   // Parsing will be done from |pDataStart|, for at most |size_left| bytes.
1488   const uint8_t* pDataStart = pData + start_offset;
1489   uint32_t size_left = dwSize - start_offset;
1490 
1491   m_StartParseOffset = start_offset;
1492 
1493   if (m_ParsedSet->size() > kMaxFormLevel ||
1494       pdfium::Contains(*m_ParsedSet, pDataStart)) {
1495     return size_left;
1496   }
1497 
1498   m_StreamStartOffsets = stream_start_offsets;
1499 
1500   pdfium::ScopedSetInsertion<const uint8_t*> scopedInsert(m_ParsedSet.Get(),
1501                                                           pDataStart);
1502 
1503   uint32_t init_obj_count = m_pObjectHolder->GetPageObjectCount();
1504   CPDF_StreamParser syntax(pdfium::make_span(pDataStart, size_left),
1505                            m_pDocument->GetByteStringPool());
1506   AutoNuller<UnownedPtr<CPDF_StreamParser>> auto_clearer(&m_pSyntax);
1507   m_pSyntax = &syntax;
1508   while (1) {
1509     uint32_t cost = m_pObjectHolder->GetPageObjectCount() - init_obj_count;
1510     if (max_cost && cost >= max_cost) {
1511       break;
1512     }
1513     switch (syntax.ParseNextElement()) {
1514       case CPDF_StreamParser::EndOfData:
1515         return m_pSyntax->GetPos();
1516       case CPDF_StreamParser::Keyword:
1517         OnOperator(syntax.GetWord());
1518         ClearAllParams();
1519         break;
1520       case CPDF_StreamParser::Number:
1521         AddNumberParam(syntax.GetWord());
1522         break;
1523       case CPDF_StreamParser::Name: {
1524         auto word = syntax.GetWord();
1525         AddNameParam(word.Last(word.GetLength() - 1));
1526         break;
1527       }
1528       default:
1529         AddObjectParam(syntax.GetObject());
1530     }
1531   }
1532   return m_pSyntax->GetPos();
1533 }
1534 
ParsePathObject()1535 void CPDF_StreamContentParser::ParsePathObject() {
1536   float params[6] = {};
1537   int nParams = 0;
1538   int last_pos = m_pSyntax->GetPos();
1539   while (1) {
1540     CPDF_StreamParser::SyntaxType type = m_pSyntax->ParseNextElement();
1541     bool bProcessed = true;
1542     switch (type) {
1543       case CPDF_StreamParser::EndOfData:
1544         return;
1545       case CPDF_StreamParser::Keyword: {
1546         ByteStringView strc = m_pSyntax->GetWord();
1547         int len = strc.GetLength();
1548         if (len == 1) {
1549           switch (strc[0]) {
1550             case kPathOperatorSubpath:
1551               AddPathPoint(params[0], params[1], FXPT_TYPE::MoveTo, false);
1552               nParams = 0;
1553               break;
1554             case kPathOperatorLine:
1555               AddPathPoint(params[0], params[1], FXPT_TYPE::LineTo, false);
1556               nParams = 0;
1557               break;
1558             case kPathOperatorCubicBezier1:
1559               AddPathPoint(params[0], params[1], FXPT_TYPE::BezierTo, false);
1560               AddPathPoint(params[2], params[3], FXPT_TYPE::BezierTo, false);
1561               AddPathPoint(params[4], params[5], FXPT_TYPE::BezierTo, false);
1562               nParams = 0;
1563               break;
1564             case kPathOperatorCubicBezier2:
1565               AddPathPoint(m_PathCurrentX, m_PathCurrentY, FXPT_TYPE::BezierTo,
1566                            false);
1567               AddPathPoint(params[0], params[1], FXPT_TYPE::BezierTo, false);
1568               AddPathPoint(params[2], params[3], FXPT_TYPE::BezierTo, false);
1569               nParams = 0;
1570               break;
1571             case kPathOperatorCubicBezier3:
1572               AddPathPoint(params[0], params[1], FXPT_TYPE::BezierTo, false);
1573               AddPathPoint(params[2], params[3], FXPT_TYPE::BezierTo, false);
1574               AddPathPoint(params[2], params[3], FXPT_TYPE::BezierTo, false);
1575               nParams = 0;
1576               break;
1577             case kPathOperatorClosePath:
1578               Handle_ClosePath();
1579               nParams = 0;
1580               break;
1581             default:
1582               bProcessed = false;
1583               break;
1584           }
1585         } else if (len == 2) {
1586           if (strc[0] == kPathOperatorRectangle[0] &&
1587               strc[1] == kPathOperatorRectangle[1]) {
1588             AddPathRect(params[0], params[1], params[2], params[3]);
1589             nParams = 0;
1590           } else {
1591             bProcessed = false;
1592           }
1593         } else {
1594           bProcessed = false;
1595         }
1596         if (bProcessed) {
1597           last_pos = m_pSyntax->GetPos();
1598         }
1599         break;
1600       }
1601       case CPDF_StreamParser::Number: {
1602         if (nParams == 6)
1603           break;
1604 
1605         FX_Number number(m_pSyntax->GetWord());
1606         params[nParams++] = number.GetFloat();
1607         break;
1608       }
1609       default:
1610         bProcessed = false;
1611     }
1612     if (!bProcessed) {
1613       m_pSyntax->SetPos(last_pos);
1614       return;
1615     }
1616   }
1617 }
1618 
1619 // static
FindKeyAbbreviationForTesting(ByteStringView abbr)1620 ByteStringView CPDF_StreamContentParser::FindKeyAbbreviationForTesting(
1621     ByteStringView abbr) {
1622   return FindFullName(kInlineKeyAbbr, pdfium::size(kInlineKeyAbbr), abbr);
1623 }
1624 
1625 // static
FindValueAbbreviationForTesting(ByteStringView abbr)1626 ByteStringView CPDF_StreamContentParser::FindValueAbbreviationForTesting(
1627     ByteStringView abbr) {
1628   return FindFullName(kInlineValueAbbr, pdfium::size(kInlineValueAbbr), abbr);
1629 }
1630 
1631 CPDF_StreamContentParser::ContentParam::ContentParam() = default;
1632 
1633 CPDF_StreamContentParser::ContentParam::~ContentParam() = default;
1634