Add CPDF_ImageObject::GetImage().

core/fpdfapi/fpdf_render/fpdf_render_loadimage.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/fpdfapi/fpdf_render/render_int.h"
 
 #include <algorithm>
 #include <memory>
@@ skipping 10 matching lines @@
 #include "core/fxcodec/include/fx_codec.h"
 #include "core/fxcrt/include/fx_safe_types.h"
 #include "core/fxge/include/fx_ge.h"
 
 namespace {
 
 unsigned int GetBits8(const uint8_t* pData, uint64_t bitpos, size_t nbits) {
   ASSERT(nbits == 1 || nbits == 2 || nbits == 4 || nbits == 8 || nbits == 16);
   ASSERT((bitpos & (nbits - 1)) == 0);
   unsigned int byte = pData[bitpos / 8];
-  if (nbits == 8) {
+  if (nbits == 8)
     return byte;
-  } else if (nbits == 16) {
+
+  if (nbits == 16)
     return byte * 256 + pData[bitpos / 8 + 1];
-  }
 
   return (byte >> (8 - nbits - (bitpos % 8))) & ((1 << nbits) - 1);
 }
 
 FX_SAFE_UINT32 CalculatePitch8(uint32_t bpc, uint32_t components, int width) {
   FX_SAFE_UINT32 pitch = bpc;
   pitch *= components;
   pitch *= width;
   pitch += 7;
   pitch /= 8;
@@ skipping 1439 matching lines @@
                                       CPDF_RenderStatus* pRenderStatus,
                                       int32_t nDownsampleWidth,
                                       int32_t nDownsampleHeight) {
   m_pImageLoader = pImageLoader;
   m_pCache = pCache;
   m_pImage = const_cast<CPDF_ImageObject*>(pImage);
   m_nDownsampleWidth = nDownsampleWidth;
   m_nDownsampleHeight = nDownsampleHeight;
   FX_BOOL ret;
   if (pCache) {
-    ret = pCache->StartGetCachedBitmap(pImage->m_pImage->GetStream(), bStdCS,
-                                       GroupFamily, bLoadMask, pRenderStatus,
-                                       m_nDownsampleWidth, m_nDownsampleHeight);
-    if (!ret) {
-      m_pImageLoader->m_bCached = TRUE;
-      m_pImageLoader->m_pBitmap =
-          pCache->GetCurImageCacheEntry()->DetachBitmap();
-      m_pImageLoader->m_pMask = pCache->GetCurImageCacheEntry()->DetachMask();
-      m_pImageLoader->m_MatteColor =
-          pCache->GetCurImageCacheEntry()->m_MatteColor;
-    }
+    ret = pCache->StartGetCachedBitmap(
+        m_pImage->GetImage()->GetStream(), bStdCS, GroupFamily, bLoadMask,
+        pRenderStatus, m_nDownsampleWidth, m_nDownsampleHeight);
   } else {
-    ret = pImage->m_pImage->StartLoadDIBSource(pRenderStatus->m_pFormResource,
-                                               pRenderStatus->m_pPageResource,
-                                               bStdCS, GroupFamily, bLoadMask);
-    if (!ret) {
-      m_pImageLoader->m_bCached = FALSE;
-      m_pImageLoader->m_pBitmap = m_pImage->m_pImage->DetachBitmap();
-      m_pImageLoader->m_pMask = m_pImage->m_pImage->DetachMask();
-      m_pImageLoader->m_MatteColor = m_pImage->m_pImage->m_MatteColor;
-    }
+    ret = m_pImage->GetImage()->StartLoadDIBSource(
+        pRenderStatus->m_pFormResource, pRenderStatus->m_pPageResource, bStdCS,
+        GroupFamily, bLoadMask);
   }
+  if (!ret)
+    HandleFailure();
   return ret;
 }
 
 FX_BOOL CPDF_ImageLoaderHandle::Continue(IFX_Pause* pPause) {
-  FX_BOOL ret;
-  if (m_pCache) {
-    ret = m_pCache->Continue(pPause);
-    if (!ret) {
-      m_pImageLoader->m_bCached = TRUE;
-      m_pImageLoader->m_pBitmap =
-          m_pCache->GetCurImageCacheEntry()->DetachBitmap();
-      m_pImageLoader->m_pMask = m_pCache->GetCurImageCacheEntry()->DetachMask();
-      m_pImageLoader->m_MatteColor =
-          m_pCache->GetCurImageCacheEntry()->m_MatteColor;
-    }
-  } else {
-    ret = m_pImage->m_pImage->Continue(pPause);
-    if (!ret) {
-      m_pImageLoader->m_bCached = FALSE;
-      m_pImageLoader->m_pBitmap = m_pImage->m_pImage->DetachBitmap();
-      m_pImageLoader->m_pMask = m_pImage->m_pImage->DetachMask();
-      m_pImageLoader->m_MatteColor = m_pImage->m_pImage->m_MatteColor;
-    }
-  }
+  FX_BOOL ret = m_pCache ? m_pCache->Continue(pPause)
+                         : m_pImage->GetImage()->Continue(pPause);
+  if (!ret)
+    HandleFailure();
   return ret;
 }
 
+void CPDF_ImageLoaderHandle::HandleFailure() {
+  if (m_pCache) {
+    CPDF_ImageCacheEntry* entry = m_pCache->GetCurImageCacheEntry();
+    m_pImageLoader->m_bCached = TRUE;
+    m_pImageLoader->m_pBitmap = entry->DetachBitmap();
+    m_pImageLoader->m_pMask = entry->DetachMask();
+    m_pImageLoader->m_MatteColor = entry->m_MatteColor;
+  } else {
+    CPDF_Image* pImage = m_pImage->GetImage();
+    m_pImageLoader->m_bCached = FALSE;
+    m_pImageLoader->m_pBitmap = pImage->DetachBitmap();
+    m_pImageLoader->m_pMask = pImage->DetachMask();
+    m_pImageLoader->m_MatteColor = pImage->m_MatteColor;
+  }
+}
+
 FX_BOOL CPDF_ImageLoader::Start(
     const CPDF_ImageObject* pImage,
     CPDF_PageRenderCache* pCache,
     std::unique_ptr<CPDF_ImageLoaderHandle>* pLoadHandle,
     FX_BOOL bStdCS,
     uint32_t GroupFamily,
     FX_BOOL bLoadMask,
     CPDF_RenderStatus* pRenderStatus,
     int32_t nDownsampleWidth,
     int32_t nDownsampleHeight) {
   m_nDownsampleWidth = nDownsampleWidth;
   m_nDownsampleHeight = nDownsampleHeight;
   pLoadHandle->reset(new CPDF_ImageLoaderHandle);
   return (*pLoadHandle)
       ->Start(this, pImage, pCache, bStdCS, GroupFamily, bLoadMask,
               pRenderStatus, m_nDownsampleWidth, m_nDownsampleHeight);
 }
 
 FX_BOOL CPDF_ImageLoader::Continue(CPDF_ImageLoaderHandle* LoadHandle,
                                    IFX_Pause* pPause) {
   return LoadHandle->Continue(pPause);
 }
 
 CPDF_ImageLoader::~CPDF_ImageLoader() {
   if (!m_bCached) {
     delete m_pBitmap;
     delete m_pMask;
   }
 }