Merge to XFA: Remove CFX_AffineMatrix/CPDF_Matrix

core/src/fpdfapi/fpdf_render/fpdf_render.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 "render_int.h"
 
 #include "core/include/fpdfapi/fpdf_module.h"
 #include "core/include/fpdfapi/fpdf_render.h"
@@ skipping 163 matching lines @@
       m_bLoadMask(FALSE),
       m_pType3Char(nullptr),
       m_T3FillColor(0),
       m_curBlend(FXDIB_BLEND_NORMAL) {}
 
 CPDF_RenderStatus::~CPDF_RenderStatus() {
 }
 
 FX_BOOL CPDF_RenderStatus::Initialize(CPDF_RenderContext* pContext,
                                       CFX_RenderDevice* pDevice,
-                                      const CFX_AffineMatrix* pDeviceMatrix,
+                                      const CFX_Matrix* pDeviceMatrix,
                                       const CPDF_PageObject* pStopObj,
                                       const CPDF_RenderStatus* pParentState,
                                       const CPDF_GraphicStates* pInitialStates,
                                       const CPDF_RenderOptions* pOptions,
                                       int transparency,
                                       FX_BOOL bDropObjects,
                                       CPDF_Dictionary* pFormResource,
                                       FX_BOOL bStdCS,
                                       CPDF_Type3Char* pType3Char,
                                       FX_ARGB fill_color,
@@ skipping 39 matching lines @@
       }
     }
   } else {
     m_InitialStates.DefaultStates();
   }
   m_pObjectRenderer.reset();
   m_Transparency = transparency;
   return TRUE;
 }
 void CPDF_RenderStatus::RenderObjectList(const CPDF_PageObjects* pObjs,
-                                         const CFX_AffineMatrix* pObj2Device) {
+                                         const CFX_Matrix* pObj2Device) {
   CFX_FloatRect clip_rect = m_pDevice->GetClipBox();
-  CFX_AffineMatrix device2object;
+  CFX_Matrix device2object;
   device2object.SetReverse(*pObj2Device);
   device2object.TransformRect(clip_rect);
   int index = 0;
   FX_POSITION pos = pObjs->GetFirstObjectPosition();
   while (pos) {
     index++;
     CPDF_PageObject* pCurObj = pObjs->GetNextObject(pos);
     if (pCurObj == m_pStopObj) {
       m_bStopped = TRUE;
       return;
     }
     if (!pCurObj) {
       continue;
     }
     if (pCurObj == NULL || pCurObj->m_Left > clip_rect.right ||
         pCurObj->m_Right < clip_rect.left ||
         pCurObj->m_Bottom > clip_rect.top ||
         pCurObj->m_Top < clip_rect.bottom) {
       continue;
     }
     RenderSingleObject(pCurObj, pObj2Device);
     if (m_bStopped) {
       return;
     }
   }
 }
-void CPDF_RenderStatus::RenderSingleObject(
-    const CPDF_PageObject* pObj,
-    const CFX_AffineMatrix* pObj2Device) {
+void CPDF_RenderStatus::RenderSingleObject(const CPDF_PageObject* pObj,
+                                           const CFX_Matrix* pObj2Device) {
   CFX_AutoRestorer<int> restorer(&s_CurrentRecursionDepth);
   if (++s_CurrentRecursionDepth > kRenderMaxRecursionDepth) {
     return;
   }
   m_pCurObj = pObj;
   if (m_Options.m_pOCContext && pObj->m_ContentMark.NotNull()) {
     if (!m_Options.m_pOCContext->CheckObjectVisible(pObj)) {
       return;
     }
   }
   ProcessClipPath(pObj->m_ClipPath, pObj2Device);
   if (ProcessTransparency(pObj, pObj2Device)) {
     return;
   }
   ProcessObjectNoClip(pObj, pObj2Device);
 }
 
-FX_BOOL CPDF_RenderStatus::ContinueSingleObject(
-    const CPDF_PageObject* pObj,
-    const CFX_AffineMatrix* pObj2Device,
-    IFX_Pause* pPause) {
+FX_BOOL CPDF_RenderStatus::ContinueSingleObject(const CPDF_PageObject* pObj,
+                                                const CFX_Matrix* pObj2Device,
+                                                IFX_Pause* pPause) {
   if (m_pObjectRenderer) {
     if (m_pObjectRenderer->Continue(pPause))
       return TRUE;
 
     if (!m_pObjectRenderer->m_Result)
       DrawObjWithBackground(pObj, pObj2Device);
     m_pObjectRenderer.reset();
     return FALSE;
   }
 
@@ skipping 21 matching lines @@
   ProcessObjectNoClip(pObj, pObj2Device);
   return FALSE;
 }
 
 IPDF_ObjectRenderer* IPDF_ObjectRenderer::Create(int type) {
   if (type != PDFPAGE_IMAGE) {
     return NULL;
   }
   return new CPDF_ImageRenderer;
 }
-FX_BOOL CPDF_RenderStatus::GetObjectClippedRect(
-    const CPDF_PageObject* pObj,
-    const CFX_AffineMatrix* pObj2Device,
-    FX_BOOL bLogical,
-    FX_RECT& rect) const {
+FX_BOOL CPDF_RenderStatus::GetObjectClippedRect(const CPDF_PageObject* pObj,
+                                                const CFX_Matrix* pObj2Device,
+                                                FX_BOOL bLogical,
+                                                FX_RECT& rect) const {
   rect = pObj->GetBBox(pObj2Device);
   FX_RECT rtClip = m_pDevice->GetClipBox();
   if (!bLogical) {
     CFX_Matrix dCTM = m_pDevice->GetCTM();
     FX_FLOAT a = FXSYS_fabs(dCTM.a);
     FX_FLOAT d = FXSYS_fabs(dCTM.d);
     if (a != 1.0f || d != 1.0f) {
       rect.right = rect.left + (int32_t)FXSYS_ceil((FX_FLOAT)rect.Width() * a);
       rect.bottom = rect.top + (int32_t)FXSYS_ceil((FX_FLOAT)rect.Height() * d);
       rtClip.right =
           rtClip.left + (int32_t)FXSYS_ceil((FX_FLOAT)rtClip.Width() * a);
       rtClip.bottom =
           rtClip.top + (int32_t)FXSYS_ceil((FX_FLOAT)rtClip.Height() * d);
     }
   }
   rect.Intersect(rtClip);
   return rect.IsEmpty();
 }
 void CPDF_RenderStatus::DitherObjectArea(const CPDF_PageObject* pObj,
-                                         const CFX_AffineMatrix* pObj2Device) {
+                                         const CFX_Matrix* pObj2Device) {
   CFX_DIBitmap* pBitmap = m_pDevice->GetBitmap();
   if (pBitmap == NULL) {
     return;
   }
   FX_RECT rect;
   if (GetObjectClippedRect(pObj, pObj2Device, FALSE, rect)) {
     return;
   }
   if (m_DitherBits == 2) {
     static FX_ARGB pal[4] = {0, 85, 170, 255};
     pBitmap->DitherFS(pal, 4, &rect);
   } else if (m_DitherBits == 3) {
     static FX_ARGB pal[8] = {0, 36, 73, 109, 146, 182, 219, 255};
     pBitmap->DitherFS(pal, 8, &rect);
   } else if (m_DitherBits == 4) {
     static FX_ARGB pal[16] = {0,   17,  34,  51,  68,  85,  102, 119,
                               136, 153, 170, 187, 204, 221, 238, 255};
     pBitmap->DitherFS(pal, 16, &rect);
   }
 }
-void CPDF_RenderStatus::ProcessObjectNoClip(
-    const CPDF_PageObject* pObj,
-    const CFX_AffineMatrix* pObj2Device) {
+void CPDF_RenderStatus::ProcessObjectNoClip(const CPDF_PageObject* pObj,
+                                            const CFX_Matrix* pObj2Device) {
   FX_BOOL bRet = FALSE;
   switch (pObj->m_Type) {
     case PDFPAGE_TEXT:
       bRet = ProcessText((CPDF_TextObject*)pObj, pObj2Device, NULL);
       break;
     case PDFPAGE_PATH:
       bRet = ProcessPath((CPDF_PathObject*)pObj, pObj2Device);
       break;
     case PDFPAGE_IMAGE:
       bRet = ProcessImage((CPDF_ImageObject*)pObj, pObj2Device);
       break;
     case PDFPAGE_SHADING:
       bRet = ProcessShading((CPDF_ShadingObject*)pObj, pObj2Device);
       break;
     case PDFPAGE_FORM:
       bRet = ProcessForm((CPDF_FormObject*)pObj, pObj2Device);
       break;
   }
   if (!bRet) {
     DrawObjWithBackground(pObj, pObj2Device);
   }
 }
-FX_BOOL CPDF_RenderStatus::DrawObjWithBlend(
-    const CPDF_PageObject* pObj,
-    const CFX_AffineMatrix* pObj2Device) {
+FX_BOOL CPDF_RenderStatus::DrawObjWithBlend(const CPDF_PageObject* pObj,
+                                            const CFX_Matrix* pObj2Device) {
   FX_BOOL bRet = FALSE;
   switch (pObj->m_Type) {
     case PDFPAGE_PATH:
       bRet = ProcessPath((CPDF_PathObject*)pObj, pObj2Device);
       break;
     case PDFPAGE_IMAGE:
       bRet = ProcessImage((CPDF_ImageObject*)pObj, pObj2Device);
       break;
     case PDFPAGE_FORM:
       bRet = ProcessForm((CPDF_FormObject*)pObj, pObj2Device);
       break;
   }
   return bRet;
 }
 void CPDF_RenderStatus::GetScaledMatrix(CFX_Matrix& matrix) const {
   CFX_Matrix dCTM = m_pDevice->GetCTM();
   matrix.a *= FXSYS_fabs(dCTM.a);
   matrix.d *= FXSYS_fabs(dCTM.d);
 }
-void CPDF_RenderStatus::DrawObjWithBackground(
-    const CPDF_PageObject* pObj,
-    const CFX_AffineMatrix* pObj2Device) {
+void CPDF_RenderStatus::DrawObjWithBackground(const CPDF_PageObject* pObj,
+                                              const CFX_Matrix* pObj2Device) {
   FX_RECT rect;
   if (GetObjectClippedRect(pObj, pObj2Device, FALSE, rect)) {
     return;
   }
   int res = 300;
   if (pObj->m_Type == PDFPAGE_IMAGE &&
       m_pDevice->GetDeviceCaps(FXDC_DEVICE_CLASS) == FXDC_PRINTER) {
     res = 0;
   }
   CPDF_ScaledRenderBuffer buffer;
   if (!buffer.Initialize(m_pContext, m_pDevice, &rect, pObj, &m_Options, res)) {
     return;
   }
-  CFX_AffineMatrix matrix = *pObj2Device;
+  CFX_Matrix matrix = *pObj2Device;
   matrix.Concat(*buffer.GetMatrix());
   GetScaledMatrix(matrix);
   CPDF_Dictionary* pFormResource = NULL;
   if (pObj->m_Type == PDFPAGE_FORM) {
     CPDF_FormObject* pFormObj = (CPDF_FormObject*)pObj;
     if (pFormObj->m_pForm && pFormObj->m_pForm->m_pFormDict) {
       pFormResource =
           pFormObj->m_pForm->m_pFormDict->GetDict(FX_BSTRC("Resources"));
     }
   }
   CPDF_RenderStatus status;
   status.Initialize(m_pContext, buffer.GetDevice(), buffer.GetMatrix(), NULL,
                     NULL, NULL, &m_Options, m_Transparency, m_bDropObjects,
                     pFormResource);
   status.RenderSingleObject(pObj, &matrix);
   buffer.OutputToDevice();
 }
 FX_BOOL CPDF_RenderStatus::ProcessForm(CPDF_FormObject* pFormObj,
-                                       const CFX_AffineMatrix* pObj2Device) {
+                                       const CFX_Matrix* pObj2Device) {
   CPDF_Dictionary* pOC =
       pFormObj->m_pForm->m_pFormDict->GetDict(FX_BSTRC("OC"));
   if (pOC && m_Options.m_pOCContext &&
       !m_Options.m_pOCContext->CheckOCGVisible(pOC)) {
     return TRUE;
   }
-  CFX_AffineMatrix matrix = pFormObj->m_FormMatrix;
+  CFX_Matrix matrix = pFormObj->m_FormMatrix;
   matrix.Concat(*pObj2Device);
   CPDF_Dictionary* pResources = NULL;
   if (pFormObj->m_pForm && pFormObj->m_pForm->m_pFormDict) {
     pResources = pFormObj->m_pForm->m_pFormDict->GetDict(FX_BSTRC("Resources"));
   }
   CPDF_RenderStatus status;
   status.Initialize(m_pContext, m_pDevice, NULL, m_pStopObj, this, pFormObj,
                     &m_Options, m_Transparency, m_bDropObjects, pResources,
                     FALSE);
   status.m_curBlend = m_curBlend;
   m_pDevice->SaveState();
   status.RenderObjectList(pFormObj->m_pForm, &matrix);
   m_bStopped = status.m_bStopped;
   m_pDevice->RestoreState();
   return TRUE;
 }
-FX_BOOL IsAvailableMatrix(const CFX_AffineMatrix& matrix) {
+FX_BOOL IsAvailableMatrix(const CFX_Matrix& matrix) {
   if (matrix.a == 0 || matrix.d == 0) {
     return matrix.b != 0 && matrix.c != 0;
   }
   if (matrix.b == 0 || matrix.c == 0) {
     return matrix.a != 0 && matrix.d != 0;
   }
   return TRUE;
 }
 FX_BOOL CPDF_RenderStatus::ProcessPath(CPDF_PathObject* pPathObj,
-                                       const CFX_AffineMatrix* pObj2Device) {
+                                       const CFX_Matrix* pObj2Device) {
   int FillType = pPathObj->m_FillType;
   FX_BOOL bStroke = pPathObj->m_bStroke;
   ProcessPathPattern(pPathObj, pObj2Device, FillType, bStroke);
   if (FillType == 0 && !bStroke) {
     return TRUE;
   }
   FX_DWORD fill_argb = 0;
   if (FillType) {
     fill_argb = GetFillArgb(pPathObj);
   }
   FX_DWORD stroke_argb = 0;
   if (bStroke) {
     stroke_argb = GetStrokeArgb(pPathObj);
   }
-  CFX_AffineMatrix path_matrix = pPathObj->m_Matrix;
+  CFX_Matrix path_matrix = pPathObj->m_Matrix;
   path_matrix.Concat(*pObj2Device);
   if (!IsAvailableMatrix(path_matrix)) {
     return TRUE;
   }
   if (FillType && (m_Options.m_Flags & RENDER_RECT_AA)) {
     FillType |= FXFILL_RECT_AA;
   }
   if (m_Options.m_Flags & RENDER_FILL_FULLCOVER) {
     FillType |= FXFILL_FULLCOVER;
   }
@@ skipping 91 matching lines @@
       if (pGeneralData->m_pTransferFunc) {
         rgb = pGeneralData->m_pTransferFunc->TranslateColor(rgb);
       }
     }
   } else {
     alpha = 255;
   }
   return m_Options.TranslateColor(ArgbEncode(alpha, rgb));
 }
 void CPDF_RenderStatus::ProcessClipPath(CPDF_ClipPath ClipPath,
-                                        const CFX_AffineMatrix* pObj2Device) {
+                                        const CFX_Matrix* pObj2Device) {
   if (ClipPath.IsNull()) {
     if (!m_LastClipPath.IsNull()) {
       m_pDevice->RestoreState(TRUE);
       m_LastClipPath.SetNull();
     }
     return;
   }
   if (m_LastClipPath == ClipPath)
     return;
 
@@ skipping 39 matching lines @@
 
     int fill_mode = FXFILL_WINDING;
     if (m_Options.m_Flags & RENDER_NOTEXTSMOOTH)
       fill_mode |= FXFILL_NOPATHSMOOTH;
     m_pDevice->SetClip_PathFill(pTextClippingPath.get(), nullptr, fill_mode);
     pTextClippingPath.reset();
   }
 }
 
 void CPDF_RenderStatus::DrawClipPath(CPDF_ClipPath ClipPath,
-                                     const CFX_AffineMatrix* pObj2Device) {
+                                     const CFX_Matrix* pObj2Device) {
   if (ClipPath.IsNull()) {
     return;
   }
   int fill_mode = 0;
   if (m_Options.m_Flags & RENDER_NOPATHSMOOTH) {
     fill_mode |= FXFILL_NOPATHSMOOTH;
   }
   int nClipPath = ClipPath.GetPathCount();
   int i;
   for (i = 0; i < nClipPath; i++) {
     const CFX_PathData* pPathData = ClipPath.GetPath(i);
     if (pPathData == NULL) {
       continue;
     }
     CFX_GraphStateData stroke_state;
     if (m_Options.m_Flags & RENDER_THINLINE) {
       stroke_state.m_LineWidth = 0;
     }
     m_pDevice->DrawPath(pPathData, pObj2Device, &stroke_state, 0, 0xffff0000,
                         fill_mode);
   }
 }
 FX_BOOL CPDF_RenderStatus::SelectClipPath(CPDF_PathObject* pPathObj,
-                                          const CFX_AffineMatrix* pObj2Device,
+                                          const CFX_Matrix* pObj2Device,
                                           FX_BOOL bStroke) {
-  CFX_AffineMatrix path_matrix = pPathObj->m_Matrix;
+  CFX_Matrix path_matrix = pPathObj->m_Matrix;
   path_matrix.Concat(*pObj2Device);
   if (bStroke) {
     CFX_GraphStateData graphState(*pPathObj->m_GraphState);
     if (m_Options.m_Flags & RENDER_THINLINE) {
       graphState.m_LineWidth = 0;
     }
     return m_pDevice->SetClip_PathStroke(pPathObj->m_Path, &path_matrix,
                                          &graphState);
   }
   int fill_mode = pPathObj->m_FillType;
   if (m_Options.m_Flags & RENDER_NOPATHSMOOTH) {
     fill_mode |= FXFILL_NOPATHSMOOTH;
   }
   return m_pDevice->SetClip_PathFill(pPathObj->m_Path, &path_matrix, fill_mode);
 }
-FX_BOOL CPDF_RenderStatus::ProcessTransparency(
-    const CPDF_PageObject* pPageObj,
-    const CFX_AffineMatrix* pObj2Device) {
+FX_BOOL CPDF_RenderStatus::ProcessTransparency(const CPDF_PageObject* pPageObj,
+                                               const CFX_Matrix* pObj2Device) {
   const CPDF_GeneralStateData* pGeneralState = pPageObj->m_GeneralState;
   int blend_type =
       pGeneralState ? pGeneralState->m_BlendType : FXDIB_BLEND_NORMAL;
   if (blend_type == FXDIB_BLEND_UNSUPPORTED) {
     return TRUE;
   }
   CPDF_Dictionary* pSMaskDict =
       pGeneralState ? ToDictionary(pGeneralState->m_pSoftMask) : NULL;
   if (pSMaskDict) {
     if (pPageObj->m_Type == PDFPAGE_IMAGE &&
@@ skipping 90 matching lines @@
     if (!m_pDevice->CreateCompatibleBitmap(oriDevice.get(), width, height))
       return TRUE;
 
     m_pDevice->GetDIBits(oriDevice.get(), rect.left, rect.top);
   }
   if (!bitmap_device.Create(width, height, FXDIB_Argb, 0, oriDevice.get()))
     return TRUE;
 
   CFX_DIBitmap* bitmap = bitmap_device.GetBitmap();
   bitmap->Clear(0);
-  CFX_AffineMatrix new_matrix = *pObj2Device;
+  CFX_Matrix new_matrix = *pObj2Device;
   new_matrix.TranslateI(-rect.left, -rect.top);
   new_matrix.Scale(scaleX, scaleY);
   nonstd::unique_ptr<CFX_DIBitmap> pTextMask;
   if (bTextClip) {
     pTextMask.reset(new CFX_DIBitmap);
     if (!pTextMask->Create(width, height, FXDIB_8bppMask))
       return TRUE;
 
     pTextMask->Clear(0);
     CFX_FxgeDevice text_device;
     text_device.Attach(pTextMask.get());
     for (FX_DWORD i = 0; i < pPageObj->m_ClipPath.GetTextCount(); i++) {
       CPDF_TextObject* textobj = pPageObj->m_ClipPath.GetText(i);
       if (textobj == NULL) {
         break;
       }
-      CFX_AffineMatrix text_matrix;
+      CFX_Matrix text_matrix;
       textobj->GetTextMatrix(&text_matrix);
       CPDF_TextRenderer::DrawTextPath(
           &text_device, textobj->m_nChars, textobj->m_pCharCodes,
           textobj->m_pCharPos, textobj->m_TextState.GetFont(),
           textobj->m_TextState.GetFontSize(), &text_matrix, &new_matrix,
           textobj->m_GraphState, (FX_ARGB)-1, 0, NULL);
     }
   }
   CPDF_RenderStatus bitmap_render;
   bitmap_render.Initialize(m_pContext, &bitmap_device, NULL, m_pStopObj, NULL,
                            NULL, &m_Options, 0, m_bDropObjects, pFormResource,
                            TRUE);
   bitmap_render.ProcessObjectNoClip(pPageObj, &new_matrix);
   m_bStopped = bitmap_render.m_bStopped;
   if (pSMaskDict) {
-    CFX_AffineMatrix smask_matrix;
+    CFX_Matrix smask_matrix;
     FXSYS_memcpy(&smask_matrix, pGeneralState->m_SMaskMatrix,
                  sizeof smask_matrix);
     smask_matrix.Concat(*pObj2Device);
     nonstd::unique_ptr<CFX_DIBSource> pSMaskSource(
         LoadSMask(pSMaskDict, &rect, &smask_matrix));
     if (pSMaskSource)
       bitmap->MultiplyAlpha(pSMaskSource.get());
   }
   if (pTextMask) {
     bitmap->MultiplyAlpha(pTextMask.get());
@@ skipping 38 matching lines @@
   if (pBackdrop->HasAlpha())
     bNeedDraw = !(m_pDevice->GetRenderCaps() & FXRC_ALPHA_OUTPUT);
   else
     bNeedDraw = !(m_pDevice->GetRenderCaps() & FXRC_GET_BITS);
 
   if (!bNeedDraw) {
     m_pDevice->GetDIBits(pBackdrop.get(), left, top);
     return pBackdrop.release();
   }
 
-  CFX_AffineMatrix FinalMatrix = m_DeviceMatrix;
+  CFX_Matrix FinalMatrix = m_DeviceMatrix;
   FinalMatrix.TranslateI(-left, -top);
   FinalMatrix.Scale(scaleX, scaleY);
   pBackdrop->Clear(pBackdrop->HasAlpha() ? 0 : 0xffffffff);
   CFX_FxgeDevice device;
   device.Attach(pBackdrop.get());
   m_pContext->Render(&device, pObj, &m_Options, &FinalMatrix);
   return pBackdrop.release();
 }
 
 void CPDF_RenderContext::GetBackground(CFX_DIBitmap* pBuffer,
                                        const CPDF_PageObject* pObj,
                                        const CPDF_RenderOptions* pOptions,
-                                       CFX_AffineMatrix* pFinalMatrix) {
+                                       CFX_Matrix* pFinalMatrix) {
   CFX_FxgeDevice device;
   device.Attach(pBuffer);
 
   FX_RECT rect(0, 0, device.GetWidth(), device.GetHeight());
   device.FillRect(&rect, 0xffffffff);
   Render(&device, pObj, pOptions, pFinalMatrix);
 }
 CPDF_GraphicStates* CPDF_RenderStatus::CloneObjStates(
     const CPDF_GraphicStates* pSrcStates,
     FX_BOOL bStroke) {
@@ skipping 30 matching lines @@
   m_bFirstLayer = bFirstLayer;
 }
 CPDF_RenderContext::~CPDF_RenderContext() {}
 void CPDF_RenderContext::Clear() {
   m_pDocument = NULL;
   m_pPageResources = NULL;
   m_pPageCache = NULL;
   m_bFirstLayer = TRUE;
   m_ContentList.RemoveAll();
 }
-void CPDF_RenderContext::AppendObjectList(
-    CPDF_PageObjects* pObjs,
-    const CFX_AffineMatrix* pObject2Device) {
+void CPDF_RenderContext::AppendObjectList(CPDF_PageObjects* pObjs,
+                                          const CFX_Matrix* pObject2Device) {
   _PDF_RenderItem* pItem = m_ContentList.AddSpace();
   pItem->m_pObjectList = pObjs;
   if (pObject2Device) {
     pItem->m_Matrix = *pObject2Device;
   } else {
     pItem->m_Matrix.SetIdentity();
   }
 }
 void CPDF_RenderContext::Render(CFX_RenderDevice* pDevice,
                                 const CPDF_RenderOptions* pOptions,
-                                const CFX_AffineMatrix* pLastMatrix) {
+                                const CFX_Matrix* pLastMatrix) {
   Render(pDevice, NULL, pOptions, pLastMatrix);
 }
 void CPDF_RenderContext::Render(CFX_RenderDevice* pDevice,
                                 const CPDF_PageObject* pStopObj,
                                 const CPDF_RenderOptions* pOptions,
-                                const CFX_AffineMatrix* pLastMatrix) {
+                                const CFX_Matrix* pLastMatrix) {
   int count = m_ContentList.GetSize();
   for (int j = 0; j < count; j++) {
     pDevice->SaveState();
     _PDF_RenderItem* pItem = m_ContentList.GetDataPtr(j);
     if (pLastMatrix) {
-      CFX_AffineMatrix FinalMatrix = pItem->m_Matrix;
+      CFX_Matrix FinalMatrix = pItem->m_Matrix;
       FinalMatrix.Concat(*pLastMatrix);
       CPDF_RenderStatus status;
       status.Initialize(this, pDevice, pLastMatrix, pStopObj, NULL, NULL,
                         pOptions, pItem->m_pObjectList->m_Transparency, FALSE,
                         NULL);
       status.RenderObjectList(pItem->m_pObjectList, &FinalMatrix);
       if (status.m_Options.m_Flags & RENDER_LIMITEDIMAGECACHE) {
         m_pPageCache->CacheOptimization(status.m_Options.m_dwLimitCacheSize);
       }
       if (status.m_bStopped) {
@@ skipping 11 matching lines @@
       if (status.m_bStopped) {
         pDevice->RestoreState();
         break;
       }
     }
     pDevice->RestoreState();
   }
 }
 void CPDF_RenderContext::DrawObjectList(CFX_RenderDevice* pDevice,
                                         CPDF_PageObjects* pObjs,
-                                        const CFX_AffineMatrix* pObject2Device,
+                                        const CFX_Matrix* pObject2Device,
                                         const CPDF_RenderOptions* pOptions) {
   AppendObjectList(pObjs, pObject2Device);
   Render(pDevice, pOptions);
 }
 
 CPDF_ProgressiveRenderer::CPDF_ProgressiveRenderer(
     CPDF_RenderContext* pContext,
     CFX_RenderDevice* pDevice,
     const CPDF_RenderOptions* pOptions)
     : m_Status(Ready),
@@ skipping 58 matching lines @@
     }
     if (!m_pRenderStatus) {
       m_ObjectPos = pItem->m_pObjectList->GetFirstObjectPosition();
       m_ObjectIndex = 0;
       m_pRenderStatus.reset(new CPDF_RenderStatus());
       m_pRenderStatus->Initialize(
           m_pContext, m_pDevice, NULL, NULL, NULL, NULL, m_pOptions,
           pItem->m_pObjectList->m_Transparency, FALSE, NULL);
       m_pDevice->SaveState();
       m_ClipRect = m_pDevice->GetClipBox();
-      CFX_AffineMatrix device2object;
+      CFX_Matrix device2object;
       device2object.SetReverse(pItem->m_Matrix);
       device2object.TransformRect(m_ClipRect);
     }
     int objs_to_go = CPDF_ModuleMgr::Get()
                          ->GetRenderModule()
                          ->GetConfig()
                          ->m_RenderStepLimit;
     while (m_ObjectPos) {
       CPDF_PageObject* pCurObj = pItem->m_pObjectList->GetObjectAt(m_ObjectPos);
       if (pCurObj && pCurObj->m_Left <= m_ClipRect.right &&
@@ skipping 282 matching lines @@
         item.GetParamType() == CPDF_ContentMarkItem::PropertiesDict) {
       CPDF_Dictionary* pOCG =
           ToDictionary(static_cast<CPDF_Object*>(item.GetParam()));
       if (!CheckOCGVisible(pOCG)) {
         return FALSE;
       }
     }
   }
   return TRUE;
 }