Remove ICodec_* Interfaces.

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 52 matching lines @@
 template <typename T>
 T ClampValue(T value, T max_value) {
   value = std::min(value, max_value);
   value = std::max<T>(0, value);
   return value;
 }
 
 // Wrapper class to use with std::unique_ptr for CJPX_Decoder.
 class JpxBitMapContext {
  public:
-  explicit JpxBitMapContext(ICodec_JpxModule* jpx_module)
+  explicit JpxBitMapContext(CCodec_JpxModule* jpx_module)
       : jpx_module_(jpx_module), decoder_(nullptr) {}
 
   ~JpxBitMapContext() { jpx_module_->DestroyDecoder(decoder_); }
 
   // Takes ownership of |decoder|.
   void set_decoder(CJPX_Decoder* decoder) { decoder_ = decoder; }
 
   CJPX_Decoder* decoder() { return decoder_; }
 
  private:
-  ICodec_JpxModule* const jpx_module_;  // Weak pointer.
+  CCodec_JpxModule* const jpx_module_;  // Weak pointer.
   CJPX_Decoder* decoder_;               // Decoder, owned.
 
   // Disallow evil constructors
   JpxBitMapContext(const JpxBitMapContext&);
   void operator=(const JpxBitMapContext&);
 };
 
 const int kMaxImageDimension = 0x01FFFF;
 
 }  // namespace
@@ skipping 27 matching lines @@
 CPDF_DIBSource::~CPDF_DIBSource() {
   FX_Free(m_pMaskedLine);
   FX_Free(m_pLineBuf);
   m_pCachedBitmap.reset();
   FX_Free(m_pCompData);
   CPDF_ColorSpace* pCS = m_pColorSpace;
   if (pCS && m_pDocument) {
     m_pDocument->GetPageData()->ReleaseColorSpace(pCS->GetArray());
   }
   if (m_pJbig2Context) {
-    ICodec_Jbig2Module* pJbig2Module = CPDF_ModuleMgr::Get()->GetJbig2Module();
+    CCodec_Jbig2Module* pJbig2Module = CPDF_ModuleMgr::Get()->GetJbig2Module();
     pJbig2Module->DestroyJbig2Context(m_pJbig2Context);
   }
 }
 
 CFX_DIBitmap* CPDF_DIBSource::GetBitmap() const {
   return m_pCachedBitmap ? m_pCachedBitmap.get() : Clone();
 }
 
 void CPDF_DIBSource::ReleaseBitmap(CFX_DIBitmap* pBitmap) const {
   if (pBitmap && pBitmap != m_pCachedBitmap.get()) {
@@ skipping 194 matching lines @@
   return ret;
 }
 
 int CPDF_DIBSource::ContinueLoadDIBSource(IFX_Pause* pPause) {
   FXCODEC_STATUS ret;
   if (m_Status == 1) {
     const CFX_ByteString& decoder = m_pStreamAcc->GetImageDecoder();
     if (decoder == "JPXDecode") {
       return 0;
     }
-    ICodec_Jbig2Module* pJbig2Module = CPDF_ModuleMgr::Get()->GetJbig2Module();
+    CCodec_Jbig2Module* pJbig2Module = CPDF_ModuleMgr::Get()->GetJbig2Module();
     if (!m_pJbig2Context) {
       m_pJbig2Context = pJbig2Module->CreateJbig2Context();
       if (m_pStreamAcc->GetImageParam()) {
         CPDF_Stream* pGlobals =
             m_pStreamAcc->GetImageParam()->GetStreamBy("JBIG2Globals");
         if (pGlobals) {
           m_pGlobalStream.reset(new CPDF_StreamAcc);
           m_pGlobalStream->LoadAllData(pGlobals, FALSE);
         }
       }
@@ skipping 162 matching lines @@
           pCompData[i].m_ColorKeyMin = std::max(min_num, 0);
           pCompData[i].m_ColorKeyMax = std::min(max_num, max_data);
         }
       }
       bColorKey = TRUE;
     }
   }
   return pCompData;
 }
 
-ICodec_ScanlineDecoder* FPDFAPI_CreateFaxDecoder(
+CCodec_ScanlineDecoder* FPDFAPI_CreateFaxDecoder(
     const uint8_t* src_buf,
     uint32_t src_size,
     int width,
     int height,
     const CPDF_Dictionary* pParams);
 
-ICodec_ScanlineDecoder* FPDFAPI_CreateFlateDecoder(
+CCodec_ScanlineDecoder* FPDFAPI_CreateFlateDecoder(
     const uint8_t* src_buf,
     uint32_t src_size,
     int width,
     int height,
     int nComps,
     int bpc,
     const CPDF_Dictionary* pParams);
 
 int CPDF_DIBSource::CreateDecoder() {
   const CFX_ByteString& decoder = m_pStreamAcc->GetImageDecoder();
@@ skipping 10 matching lines @@
     m_pDecoder.reset(FPDFAPI_CreateFaxDecoder(src_data, src_size, m_Width,
                                               m_Height, pParams));
   } else if (decoder == "DCTDecode") {
     m_pDecoder.reset(CPDF_ModuleMgr::Get()->GetJpegModule()->CreateDecoder(
         src_data, src_size, m_Width, m_Height, m_nComponents,
         pParams ? pParams->GetIntegerBy("ColorTransform", 1) : 1));
     if (!m_pDecoder) {
       FX_BOOL bTransform = FALSE;
       int comps;
       int bpc;
-      ICodec_JpegModule* pJpegModule = CPDF_ModuleMgr::Get()->GetJpegModule();
+      CCodec_JpegModule* pJpegModule = CPDF_ModuleMgr::Get()->GetJpegModule();
       if (pJpegModule->LoadInfo(src_data, src_size, m_Width, m_Height, comps,
                                 bpc, bTransform)) {
         if (m_nComponents != static_cast<uint32_t>(comps)) {
           FX_Free(m_pCompData);
           m_nComponents = static_cast<uint32_t>(comps);
           if (m_Family == PDFCS_LAB && m_nComponents != 3) {
             m_pCompData = nullptr;
             return 0;
           }
           m_pCompData = GetDecodeAndMaskArray(m_bDefaultDecode, m_bColorKey);
@@ skipping 42 matching lines @@
   if (!provided_pitch.IsValid()) {
     return 0;
   }
   if (provided_pitch.ValueOrDie() < requested_pitch.ValueOrDie()) {
     return 0;
   }
   return 1;
 }
 
 void CPDF_DIBSource::LoadJpxBitmap() {
-  ICodec_JpxModule* pJpxModule = CPDF_ModuleMgr::Get()->GetJpxModule();
+  CCodec_JpxModule* pJpxModule = CPDF_ModuleMgr::Get()->GetJpxModule();
   if (!pJpxModule)
     return;
 
   std::unique_ptr<JpxBitMapContext> context(new JpxBitMapContext(pJpxModule));
   context->set_decoder(pJpxModule->CreateDecoder(
       m_pStreamAcc->GetData(), m_pStreamAcc->GetSize(), m_pColorSpace));
   if (!context->decoder())
     return;
 
   uint32_t width = 0;
@@ skipping 926 matching lines @@
                                    IFX_Pause* pPause) {
   return LoadHandle->Continue(pPause);
 }
 
 CPDF_ImageLoader::~CPDF_ImageLoader() {
   if (!m_bCached) {
     delete m_pBitmap;
     delete m_pMask;
   }
 }