Merge to XFA: Use override in more classes in core/

core/src/fxcodec/codec/codec_int.h

 // 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
 
 #ifndef CORE_SRC_FXCODEC_CODEC_CODEC_INT_H_
 #define CORE_SRC_FXCODEC_CODEC_CODEC_INT_H_
 
 #include <limits.h>
@@ skipping 13 matching lines @@
                             FX_DWORD src_size,
                             uint8_t*& dest_buf,
                             FX_DWORD& dest_size);
   virtual ICodec_ScanlineDecoder* CreateRunLengthDecoder(const uint8_t* src_buf,
                                                          FX_DWORD src_size,
                                                          int width,
                                                          int height,
                                                          int nComps,
                                                          int bpc);
 };
+
 struct CCodec_ImageDataCache {
   int m_Width, m_Height;
   int m_nCachedLines;
   uint8_t m_Data;
 };
+
 class CCodec_ScanlineDecoder : public ICodec_ScanlineDecoder {
  public:
   CCodec_ScanlineDecoder();
+  ~CCodec_ScanlineDecoder() override;
 
-  virtual ~CCodec_ScanlineDecoder();
-
-  virtual FX_DWORD GetSrcOffset() { return -1; }
-
-  virtual void DownScale(int dest_width, int dest_height);
-
-  uint8_t* GetScanline(int line);
-
-  FX_BOOL SkipToScanline(int line, IFX_Pause* pPause);
-
-  int GetWidth() { return m_OutputWidth; }
-
-  int GetHeight() { return m_OutputHeight; }
-
-  int CountComps() { return m_nComps; }
-
-  int GetBPC() { return m_bpc; }
-
-  FX_BOOL IsColorTransformed() { return m_bColorTransformed; }
-
-  void ClearImageData() {
+  // ICodec_ScanlineDecoder
+  FX_DWORD GetSrcOffset() override { return -1; }
+  void DownScale(int dest_width, int dest_height) override;
+  uint8_t* GetScanline(int line) override;
+  FX_BOOL SkipToScanline(int line, IFX_Pause* pPause) override;
+  int GetWidth() override { return m_OutputWidth; }
+  int GetHeight() override { return m_OutputHeight; }
+  int CountComps() override { return m_nComps; }
+  int GetBPC() override { return m_bpc; }
+  FX_BOOL IsColorTransformed() override { return m_bColorTransformed; }
+  void ClearImageData() override {
     if (m_pDataCache) {
       FX_Free(m_pDataCache);
     }
     m_pDataCache = NULL;
   }
 
  protected:
   int m_OrigWidth;
 
   int m_OrigHeight;
@@ skipping 19 matching lines @@
   virtual uint8_t* v_GetNextLine() = 0;
 
   virtual void v_DownScale(int dest_width, int dest_height) = 0;
 
   int m_NextLine;
 
   uint8_t* m_pLastScanline;
 
   CCodec_ImageDataCache* m_pDataCache;
 };
+
 class CCodec_FaxModule : public ICodec_FaxModule {
  public:
   virtual ICodec_ScanlineDecoder* CreateDecoder(const uint8_t* src_buf,
                                                 FX_DWORD src_size,
                                                 int width,
                                                 int height,
                                                 int K,
                                                 FX_BOOL EndOfLine,
                                                 FX_BOOL EncodedByteAlign,
                                                 FX_BOOL BlackIs1,
                                                 int Columns,
                                                 int Rows);
   FX_BOOL Encode(const uint8_t* src_buf,
                  int width,
                  int height,
                  int pitch,
                  uint8_t*& dest_buf,
                  FX_DWORD& dest_size);
 };
+
 class CCodec_FlateModule : public ICodec_FlateModule {
  public:
   virtual ICodec_ScanlineDecoder* CreateDecoder(const uint8_t* src_buf,
                                                 FX_DWORD src_size,
                                                 int width,
                                                 int height,
                                                 int nComps,
                                                 int bpc,
                                                 int predictor,
                                                 int Colors,
@@ skipping 16 matching lines @@
                          int Colors,
                          int BitsPerComponent,
                          int Columns,
                          uint8_t*& dest_buf,
                          FX_DWORD& dest_size);
   virtual FX_BOOL Encode(const uint8_t* src_buf,
                          FX_DWORD src_size,
                          uint8_t*& dest_buf,
                          FX_DWORD& dest_size);
 };
+
 class CCodec_JpegModule : public ICodec_JpegModule {
  public:
   CCodec_JpegModule() : m_pExtProvider(NULL) {}
   void SetPovider(IFX_JpegProvider* pJP) { m_pExtProvider = pJP; }
   ICodec_ScanlineDecoder* CreateDecoder(const uint8_t* src_buf,
                                         FX_DWORD src_size,
                                         int width,
                                         int height,
                                         int nComps,
                                         FX_BOOL ColorTransform);
@@ skipping 133 matching lines @@
   typedef enum {
     Icc_CLASS_INPUT = 0,
     Icc_CLASS_OUTPUT,
     Icc_CLASS_PROOF,
     Icc_CLASS_MAX
   } Icc_CLASS;
   void* CreateProfile(ICodec_IccModule::IccParam* pIccParam,
                       Icc_CLASS ic,
                       CFX_BinaryBuf* pTransformKey);
 };
+
 class CCodec_JpxModule : public ICodec_JpxModule {
  public:
   CCodec_JpxModule();
   void* CreateDecoder(const uint8_t* src_buf,
                       FX_DWORD src_size,
                       FX_BOOL useColorSpace = FALSE);
   void GetImageInfo(void* ctx,
                     FX_DWORD& width,
                     FX_DWORD& height,
                     FX_DWORD& codestream_nComps,
                     FX_DWORD& output_nComps);
   FX_BOOL Decode(void* ctx,
                  uint8_t* dest_data,
                  int pitch,
                  FX_BOOL bTranslateColor,
                  uint8_t* offsets);
   void DestroyDecoder(void* ctx);
 };
+
 class CCodec_TiffModule : public ICodec_TiffModule {

[Lei Zhang, 2015/08/15 04:49:07]

This is new in XFA.

  public:
-  virtual void* CreateDecoder(IFX_FileRead* file_ptr);
-  virtual void GetFrames(void* ctx, int32_t& frames);
-  virtual FX_BOOL LoadFrameInfo(void* ctx,
-                                int32_t frame,
-                                FX_DWORD& width,
-                                FX_DWORD& height,
-                                FX_DWORD& comps,
-                                FX_DWORD& bpc,
-                                CFX_DIBAttribute* pAttribute = NULL);
-  virtual FX_BOOL Decode(void* ctx, class CFX_DIBitmap* pDIBitmap);
-  virtual void DestroyDecoder(void* ctx);
+  // ICodec_TiffModule
+  void* CreateDecoder(IFX_FileRead* file_ptr) override;
+  void GetFrames(void* ctx, int32_t& frames) override;
+  FX_BOOL LoadFrameInfo(void* ctx,
+                        int32_t frame,
+                        FX_DWORD& width,
+                        FX_DWORD& height,
+                        FX_DWORD& comps,
+                        FX_DWORD& bpc,
+                        CFX_DIBAttribute* pAttribute = NULL) override;
+  FX_BOOL Decode(void* ctx, class CFX_DIBitmap* pDIBitmap) override;
+  void DestroyDecoder(void* ctx) override;
+
+ protected:
+  ~CCodec_TiffModule() override {}
 };
+
 class CPDF_Jbig2Interface : public CJBig2_Module {
  public:
   virtual void* JBig2_Malloc(FX_DWORD dwSize) {
     return FX_Alloc(uint8_t, dwSize);
   }
   virtual void* JBig2_Malloc2(FX_DWORD num, FX_DWORD dwSize) {
     if (dwSize && num >= UINT_MAX / dwSize) {
       return NULL;
     }
     return FX_Alloc(uint8_t, num * dwSize);
   }
   virtual void* JBig2_Malloc3(FX_DWORD num, FX_DWORD dwSize, FX_DWORD dwSize2) {
     if (dwSize2 && dwSize >= UINT_MAX / dwSize2) {
       return NULL;
     }
     FX_DWORD size = dwSize2 * dwSize;
     if (size && num >= UINT_MAX / size) {
       return NULL;
     }
     return FX_Alloc(uint8_t, num * size);
   }
   virtual void* JBig2_Realloc(void* pMem, FX_DWORD dwSize) {
     return FX_Realloc(uint8_t, pMem, dwSize);
   }
   virtual void JBig2_Free(void* pMem) { FX_Free(pMem); }
 };
+
 class CCodec_Jbig2Context {
  public:
   CCodec_Jbig2Context();
   ~CCodec_Jbig2Context(){};
 
   FX_DWORD m_width;
   FX_DWORD m_height;
   uint8_t* m_src_buf;
   FX_DWORD m_src_size;
   const uint8_t* m_global_data;
   FX_DWORD m_global_size;
   uint8_t* m_dest_buf;
   FX_DWORD m_dest_pitch;
   FX_BOOL m_bFileReader;
   IFX_Pause* m_pPause;
   CJBig2_Context* m_pContext;
   CJBig2_Image* m_dest_image;
 };
 class CCodec_Jbig2Module : public ICodec_Jbig2Module {
  public:
   CCodec_Jbig2Module(){};
-  ~CCodec_Jbig2Module();
+  ~CCodec_Jbig2Module() override;
+
+  // ICodec_Jbig2Module
   FX_BOOL Decode(FX_DWORD width,
                  FX_DWORD height,
                  const uint8_t* src_buf,
                  FX_DWORD src_size,
                  const uint8_t* global_data,
                  FX_DWORD global_size,
                  uint8_t* dest_buf,
-                 FX_DWORD dest_pitch);
+                 FX_DWORD dest_pitch) override;
   FX_BOOL Decode(IFX_FileRead* file_ptr,
                  FX_DWORD& width,
                  FX_DWORD& height,
                  FX_DWORD& pitch,
-                 uint8_t*& dest_buf);
-  void* CreateJbig2Context();
+                 uint8_t*& dest_buf) override;
+  void* CreateJbig2Context() override;
   FXCODEC_STATUS StartDecode(void* pJbig2Context,
                              FX_DWORD width,
                              FX_DWORD height,
                              const uint8_t* src_buf,
                              FX_DWORD src_size,
                              const uint8_t* global_data,
                              FX_DWORD global_size,
                              uint8_t* dest_buf,
                              FX_DWORD dest_pitch,
-                             IFX_Pause* pPause);
-
+                             IFX_Pause* pPause) override;
   FXCODEC_STATUS StartDecode(void* pJbig2Context,
                              IFX_FileRead* file_ptr,
                              FX_DWORD& width,
                              FX_DWORD& height,
                              FX_DWORD& pitch,
                              uint8_t*& dest_buf,
-                             IFX_Pause* pPause);
-  FXCODEC_STATUS ContinueDecode(void* pJbig2Context, IFX_Pause* pPause);
-  void DestroyJbig2Context(void* pJbig2Context);
+                             IFX_Pause* pPause) override;
+  FXCODEC_STATUS ContinueDecode(void* pJbig2Context,
+                                IFX_Pause* pPause) override;
+  void DestroyJbig2Context(void* pJbig2Context) override;
+
+ private:
   CPDF_Jbig2Interface m_Module;
   std::list<CJBig2_CachePair> m_SymbolDictCache;
-
- private:
 };
 class CFX_DIBAttributeExif : public IFX_DIBAttributeExif {
  public:
   CFX_DIBAttributeExif();
   ~CFX_DIBAttributeExif();
   virtual FX_BOOL GetInfo(FX_WORD tag, void* val);
 
   FX_BOOL ParseExif(CFX_MapPtrTemplate<FX_DWORD, uint8_t*>* pHead,
                     uint8_t* data,
                     FX_DWORD len,
@@ skipping 33 matching lines @@
 OPJ_SIZE_T opj_read_from_memory(void* p_buffer,
                                 OPJ_SIZE_T nb_bytes,
                                 void* p_user_data);
 OPJ_SIZE_T opj_write_from_memory(void* p_buffer,
                                  OPJ_SIZE_T nb_bytes,
                                  void* p_user_data);
 OPJ_OFF_T opj_skip_from_memory(OPJ_OFF_T nb_bytes, void* p_user_data);
 OPJ_BOOL opj_seek_from_memory(OPJ_OFF_T nb_bytes, void* p_user_data);
 
 #endif  // CORE_SRC_FXCODEC_CODEC_CODEC_INT_H_