Clean up CFX_ImageTransformer.

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 278 matching lines @@
   if (bFlipX) {
     rect.top = width - clip.left;
     rect.bottom = width - clip.right;
   } else {
     rect.top = clip.left;
     rect.bottom = clip.right;
   }
   rect.Normalize();
   return rect;
 }
+
 CFX_DIBitmap* CFX_DIBSource::TransformTo(const CFX_Matrix* pDestMatrix,
                                          int& result_left,
                                          int& result_top,
                                          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_ImageTransformer transformer(this, pDestMatrix, flags, pDestClip);
+  transformer.Start();
+  transformer.Continue(nullptr);
+  result_left = transformer.result().left;
+  result_top = transformer.result().top;
+  return transformer.DetachBitmap().release();
 }
 
 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)
     clip_rect.Intersect(*pClip);
 
   if (clip_rect.IsEmpty())
     return nullptr;
 
   if (dest_width == m_Width && dest_height == m_Height)
     return Clone(&clip_rect);
 
   CFX_BitmapStorer storer;
   CFX_ImageStretcher stretcher(&storer, this, dest_width, dest_height,
                                clip_rect, flags);
   if (stretcher.Start())
     stretcher.Continue(nullptr);
-  return storer.Detach();
+  return storer.Detach().release();
 }
 
-CFX_ImageTransformer::CFX_ImageTransformer() {
-  m_Status = 0;
-  m_pMatrix = NULL;
-}
+CFX_ImageTransformer::CFX_ImageTransformer(const CFX_DIBSource* pSrc,
+                                           const CFX_Matrix* pMatrix,
+                                           int flags,
+                                           const FX_RECT* pClip)
+    : m_pSrc(pSrc),
+      m_pMatrix(pMatrix),
+      m_pClip(pClip),
+      m_Flags(flags),
+      m_Status(0) {}
 
 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_BOOL CFX_ImageTransformer::Start() {
+  CFX_FloatRect unit_rect = m_pMatrix->GetUnitRect();
   FX_RECT result_rect = unit_rect.GetClosestRect();
   FX_RECT result_clip = result_rect;
-  if (pDestClip)
-    result_clip.Intersect(*pDestClip);
+  if (m_pClip)
+    result_clip.Intersect(*m_pClip);
 
   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) {
+  m_result = result_clip;
+  if (FXSYS_fabs(m_pMatrix->a) < FXSYS_fabs(m_pMatrix->b) / 20 &&
+      FXSYS_fabs(m_pMatrix->d) < FXSYS_fabs(m_pMatrix->c) / 20 &&
+      FXSYS_fabs(m_pMatrix->a) < 0.5f && FXSYS_fabs(m_pMatrix->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.reset(new CFX_ImageStretcher(&m_Storer, pSrc, dest_height,
-                                             dest_width, result_clip, flags));
+                                    m_pMatrix->c > 0, m_pMatrix->b < 0);
+    m_Stretcher.reset(new CFX_ImageStretcher(&m_Storer, m_pSrc, dest_height,
+                                             dest_width, result_clip, m_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);
+  if (FXSYS_fabs(m_pMatrix->b) < FIX16_005 &&
+      FXSYS_fabs(m_pMatrix->c) < FIX16_005) {
+    int dest_width = m_pMatrix->a > 0 ? (int)FXSYS_ceil(m_pMatrix->a)
+                                      : (int)FXSYS_floor(m_pMatrix->a);
+    int dest_height = m_pMatrix->d > 0 ? (int)-FXSYS_ceil(m_pMatrix->d)
+                                       : (int)-FXSYS_floor(m_pMatrix->d);
     result_clip.Offset(-result_rect.left, -result_rect.top);
-    m_Stretcher.reset(new CFX_ImageStretcher(&m_Storer, pSrc, dest_width,
-                                             dest_height, result_clip, flags));
+    m_Stretcher.reset(new CFX_ImageStretcher(
+        &m_Storer, m_pSrc, dest_width, dest_height, result_clip, m_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));
+  int stretch_width = (int)FXSYS_ceil(FXSYS_sqrt2(m_pMatrix->a, m_pMatrix->b));
+  int stretch_height = (int)FXSYS_ceil(FXSYS_sqrt2(m_pMatrix->c, m_pMatrix->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_pMatrix->a / stretch_width, m_pMatrix->b / stretch_width,
+      m_pMatrix->c / stretch_height, m_pMatrix->d / stretch_height,
+      m_pMatrix->e, m_pMatrix->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.reset(new CFX_ImageStretcher(
-      &m_Storer, pSrc, stretch_width, stretch_height, m_StretchClip, flags));
+  m_Stretcher.reset(new CFX_ImageStretcher(&m_Storer, m_pSrc, stretch_width,
+                                           stretch_height, m_StretchClip,
+                                           m_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))
       return TRUE;
 
     if (m_Storer.GetBitmap()) {
-      m_Storer.Replace(
+      std::unique_ptr<CFX_DIBitmap> swapped(
           m_Storer.GetBitmap()->SwapXY(m_pMatrix->c > 0, m_pMatrix->b < 0));
+      m_Storer.Replace(std::move(swapped));
     }
     return FALSE;
   }
 
   if (m_Status == 2)
     return m_Stretcher->Continue(pPause);
 
   if (m_Status != 3)
     return FALSE;
 
   if (m_Stretcher->Continue(pPause))
     return TRUE;
 
   int stretch_width = m_StretchClip.Width();
   int stretch_height = m_StretchClip.Height();
   if (!m_Storer.GetBitmap())
     return FALSE;
 
   const uint8_t* stretch_buf = m_Storer.GetBitmap()->GetBuffer();
   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();
   std::unique_ptr<CFX_DIBitmap> pTransformed(new CFX_DIBitmap);
   FXDIB_Format transformF = GetTransformedFormat(m_Stretcher->source());
-  if (!pTransformed->Create(m_ResultWidth, m_ResultHeight, transformF))
+  if (!pTransformed->Create(m_result.Width(), m_result.Height(), transformF))
     return FALSE;
 
   pTransformed->Clear(0);
   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));
+  CFX_Matrix result2stretch(1.0f, 0.0f, 0.0f, 1.0f, (FX_FLOAT)(m_result.left),
+                            (FX_FLOAT)(m_result.top));
   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);
-      for (int row = 0; row < m_ResultHeight; row++) {
+      for (int row = 0; row < m_result.Height(); row++) {
         uint8_t* dest_pos_mask =
             (uint8_t*)pTransformed->m_pAlphaMask->GetScanline(row);
-        for (int col = 0; col < m_ResultWidth; col++) {
+        for (int col = 0; col < m_result.Width(); col++) {
           int src_col_l, src_row_l, res_x, res_y;
           result2stretch_fix.Transform(col, row, src_col_l, src_row_l, res_x,
                                        res_y);
           if (src_col_l >= 0 && src_col_l <= stretch_width && src_row_l >= 0 &&
               src_row_l <= stretch_height) {
             if (src_col_l == stretch_width) {
               src_col_l--;
             }
             if (src_row_l == stretch_height) {
               src_row_l--;
@@ skipping 10 matching lines @@
             int row_offset_r = src_row_r * stretch_pitch_mask;
             *dest_pos_mask =
                 bilinear_interpol(stretch_buf_mask, row_offset_l, row_offset_r,
                                   src_col_l, src_col_r, res_x, res_y, 1, 0);
           }
           dest_pos_mask++;
         }
       }
     } else if (m_Flags & FXDIB_BICUBIC_INTERPOL) {
       CFX_BilinearMatrix result2stretch_fix(result2stretch, 8);
-      for (int row = 0; row < m_ResultHeight; row++) {
+      for (int row = 0; row < m_result.Height(); row++) {
         uint8_t* dest_pos_mask =
             (uint8_t*)pTransformed->m_pAlphaMask->GetScanline(row);
-        for (int col = 0; col < m_ResultWidth; col++) {
+        for (int col = 0; col < m_result.Width(); col++) {
           int src_col_l, src_row_l, res_x, res_y;
           result2stretch_fix.Transform(col, row, src_col_l, src_row_l, res_x,
                                        res_y);
           if (src_col_l >= 0 && src_col_l <= stretch_width && src_row_l >= 0 &&
               src_row_l <= stretch_height) {
             int pos_pixel[8];
             int u_w[4], v_w[4];
             if (src_col_l == stretch_width) {
               src_col_l--;
             }
             if (src_row_l == stretch_height) {
               src_row_l--;
             }
             bicubic_get_pos_weight(pos_pixel, u_w, v_w, src_col_l, src_row_l,
                                    res_x, res_y, stretch_width, stretch_height);
             *dest_pos_mask =
                 bicubic_interpol(stretch_buf_mask, stretch_pitch_mask,
                                  pos_pixel, u_w, v_w, res_x, res_y, 1, 0);
           }
           dest_pos_mask++;
         }
       }
     } else {
       CPDF_FixedMatrix result2stretch_fix(result2stretch, 8);
-      for (int row = 0; row < m_ResultHeight; row++) {
+      for (int row = 0; row < m_result.Height(); row++) {
         uint8_t* dest_pos_mask =
             (uint8_t*)pTransformed->m_pAlphaMask->GetScanline(row);
-        for (int col = 0; col < m_ResultWidth; col++) {
+        for (int col = 0; col < m_result.Width(); col++) {
           int src_col, src_row;
           result2stretch_fix.Transform(col, row, src_col, src_row);
           if (src_col >= 0 && src_col <= stretch_width && src_row >= 0 &&
               src_row <= stretch_height) {
             if (src_col == stretch_width) {
               src_col--;
             }
             if (src_row == stretch_height) {
               src_row--;
             }
             *dest_pos_mask =
                 stretch_buf_mask[src_row * stretch_pitch_mask + src_col];
           }
           dest_pos_mask++;
         }
       }
     }
   }
   if (m_Storer.GetBitmap()->IsAlphaMask()) {
     if (!(m_Flags & FXDIB_DOWNSAMPLE) && !(m_Flags & FXDIB_BICUBIC_INTERPOL)) {
       CFX_BilinearMatrix result2stretch_fix(result2stretch, 8);
-      for (int row = 0; row < m_ResultHeight; row++) {
+      for (int row = 0; row < m_result.Height(); row++) {
         uint8_t* dest_scan = (uint8_t*)pTransformed->GetScanline(row);
-        for (int col = 0; col < m_ResultWidth; col++) {
+        for (int col = 0; col < m_result.Width(); col++) {
           int src_col_l, src_row_l, res_x, res_y;
           result2stretch_fix.Transform(col, row, src_col_l, src_row_l, res_x,
                                        res_y);
           if (src_col_l >= 0 && src_col_l <= stretch_width && src_row_l >= 0 &&
               src_row_l <= stretch_height) {
             if (src_col_l == stretch_width) {
               src_col_l--;
             }
             if (src_row_l == stretch_height) {
               src_row_l--;
@@ skipping 10 matching lines @@
             int row_offset_r = src_row_r * stretch_pitch;
             *dest_scan =
                 bilinear_interpol(stretch_buf, row_offset_l, row_offset_r,
                                   src_col_l, src_col_r, res_x, res_y, 1, 0);
           }
           dest_scan++;
         }
       }
     } else if (m_Flags & FXDIB_BICUBIC_INTERPOL) {
       CFX_BilinearMatrix result2stretch_fix(result2stretch, 8);
-      for (int row = 0; row < m_ResultHeight; row++) {
+      for (int row = 0; row < m_result.Height(); row++) {
         uint8_t* dest_scan = (uint8_t*)pTransformed->GetScanline(row);
-        for (int col = 0; col < m_ResultWidth; col++) {
+        for (int col = 0; col < m_result.Width(); col++) {
           int src_col_l, src_row_l, res_x, res_y;
           result2stretch_fix.Transform(col, row, src_col_l, src_row_l, res_x,
                                        res_y);
           if (src_col_l >= 0 && src_col_l <= stretch_width && src_row_l >= 0 &&
               src_row_l <= stretch_height) {
             int pos_pixel[8];
             int u_w[4], v_w[4];
             if (src_col_l == stretch_width) {
               src_col_l--;
             }
             if (src_row_l == stretch_height) {
               src_row_l--;
             }
             bicubic_get_pos_weight(pos_pixel, u_w, v_w, src_col_l, src_row_l,
                                    res_x, res_y, stretch_width, stretch_height);
             *dest_scan = bicubic_interpol(stretch_buf, stretch_pitch, pos_pixel,
                                           u_w, v_w, res_x, res_y, 1, 0);
           }
           dest_scan++;
         }
       }
     } else {
       CPDF_FixedMatrix result2stretch_fix(result2stretch, 8);
-      for (int row = 0; row < m_ResultHeight; row++) {
+      for (int row = 0; row < m_result.Height(); row++) {
         uint8_t* dest_scan = (uint8_t*)pTransformed->GetScanline(row);
-        for (int col = 0; col < m_ResultWidth; col++) {
+        for (int col = 0; col < m_result.Width(); col++) {
           int src_col, src_row;
           result2stretch_fix.Transform(col, row, src_col, src_row);
           if (src_col >= 0 && src_col <= stretch_width && src_row >= 0 &&
               src_row <= stretch_height) {
             if (src_col == stretch_width) {
               src_col--;
             }
             if (src_row == stretch_height) {
               src_row--;
             }
@@ skipping 22 matching lines @@
           }
         } else {
           for (int i = 0; i < 256; i++) {
             argb[i] = 0xff000000 | (i * 0x010101);
           }
         }
       }
       if (!(m_Flags & FXDIB_DOWNSAMPLE) &&
           !(m_Flags & FXDIB_BICUBIC_INTERPOL)) {
         CFX_BilinearMatrix result2stretch_fix(result2stretch, 8);
-        for (int row = 0; row < m_ResultHeight; row++) {
+        for (int row = 0; row < m_result.Height(); row++) {
           uint8_t* dest_pos = (uint8_t*)pTransformed->GetScanline(row);
-          for (int col = 0; col < m_ResultWidth; col++) {
+          for (int col = 0; col < m_result.Width(); col++) {
             int src_col_l, src_row_l, res_x, res_y;
             result2stretch_fix.Transform(col, row, src_col_l, src_row_l, res_x,
                                          res_y);
             if (src_col_l >= 0 && src_col_l <= stretch_width &&
                 src_row_l >= 0 && src_row_l <= stretch_height) {
               if (src_col_l == stretch_width) {
                 src_col_l--;
               }
               if (src_row_l == stretch_height) {
                 src_row_l--;
@@ skipping 17 matching lines @@
                 dest_pos[2] = (uint8_t)(r_bgra_cmyk >> 8);
               } else {
                 *(uint32_t*)dest_pos = r_bgra_cmyk;
               }
             }
             dest_pos += destBpp;
           }
         }
       } else if (m_Flags & FXDIB_BICUBIC_INTERPOL) {
         CFX_BilinearMatrix result2stretch_fix(result2stretch, 8);
-        for (int row = 0; row < m_ResultHeight; row++) {
+        for (int row = 0; row < m_result.Height(); row++) {
           uint8_t* dest_pos = (uint8_t*)pTransformed->GetScanline(row);
-          for (int col = 0; col < m_ResultWidth; col++) {
+          for (int col = 0; col < m_result.Width(); col++) {
             int src_col_l, src_row_l, res_x, res_y;
             result2stretch_fix.Transform(col, row, src_col_l, src_row_l, res_x,
                                          res_y);
             if (src_col_l >= 0 && src_col_l <= stretch_width &&
                 src_row_l >= 0 && src_row_l <= stretch_height) {
               int pos_pixel[8];
               int u_w[4], v_w[4];
               if (src_col_l == stretch_width) {
                 src_col_l--;
               }
@@ skipping 12 matching lines @@
                 dest_pos[2] = (uint8_t)(r_bgra_cmyk >> 8);
               } else {
                 *(uint32_t*)dest_pos = r_bgra_cmyk;
               }
             }
             dest_pos += destBpp;
           }
         }
       } else {
         CPDF_FixedMatrix result2stretch_fix(result2stretch, 8);
-        for (int row = 0; row < m_ResultHeight; row++) {
+        for (int row = 0; row < m_result.Height(); row++) {
           uint8_t* dest_pos = (uint8_t*)pTransformed->GetScanline(row);
-          for (int col = 0; col < m_ResultWidth; col++) {
+          for (int col = 0; col < m_result.Width(); col++) {
             int src_col, src_row;
             result2stretch_fix.Transform(col, row, src_col, src_row);
             if (src_col >= 0 && src_col <= stretch_width && src_row >= 0 &&
                 src_row <= stretch_height) {
               if (src_col == stretch_width) {
                 src_col--;
               }
               if (src_row == stretch_height) {
                 src_row--;
               }
@@ skipping 10 matching lines @@
             dest_pos += destBpp;
           }
         }
       }
     } else {
       FX_BOOL bHasAlpha = m_Storer.GetBitmap()->HasAlpha();
       int destBpp = pTransformed->GetBPP() / 8;
       if (!(m_Flags & FXDIB_DOWNSAMPLE) &&
           !(m_Flags & FXDIB_BICUBIC_INTERPOL)) {
         CFX_BilinearMatrix result2stretch_fix(result2stretch, 8);
-        for (int row = 0; row < m_ResultHeight; row++) {
+        for (int row = 0; row < m_result.Height(); row++) {
           uint8_t* dest_pos = (uint8_t*)pTransformed->GetScanline(row);
-          for (int col = 0; col < m_ResultWidth; col++) {
+          for (int col = 0; col < m_result.Width(); col++) {
             int src_col_l, src_row_l, res_x, res_y, r_pos_k_r = 0;
             result2stretch_fix.Transform(col, row, src_col_l, src_row_l, res_x,
                                          res_y);
             if (src_col_l >= 0 && src_col_l <= stretch_width &&
                 src_row_l >= 0 && src_row_l <= stretch_height) {
               if (src_col_l == stretch_width) {
                 src_col_l--;
               }
               if (src_row_l == stretch_height) {
                 src_row_l--;
@@ skipping 53 matching lines @@
                       FXARGB_MAKE(r_pos_k_r, r_pos_red_y_r, r_pos_green_m_r,
                                   r_pos_blue_c_r));
                 }
               }
             }
             dest_pos += destBpp;
           }
         }
       } else if (m_Flags & FXDIB_BICUBIC_INTERPOL) {
         CFX_BilinearMatrix result2stretch_fix(result2stretch, 8);
-        for (int row = 0; row < m_ResultHeight; row++) {
+        for (int row = 0; row < m_result.Height(); row++) {
           uint8_t* dest_pos = (uint8_t*)pTransformed->GetScanline(row);
-          for (int col = 0; col < m_ResultWidth; col++) {
+          for (int col = 0; col < m_result.Width(); col++) {
             int src_col_l, src_row_l, res_x, res_y, r_pos_k_r = 0;
             result2stretch_fix.Transform(col, row, src_col_l, src_row_l, res_x,
                                          res_y);
             if (src_col_l >= 0 && src_col_l <= stretch_width &&
                 src_row_l >= 0 && src_row_l <= stretch_height) {
               int pos_pixel[8];
               int u_w[4], v_w[4];
               if (src_col_l == stretch_width) {
                 src_col_l--;
               }
@@ skipping 48 matching lines @@
                       FXARGB_MAKE(r_pos_k_r, r_pos_red_y_r, r_pos_green_m_r,
                                   r_pos_blue_c_r));
                 }
               }
             }
             dest_pos += destBpp;
           }
         }
       } else {
         CPDF_FixedMatrix result2stretch_fix(result2stretch, 8);
-        for (int row = 0; row < m_ResultHeight; row++) {
+        for (int row = 0; row < m_result.Height(); row++) {
           uint8_t* dest_pos = (uint8_t*)pTransformed->GetScanline(row);
-          for (int col = 0; col < m_ResultWidth; col++) {
+          for (int col = 0; col < m_result.Width(); col++) {
             int src_col, src_row;
             result2stretch_fix.Transform(col, row, src_col, src_row);
             if (src_col >= 0 && src_col <= stretch_width && src_row >= 0 &&
                 src_row <= stretch_height) {
               if (src_col == stretch_width) {
                 src_col--;
               }
               if (src_row == stretch_height) {
                 src_row--;
               }
@@ skipping 22 matching lines @@
                       FXARGB_MAKE(0xff, src_pos[2], src_pos[1], src_pos[0]));
                 }
               }
             }
             dest_pos += destBpp;
           }
         }
       }
     }
   }
-  m_Storer.Replace(pTransformed.release());
+  m_Storer.Replace(std::move(pTransformed));
   return FALSE;
 }
+
+std::unique_ptr<CFX_DIBitmap> CFX_ImageTransformer::DetachBitmap() {
+  return m_Storer.Detach();
+}