CPDF_Document::LoadPattern() and friends always have a valid matrix.

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>
 
 #include "core/fpdfapi/fpdf_edit/include/cpdf_creator.h"
 #include "core/fpdfapi/fpdf_font/cpdf_type3font.h"
 #include "core/fpdfapi/fpdf_font/include/cpdf_font.h"
 #include "core/fpdfapi/fpdf_page/cpdf_allstates.h"
+#include "core/fpdfapi/fpdf_page/cpdf_meshstream.h"
 #include "core/fpdfapi/fpdf_page/cpdf_shadingpattern.h"
 #include "core/fpdfapi/fpdf_page/include/cpdf_form.h"
 #include "core/fpdfapi/fpdf_page/include/cpdf_formobject.h"
 #include "core/fpdfapi/fpdf_page/include/cpdf_image.h"
 #include "core/fpdfapi/fpdf_page/include/cpdf_imageobject.h"
 #include "core/fpdfapi/fpdf_page/include/cpdf_pageobject.h"
 #include "core/fpdfapi/fpdf_page/include/cpdf_pathobject.h"
 #include "core/fpdfapi/fpdf_page/include/cpdf_shadingobject.h"
 #include "core/fpdfapi/fpdf_page/include/cpdf_textobject.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_array.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_dictionary.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_document.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_name.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_number.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_reference.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_stream.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_stream_acc.h"
 #include "core/fpdfapi/fpdf_parser/include/fpdf_parser_decode.h"
 
 namespace {
 
+const int kSingleCoordinatePair = 1;
+const int kTensorCoordinatePairs = 16;
+const int kCoonsCoordinatePairs = 12;
+const int kSingleColorPerPatch = 1;
+const int kQuadColorsPerPatch = 4;
+
 const char kPathOperatorSubpath = 'm';
 const char kPathOperatorLine = 'l';
 const char kPathOperatorCubicBezier1 = 'c';
 const char kPathOperatorCubicBezier2 = 'v';
 const char kPathOperatorCubicBezier3 = 'y';
 const char kPathOperatorClosePath = 'h';
 const char kPathOperatorRectangle[] = "re";
 
 struct PDF_AbbrPair {
   const FX_CHAR* abbr;
@@ skipping 37 matching lines @@
 CFX_ByteStringC PDF_FindFullName(const PDF_AbbrPair* table,
                                  size_t count,
                                  const CFX_ByteStringC& abbr) {
   auto it = std::find_if(
       table, table + count,
       [abbr](const PDF_AbbrPair& pair) { return pair.abbr == abbr; });
   return it != table + count ? CFX_ByteStringC(it->full_name)
                              : CFX_ByteStringC();
 }
 
+CFX_FloatRect GetShadingBBox(CPDF_Stream* pStream,
+                             ShadingType type,
+                             const CFX_Matrix& matrix,
+                             CPDF_Function** pFuncs,
+                             int nFuncs,
+                             CPDF_ColorSpace* pCS) {
+  if (!pStream || !pFuncs || !pCS)
+    return CFX_FloatRect(0, 0, 0, 0);
+
+  CPDF_MeshStream stream;
+  if (!stream.Load(pStream, pFuncs, nFuncs, pCS))
+    return CFX_FloatRect(0, 0, 0, 0);
+
+  CFX_FloatRect rect;
+  bool bStarted = false;
+  bool bGouraud = type == kFreeFormGouraudTriangleMeshShading ||
+                  type == kLatticeFormGouraudTriangleMeshShading;
+
+  int point_count = kSingleCoordinatePair;
+  if (type == kTensorProductPatchMeshShading)
+    point_count = kTensorCoordinatePairs;
+  else if (type == kCoonsPatchMeshShading)
+    point_count = kCoonsCoordinatePairs;
+
+  int color_count = kSingleColorPerPatch;
+  if (type == kCoonsPatchMeshShading || type == kTensorProductPatchMeshShading)
+    color_count = kQuadColorsPerPatch;
+
+  while (!stream.m_BitStream.IsEOF()) {
+    uint32_t flag = 0;
+    if (type != kLatticeFormGouraudTriangleMeshShading)
+      flag = stream.GetFlag();
+
+    if (!bGouraud && flag) {
+      point_count -= 4;
+      color_count -= 2;
+    }
+
+    for (int i = 0; i < point_count; i++) {
+      FX_FLOAT x;
+      FX_FLOAT y;
+      stream.GetCoords(x, y);
+      if (bStarted) {
+        rect.UpdateRect(x, y);
+      } else {
+        rect.InitRect(x, y);
+        bStarted = true;
+      }
+    }
+    stream.m_BitStream.SkipBits(stream.m_nComps * stream.m_nCompBits *
+                                color_count);
+    if (bGouraud)
+      stream.m_BitStream.ByteAlign();
+  }
+  rect.Transform(&matrix);
+  return rect;
+}
+
 }  // namespace
 
 CFX_ByteStringC PDF_FindKeyAbbreviationForTesting(const CFX_ByteStringC& abbr) {
   return PDF_FindFullName(PDF_InlineKeyAbbr, FX_ArraySize(PDF_InlineKeyAbbr),
                           abbr);
 }
 
 CFX_ByteStringC PDF_FindValueAbbreviationForTesting(
     const CFX_ByteStringC& abbr) {
   return PDF_FindFullName(PDF_InlineValueAbbr,
@@ skipping 14 matching lines @@
       return true;
     }
   }
   return false;
 }
 
 CPDF_StreamContentParser::CPDF_StreamContentParser(
     CPDF_Document* pDocument,
     CPDF_Dictionary* pPageResources,
     CPDF_Dictionary* pParentResources,
-    CFX_Matrix* pmtContentToUser,
+    const CFX_Matrix* pmtContentToUser,
     CPDF_PageObjectHolder* pObjHolder,
     CPDF_Dictionary* pResources,
     CFX_FloatRect* pBBox,
     CPDF_AllStates* pStates,
     int level)
     : m_pDocument(pDocument),
       m_pPageResources(pPageResources),
       m_pParentResources(pParentResources),
       m_pResources(pResources),
       m_pObjectHolder(pObjHolder),
@@ skipping 840 matching lines @@
   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);
+    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() {
   CPDF_Object* pLastParam = GetObject(0);
   if (!pLastParam) {
     return;
   }
   int nargs = m_ParamCount;
   int nvalues = nargs;
   if (pLastParam->IsName())
     nvalues--;
 
   FX_FLOAT* values = NULL;
   if (nvalues) {
     values = FX_Alloc(FX_FLOAT, nvalues);
     for (int i = 0; i < nvalues; i++) {
       values[i] = GetNumber(nargs - i - 1);
     }
   }
   if (nvalues != nargs) {
-    CPDF_Pattern* pPattern = FindPattern(GetString(0), FALSE);
+    CPDF_Pattern* pPattern = FindPattern(GetString(0), false);
     if (pPattern) {
       m_pCurStates->m_ColorState.SetStrokePattern(pPattern, values, nvalues);
     }
   } else {
     m_pCurStates->m_ColorState.SetStrokeColor(NULL, values, nvalues);
   }
   FX_Free(values);
 }
 
-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() {
-  CPDF_Pattern* pPattern = FindPattern(GetString(0), TRUE);
+  CPDF_Pattern* pPattern = FindPattern(GetString(0), true);
   if (!pPattern)
     return;
 
   CPDF_ShadingPattern* pShading = pPattern->AsShadingPattern();
   if (!pShading)
     return;
 
   if (!pShading->m_bShadingObj || !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 =
       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_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;
   m_pObjectHolder->GetPageObjectList()->push_back(std::move(pObj));
 }
 
@@ skipping 92 matching lines @@
   }
   CPDF_Object* pCSObj = FindResourceObj("ColorSpace", name);
   if (!pCSObj) {
     m_bResourceMissing = TRUE;
     return NULL;
   }
   return m_pDocument->LoadColorSpace(pCSObj);
 }
 
 CPDF_Pattern* CPDF_StreamContentParser::FindPattern(const CFX_ByteString& name,
-                                                    FX_BOOL bShading) {
+                                                    bool bShading) {
   CPDF_Object* pPattern =
       FindResourceObj(bShading ? "Shading" : "Pattern", name);
   if (!pPattern || (!pPattern->IsDictionary() && !pPattern->IsStream())) {
     m_bResourceMissing = TRUE;
-    return NULL;
+    return nullptr;
   }
   return m_pDocument->LoadPattern(pPattern, bShading,
-                                  &m_pCurStates->m_ParentMatrix);
+                                  m_pCurStates->m_ParentMatrix);
 }
 
 void CPDF_StreamContentParser::ConvertTextSpace(FX_FLOAT& x, FX_FLOAT& y) {
   m_pCurStates->m_TextMatrix.Transform(x, y, x, y);
   ConvertUserSpace(x, y);
 }
 
 void CPDF_StreamContentParser::ConvertUserSpace(FX_FLOAT& x, FX_FLOAT& y) {
   m_pCurStates->m_CTM.Transform(x, y, x, y);
   m_mtContentToUser.Transform(x, y, x, y);
@@ skipping 466 matching lines @@
         } else {
           PDF_ReplaceAbbr(pElement);
         }
       }
       break;
     }
     default:
       break;
   }
 }