Clean up CFX_ImageTransformer.

xfa/fxfa/app/xfa_ffwidget.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 "xfa/fxfa/include/xfa_ffwidget.h"
 
 #include <algorithm>
+#include <memory>
 
 #include "core/fpdfapi/fpdf_page/include/cpdf_pageobjectholder.h"
 #include "core/fxcodec/codec/include/ccodec_progressivedecoder.h"
 #include "core/fxcodec/include/fx_codec.h"
 #include "xfa/fxfa/app/xfa_textlayout.h"
 #include "xfa/fxfa/include/xfa_ffapp.h"
 #include "xfa/fxfa/include/xfa_ffdoc.h"
 #include "xfa/fxfa/include/xfa_ffdocview.h"
 #include "xfa/fxfa/include/xfa_ffpageview.h"
 #include "xfa/fxfa/parser/cxfa_corner.h"
@@ skipping 453 matching lines @@
   switch (iLineCap) {
     case XFA_ATTRIBUTEENUM_Round:
       return CFX_GraphStateData::LineCapRound;
     case XFA_ATTRIBUTEENUM_Butt:
       return CFX_GraphStateData::LineCapButt;
     default:
       break;
   }
   return CFX_GraphStateData::LineCapSquare;
 }
+
 class CXFA_ImageRenderer {
  public:
   CXFA_ImageRenderer();
   ~CXFA_ImageRenderer();
+
   FX_BOOL Start(CFX_RenderDevice* pDevice,
                 CFX_DIBSource* pDIBSource,
                 FX_ARGB bitmap_argb,
                 int bitmap_alpha,
                 const CFX_Matrix* pImage2Device,
                 uint32_t flags,
                 int blendType = FXDIB_BLEND_NORMAL);
   FX_BOOL Continue(IFX_Pause* pPause);
 
  protected:
   CFX_RenderDevice* m_pDevice;
   int m_Status;
   CFX_Matrix m_ImageMatrix;
   CFX_DIBSource* m_pDIBSource;
   CFX_DIBitmap* m_pCloneConvert;
   int m_BitmapAlpha;
   FX_ARGB m_FillArgb;
   uint32_t m_Flags;
-  CFX_ImageTransformer* m_pTransformer;
+  std::unique_ptr<CFX_ImageTransformer> m_pTransformer;
   void* m_DeviceHandle;
   int32_t m_BlendType;
   FX_BOOL m_Result;
   FX_BOOL m_bPrint;
   FX_BOOL StartDIBSource();
   void CompositeDIBitmap(CFX_DIBitmap* pDIBitmap,
                          int left,
                          int top,
                          FX_ARGB mask_argb,
                          int bitmap_alpha,
                          int blend_mode,
                          int Transparency);
 };
 CXFA_ImageRenderer::CXFA_ImageRenderer() {
   m_pDevice = NULL;
   m_Status = 0;
   m_pDIBSource = NULL;
   m_pCloneConvert = NULL;
   m_BitmapAlpha = 255;
   m_FillArgb = 0;
   m_Flags = 0;
-  m_pTransformer = NULL;
   m_DeviceHandle = NULL;
   m_BlendType = FXDIB_BLEND_NORMAL;
   m_Result = TRUE;
   m_bPrint = FALSE;
 }
 
 CXFA_ImageRenderer::~CXFA_ImageRenderer() {
   delete m_pCloneConvert;
-  delete m_pTransformer;
   if (m_DeviceHandle)
     m_pDevice->CancelDIBits(m_DeviceHandle);
 }
 
 FX_BOOL CXFA_ImageRenderer::Start(CFX_RenderDevice* pDevice,
                                   CFX_DIBSource* pDIBSource,
                                   FX_ARGB bitmap_argb,
                                   int bitmap_alpha,
                                   const CFX_Matrix* pImage2Device,
                                   uint32_t flags,
@@ skipping 34 matching lines @@
       m_pCloneConvert = m_pDIBSource->CloneConvert(FXDIB_Rgb);
       if (!m_pCloneConvert) {
         m_Result = FALSE;
         return FALSE;
       }
       pDib = m_pCloneConvert;
     }
     FX_RECT clip_box = m_pDevice->GetClipBox();
     clip_box.Intersect(image_rect);
     m_Status = 2;
-    m_pTransformer = new CFX_ImageTransformer;
-    m_pTransformer->Start(pDib, &m_ImageMatrix, m_Flags, &clip_box);
+    m_pTransformer.reset(
+        new CFX_ImageTransformer(pDib, &m_ImageMatrix, m_Flags, &clip_box));
+    m_pTransformer->Start();
     return TRUE;
   }
   if (m_ImageMatrix.a < 0) {
     dest_width = -dest_width;
   }
   if (m_ImageMatrix.d > 0) {
     dest_height = -dest_height;
   }
   int dest_left, dest_top;
   dest_left = dest_width > 0 ? image_rect.left : image_rect.right;
@@ skipping 16 matching lines @@
   if (m_bPrint && !(m_pDevice->GetRenderCaps() & FXRC_BLEND_MODE)) {
     m_Result = FALSE;
     return TRUE;
   }
   FX_RECT clip_box = m_pDevice->GetClipBox();
   FX_RECT dest_rect = clip_box;
   dest_rect.Intersect(image_rect);
   FX_RECT dest_clip(
       dest_rect.left - image_rect.left, dest_rect.top - image_rect.top,
       dest_rect.right - image_rect.left, dest_rect.bottom - image_rect.top);
-  CFX_DIBitmap* pStretched =
-      m_pDIBSource->StretchTo(dest_width, dest_height, m_Flags, &dest_clip);
+  std::unique_ptr<CFX_DIBitmap> pStretched(
+      m_pDIBSource->StretchTo(dest_width, dest_height, m_Flags, &dest_clip));
   if (pStretched) {
-    CompositeDIBitmap(pStretched, dest_rect.left, dest_rect.top, m_FillArgb,
-                      m_BitmapAlpha, m_BlendType, FALSE);
-    delete pStretched;
-    pStretched = NULL;
+    CompositeDIBitmap(pStretched.get(), dest_rect.left, dest_rect.top,
+                      m_FillArgb, m_BitmapAlpha, m_BlendType, FALSE);
   }
   return FALSE;
 }
+
 FX_BOOL CXFA_ImageRenderer::Continue(IFX_Pause* pPause) {
   if (m_Status == 2) {
-    if (m_pTransformer->Continue(pPause)) {
+    if (m_pTransformer->Continue(pPause))
       return TRUE;
+
+    std::unique_ptr<CFX_DIBitmap> pBitmap(m_pTransformer->DetachBitmap());
+    if (!pBitmap)
+      return FALSE;
+
+    if (pBitmap->IsAlphaMask()) {
+      if (m_BitmapAlpha != 255)
+        m_FillArgb = FXARGB_MUL_ALPHA(m_FillArgb, m_BitmapAlpha);
+      m_Result =
+          m_pDevice->SetBitMask(pBitmap.get(), m_pTransformer->result().left,
+                                m_pTransformer->result().top, m_FillArgb);
+    } else {
+      if (m_BitmapAlpha != 255)
+        pBitmap->MultiplyAlpha(m_BitmapAlpha);
+      m_Result =
+          m_pDevice->SetDIBits(pBitmap.get(), m_pTransformer->result().left,
+                               m_pTransformer->result().top, m_BlendType);
     }
-    CFX_DIBitmap* pBitmap = m_pTransformer->m_Storer.Detach();
-    if (pBitmap == NULL) {
-      return FALSE;
-    }
-    if (pBitmap->IsAlphaMask()) {
-      if (m_BitmapAlpha != 255) {
-        m_FillArgb = FXARGB_MUL_ALPHA(m_FillArgb, m_BitmapAlpha);
-      }
-      m_Result = m_pDevice->SetBitMask(pBitmap, m_pTransformer->m_ResultLeft,
-                                       m_pTransformer->m_ResultTop, m_FillArgb);
-    } else {
-      if (m_BitmapAlpha != 255) {
-        pBitmap->MultiplyAlpha(m_BitmapAlpha);
-      }
-      m_Result = m_pDevice->SetDIBits(pBitmap, m_pTransformer->m_ResultLeft,
-                                      m_pTransformer->m_ResultTop, m_BlendType);
-    }
-    delete pBitmap;
     return FALSE;
-  } else if (m_Status == 3) {
+  }
+  if (m_Status == 3)
     return m_pDevice->ContinueDIBits(m_DeviceHandle, pPause);
-  }
+
   return FALSE;
 }
+
 void CXFA_ImageRenderer::CompositeDIBitmap(CFX_DIBitmap* pDIBitmap,
                                            int left,
                                            int top,
                                            FX_ARGB mask_argb,
                                            int bitmap_alpha,
                                            int blend_mode,
                                            int Transparency) {
   if (pDIBitmap == NULL) {
     return;
   }
@@ skipping 1281 matching lines @@
       iType != XFA_ELEMENT_Rectangle) {
     return;
   }
   CXFA_StrokeArray strokes;
   if (!(dwFlags & XFA_DRAWBOX_ForceRound) && iType != XFA_ELEMENT_Arc) {
     box.GetStrokes(strokes);
   }
   XFA_BOX_Fill(box, strokes, pGS, rtWidget, pMatrix, dwFlags);
   XFA_BOX_Stroke(box, strokes, pGS, rtWidget, pMatrix, dwFlags);
 }