Merge to XFA: Tidy up shading patterns

core/src/fpdfapi/fpdf_page/fpdf_page_pattern.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 "pageint.h"
 
 #include "core/include/fpdfapi/fpdf_page.h"
 
 namespace {
 
 const int kSingleCoordinatePair = 1;
 const int kTensorCoordinatePairs = 16;
 const int kCoonsCoordinatePairs = 12;
 
 const int kSingleColorPerPatch = 1;
 const int kQuadColorsPerPatch = 4;
 
 ShadingType ToShadingType(int type) {
   return (type > static_cast<int>(kInvalidShading) &&
           type < static_cast<int>(kMaxShading))
              ? static_cast<ShadingType>(type)
              : kInvalidShading;
 }
 
 }  // namespace
 
-CPDF_Pattern::CPDF_Pattern(const CFX_Matrix* pParentMatrix)
-    : m_pPatternObj(NULL),
-      m_PatternType(PATTERN_TILING),
-      m_pDocument(NULL),
+CPDF_Pattern::CPDF_Pattern(PatternType type,
+                           CPDF_Document* pDoc,
+                           CPDF_Object* pObj,
+                           const CFX_Matrix* pParentMatrix)
+    : m_PatternType(type),
+      m_pDocument(pDoc),
+      m_pPatternObj(pObj),
       m_bForceClear(FALSE) {
-  if (pParentMatrix) {
+  if (pParentMatrix)
     m_ParentMatrix = *pParentMatrix;
-  }
 }
 CPDF_Pattern::~CPDF_Pattern() {}
 CPDF_TilingPattern::CPDF_TilingPattern(CPDF_Document* pDoc,
                                        CPDF_Object* pPatternObj,
                                        const CFX_Matrix* parentMatrix)
-    : CPDF_Pattern(parentMatrix) {
-  m_PatternType = PATTERN_TILING;
-  m_pPatternObj = pPatternObj;
-  m_pDocument = pDoc;
+    : CPDF_Pattern(TILING, pDoc, pPatternObj, parentMatrix) {
   CPDF_Dictionary* pDict = m_pPatternObj->GetDict();
-  ASSERT(pDict);
   m_Pattern2Form = pDict->GetMatrix("Matrix");
   m_bColored = pDict->GetInteger("PaintType") == 1;
   if (parentMatrix) {
     m_Pattern2Form.Concat(*parentMatrix);
   }
   m_pForm = NULL;
 }
 CPDF_TilingPattern::~CPDF_TilingPattern() {
   delete m_pForm;
   m_pForm = NULL;
@@ skipping 16 matching lines @@
 
   m_pForm = new CPDF_Form(m_pDocument, NULL, pStream);
   m_pForm->ParseContent(NULL, &m_ParentMatrix, NULL, NULL);
   m_BBox = pDict->GetRect("BBox");
   return TRUE;
 }
 CPDF_ShadingPattern::CPDF_ShadingPattern(CPDF_Document* pDoc,
                                          CPDF_Object* pPatternObj,
                                          FX_BOOL bShading,
                                          const CFX_Matrix* parentMatrix)
-    : CPDF_Pattern(parentMatrix) {
-  m_PatternType = PATTERN_SHADING;
-  m_pPatternObj = bShading ? NULL : pPatternObj;
-  m_pDocument = pDoc;
-  m_bShadingObj = bShading;
+    : CPDF_Pattern(SHADING,
+                   pDoc,
+                   bShading ? nullptr : pPatternObj,
+                   parentMatrix),
+      m_ShadingType(kInvalidShading),
+      m_bShadingObj(bShading),
+      m_pShadingObj(pPatternObj),
+      m_pCS(nullptr),
+      m_pCountedCS(nullptr),
+      m_nFuncs(0) {
   if (!bShading) {
     CPDF_Dictionary* pDict = m_pPatternObj->GetDict();
-    ASSERT(pDict);
     m_Pattern2Form = pDict->GetMatrix("Matrix");
     m_pShadingObj = pDict->GetElementValue("Shading");
-    if (parentMatrix) {
+    if (parentMatrix)
       m_Pattern2Form.Concat(*parentMatrix);
-    }
-  } else {
-    m_pShadingObj = pPatternObj;
   }
-  m_ShadingType = kInvalidShading;
-  m_pCS = NULL;
-  m_nFuncs = 0;
-  for (int i = 0; i < 4; i++) {
-    m_pFunctions[i] = NULL;
-  }
-  m_pCountedCS = NULL;
+  for (int i = 0; i < FX_ArraySize(m_pFunctions); ++i)
+    m_pFunctions[i] = nullptr;
 }
+
 CPDF_ShadingPattern::~CPDF_ShadingPattern() {
-  Clear();
-}
-void CPDF_ShadingPattern::Clear() {
-  for (int i = 0; i < m_nFuncs; i++) {
+  for (int i = 0; i < m_nFuncs; ++i)
     delete m_pFunctions[i];
-    m_pFunctions[i] = NULL;
-  }
+
   CPDF_ColorSpace* pCS = m_pCountedCS ? m_pCountedCS->get() : NULL;
-  if (pCS && m_pDocument) {
+  if (pCS && m_pDocument)
     m_pDocument->GetPageData()->ReleaseColorSpace(pCS->GetArray());
-  }
-  m_ShadingType = kInvalidShading;
-  m_pCS = NULL;
-  m_pCountedCS = NULL;
-  m_nFuncs = 0;
 }
 
 FX_BOOL CPDF_ShadingPattern::Load() {
   if (m_ShadingType != kInvalidShading)
     return TRUE;
 
   CPDF_Dictionary* pShadingDict =
       m_pShadingObj ? m_pShadingObj->GetDict() : NULL;
   if (!pShadingDict) {
     return FALSE;
@@ skipping 27 matching lines @@
   }
 
   m_ShadingType = ToShadingType(pShadingDict->GetInteger("ShadingType"));
 
   // We expect to have a stream if our shading type is a mesh.
   if (IsMeshShading() && !ToStream(m_pShadingObj))
     return FALSE;
 
   return TRUE;
 }
-FX_BOOL CPDF_ShadingPattern::Reload() {
-  Clear();
-  return Load();
-}
 FX_BOOL CPDF_MeshStream::Load(CPDF_Stream* pShadingStream,
                               CPDF_Function** pFuncs,
                               int nFuncs,
                               CPDF_ColorSpace* pCS) {
   m_Stream.LoadAllData(pShadingStream);
   m_BitStream.Init(m_Stream.GetData(), m_Stream.GetSize());
   m_pFuncs = pFuncs;
   m_nFuncs = nFuncs;
   m_pCS = pCS;
   CPDF_Dictionary* pDict = pShadingStream->GetDict();
@@ skipping 139 matching lines @@
       }
     }
     stream.m_BitStream.SkipBits(stream.m_nComps * stream.m_nCompBits *
                                 color_count);
     if (bGouraud)
       stream.m_BitStream.ByteAlign();
   }
   rect.Transform(pMatrix);
   return rect;
 }