Clean up CFX_ImageStretcher.

core/fxge/dib/fx_dib_transform.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/fxge/dib/dib_int.h"
 
 #include "core/fxge/include/fx_dib.h"
 
@@ skipping 291 matching lines @@
                                          uint32_t flags,
                                          const FX_RECT* pDestClip) const {
   CFX_ImageTransformer transformer;
   transformer.Start(this, pDestMatrix, flags, pDestClip);
   transformer.Continue(NULL);
   result_left = transformer.m_ResultLeft;
   result_top = transformer.m_ResultTop;
   CFX_DIBitmap* pTransformed = transformer.m_Storer.Detach();
   return pTransformed;
 }
+
 CFX_DIBitmap* CFX_DIBSource::StretchTo(int dest_width,
                                        int dest_height,
                                        uint32_t flags,
                                        const FX_RECT* pClip) const {
   FX_RECT clip_rect(0, 0, FXSYS_abs(dest_width), FXSYS_abs(dest_height));
-  if (pClip) {
+  if (pClip)
     clip_rect.Intersect(*pClip);
-  }
-  if (clip_rect.IsEmpty()) {
-    return NULL;
-  }
-  if (dest_width == m_Width && dest_height == m_Height) {
+
+  if (clip_rect.IsEmpty())
+    return nullptr;
+
+  if (dest_width == m_Width && dest_height == m_Height)
     return Clone(&clip_rect);
-  }
-  CFX_ImageStretcher stretcher;
+
   CFX_BitmapStorer storer;
-  if (stretcher.Start(&storer, this, dest_width, dest_height, clip_rect,
-                      flags)) {
-    stretcher.Continue(NULL);
-  }
+  CFX_ImageStretcher stretcher(&storer, this, dest_width, dest_height,
+                               clip_rect, flags);
+  if (stretcher.Start())
+    stretcher.Continue(nullptr);

[Tom Sepez, 2016/05/12 00:03:08]

Do we ever call this with non-nullptr?

[Lei Zhang, 2016/05/12 01:17:13]

Yes, we pass a pPause variable in sometimes. Whether that is always NULL or
not... who knows.

   return storer.Detach();
 }
+
 CFX_ImageTransformer::CFX_ImageTransformer() {
   m_Status = 0;
   m_pMatrix = NULL;
 }
+
 CFX_ImageTransformer::~CFX_ImageTransformer() {}
+
 FX_BOOL CFX_ImageTransformer::Start(const CFX_DIBSource* pSrc,
                                     const CFX_Matrix* pDestMatrix,
                                     int flags,
                                     const FX_RECT* pDestClip) {
   m_pMatrix = (CFX_Matrix*)pDestMatrix;
   CFX_FloatRect unit_rect = pDestMatrix->GetUnitRect();
   FX_RECT result_rect = unit_rect.GetClosestRect();
   FX_RECT result_clip = result_rect;
-  if (pDestClip) {
+  if (pDestClip)
     result_clip.Intersect(*pDestClip);
-  }
-  if (result_clip.IsEmpty()) {
+
+  if (result_clip.IsEmpty())
     return FALSE;
-  }
+
   m_ResultLeft = result_clip.left;
   m_ResultTop = result_clip.top;
   m_ResultWidth = result_clip.Width();
   m_ResultHeight = result_clip.Height();
   m_Flags = flags;
   if (FXSYS_fabs(pDestMatrix->a) < FXSYS_fabs(pDestMatrix->b) / 20 &&
       FXSYS_fabs(pDestMatrix->d) < FXSYS_fabs(pDestMatrix->c) / 20 &&
       FXSYS_fabs(pDestMatrix->a) < 0.5f && FXSYS_fabs(pDestMatrix->d) < 0.5f) {
     int dest_width = result_rect.Width();
     int dest_height = result_rect.Height();
     result_clip.Offset(-result_rect.left, -result_rect.top);
     result_clip = FXDIB_SwapClipBox(result_clip, dest_width, dest_height,
                                     pDestMatrix->c > 0, pDestMatrix->b < 0);
-    m_Stretcher.Start(&m_Storer, pSrc, dest_height, dest_width, result_clip,
-                      flags);
+    m_Stretcher.reset(new CFX_ImageStretcher(&m_Storer, pSrc, dest_height,
+                                             dest_width, result_clip, flags));
+    m_Stretcher->Start();
     m_Status = 1;
     return TRUE;
   }
   if (FXSYS_fabs(pDestMatrix->b) < FIX16_005 &&
       FXSYS_fabs(pDestMatrix->c) < FIX16_005) {
     int dest_width = pDestMatrix->a > 0 ? (int)FXSYS_ceil(pDestMatrix->a)
                                         : (int)FXSYS_floor(pDestMatrix->a);
     int dest_height = pDestMatrix->d > 0 ? (int)-FXSYS_ceil(pDestMatrix->d)
                                          : (int)-FXSYS_floor(pDestMatrix->d);
     result_clip.Offset(-result_rect.left, -result_rect.top);
-    m_Stretcher.Start(&m_Storer, pSrc, dest_width, dest_height, result_clip,
-                      flags);
+    m_Stretcher.reset(new CFX_ImageStretcher(&m_Storer, pSrc, dest_width,
+                                             dest_height, result_clip, flags));
+    m_Stretcher->Start();
     m_Status = 2;
     return TRUE;
   }
   int stretch_width =
       (int)FXSYS_ceil(FXSYS_sqrt2(pDestMatrix->a, pDestMatrix->b));
   int stretch_height =
       (int)FXSYS_ceil(FXSYS_sqrt2(pDestMatrix->c, pDestMatrix->d));
   CFX_Matrix stretch2dest(1.0f, 0.0f, 0.0f, -1.0f, 0.0f,
                           (FX_FLOAT)(stretch_height));
   stretch2dest.Concat(
       pDestMatrix->a / stretch_width, pDestMatrix->b / stretch_width,
       pDestMatrix->c / stretch_height, pDestMatrix->d / stretch_height,
       pDestMatrix->e, pDestMatrix->f);
   m_dest2stretch.SetReverse(stretch2dest);
   CFX_FloatRect clip_rect_f(result_clip);
   clip_rect_f.Transform(&m_dest2stretch);
   m_StretchClip = clip_rect_f.GetOutterRect();
   m_StretchClip.Intersect(0, 0, stretch_width, stretch_height);
-  m_Stretcher.Start(&m_Storer, pSrc, stretch_width, stretch_height,
-                    m_StretchClip, flags);
+  m_Stretcher.reset(new CFX_ImageStretcher(
+      &m_Storer, pSrc, stretch_width, stretch_height, m_StretchClip, flags));
+  m_Stretcher->Start();
   m_Status = 3;
   return TRUE;
 }
 
 FX_BOOL CFX_ImageTransformer::Continue(IFX_Pause* pPause) {
   if (m_Status == 1) {
-    if (m_Stretcher.Continue(pPause)) {
+    if (m_Stretcher->Continue(pPause))
       return TRUE;
-    }
+
     if (m_Storer.GetBitmap()) {
       m_Storer.Replace(
           m_Storer.GetBitmap()->SwapXY(m_pMatrix->c > 0, m_pMatrix->b < 0));
     }
     return FALSE;
   }
-  if (m_Status == 2) {
-    return m_Stretcher.Continue(pPause);
-  }
-  if (m_Status != 3) {
+
+  if (m_Status == 2)
+    return m_Stretcher->Continue(pPause);
+
+  if (m_Status != 3)
     return FALSE;
-  }
-  if (m_Stretcher.Continue(pPause)) {
+
+  if (m_Stretcher->Continue(pPause))
     return TRUE;
-  }
+
   int stretch_width = m_StretchClip.Width();
   int stretch_height = m_StretchClip.Height();
-  if (!m_Storer.GetBitmap()) {
+  if (!m_Storer.GetBitmap())
     return FALSE;
-  }
+
   const uint8_t* stretch_buf = m_Storer.GetBitmap()->GetBuffer();
-  const uint8_t* stretch_buf_mask = NULL;
-  if (m_Storer.GetBitmap()->m_pAlphaMask) {
+  const uint8_t* stretch_buf_mask = nullptr;
+  if (m_Storer.GetBitmap()->m_pAlphaMask)
     stretch_buf_mask = m_Storer.GetBitmap()->m_pAlphaMask->GetBuffer();
-  }
+
   int stretch_pitch = m_Storer.GetBitmap()->GetPitch();
-  CFX_DIBitmap* pTransformed = new CFX_DIBitmap;
-  FXDIB_Format transformF = GetTransformedFormat(m_Stretcher.m_pSource);
-  if (!pTransformed->Create(m_ResultWidth, m_ResultHeight, transformF)) {
-    delete pTransformed;
+  std::unique_ptr<CFX_DIBitmap> pTransformed(new CFX_DIBitmap);
+  FXDIB_Format transformF = GetTransformedFormat(m_Stretcher->source());
+  if (!pTransformed->Create(m_ResultWidth, m_ResultHeight, transformF))
     return FALSE;
-  }
+
   pTransformed->Clear(0);
-  if (pTransformed->m_pAlphaMask) {
+  if (pTransformed->m_pAlphaMask)
     pTransformed->m_pAlphaMask->Clear(0);
-  }
+
   CFX_Matrix result2stretch(1.0f, 0.0f, 0.0f, 1.0f, (FX_FLOAT)(m_ResultLeft),
                             (FX_FLOAT)(m_ResultTop));
   result2stretch.Concat(m_dest2stretch);
   result2stretch.TranslateI(-m_StretchClip.left, -m_StretchClip.top);
   if (!stretch_buf_mask && pTransformed->m_pAlphaMask) {
     pTransformed->m_pAlphaMask->Clear(0xff000000);
   } else if (pTransformed->m_pAlphaMask) {
     int stretch_pitch_mask = m_Storer.GetBitmap()->m_pAlphaMask->GetPitch();
     if (!(m_Flags & FXDIB_DOWNSAMPLE) && !(m_Flags & FXDIB_BICUBIC_INTERPOL)) {
       CFX_BilinearMatrix result2stretch_fix(result2stretch, 8);
@@ skipping 481 matching lines @@
                       FXARGB_MAKE(0xff, src_pos[2], src_pos[1], src_pos[0]));
                 }
               }
             }
             dest_pos += destBpp;
           }
         }
       }
     }
   }
-  m_Storer.Replace(pTransformed);
+  m_Storer.Replace(pTransformed.release());
   return FALSE;
 }