Inflict PPDF_ENABLE_XFA ifdefs on XFA core/

core/include/fxcodec/fx_codec.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_INCLUDE_FXCODEC_FX_CODEC_H_
 #define CORE_INCLUDE_FXCODEC_FX_CODEC_H_
 
+#ifdef PDF_ENABLE_XFA
 #include <map>

[Lei Zhang, 2015/11/24 23:36:04]

Can we have a single #ifdef PDF_ENABLE_XFA block for #includes? i.e. mvoe this
down to line 20.

[Tom Sepez, 2015/11/25 18:51:45]

Yep, will fix in next CL.

+#endif
 #include <vector>
 
 #include "core/include/fxcrt/fx_basic.h"
 #include "fx_codec_def.h"
 #include "third_party/base/nonstd_unique_ptr.h"
 
+#ifdef PDF_ENABLE_XFA
 #include "../fxcrt/fx_coordinates.h"  // For FX_RECT.
 
+#endif
 class CFX_DIBSource;
 class CJPX_Decoder;
 class CPDF_PrivateData;
 class CPDF_StreamAcc;
+#ifndef PDF_ENABLE_XFA

[Lei Zhang, 2015/11/24 23:36:04]

Ditto, move these to the separate block below.

[Tom Sepez, 2015/11/25 18:51:45]

Acknowledged.

+class ICodec_ScanlineDecoder;
+#endif
 class ICodec_BasicModule;
 class ICodec_FaxModule;
+#ifdef PDF_ENABLE_XFA
 class ICodec_FlateModule;
 class ICodec_IccModule;
 class ICodec_Jbig2Encoder;
 class ICodec_Jbig2Module;
+#endif
 class ICodec_JpegModule;
 class ICodec_JpxModule;
+#ifndef PDF_ENABLE_XFA
+class ICodec_Jbig2Module;
+class ICodec_IccModule;
+class ICodec_FlateModule;
+class ICodec_Jbig2Encoder;
+#endif
 class ICodec_ScanlineDecoder;
 
+#ifdef PDF_ENABLE_XFA
 class ICodec_BmpModule;
 class ICodec_GifModule;
 class ICodec_PngModule;
 class ICodec_ProgressiveDecoder;
 class ICodec_TiffModule;
 
 class CFX_DIBAttribute {
  public:
   CFX_DIBAttribute();
   ~CFX_DIBAttribute();
 
   int32_t m_nXDPI;
   int32_t m_nYDPI;
   FX_FLOAT m_fAspectRatio;
   FX_WORD m_wDPIUnit;
   CFX_ByteString m_strAuthor;
   uint8_t m_strTime[20];
   int32_t m_nGifLeft;
   int32_t m_nGifTop;
   FX_DWORD* m_pGifLocalPalette;
   FX_DWORD m_nGifLocalPalNum;
   int32_t m_nBmpCompressType;
   std::map<FX_DWORD, void*> m_Exif;
 };
 
+#endif
 class CCodec_ModuleMgr {
  public:
   CCodec_ModuleMgr();
 
   ICodec_BasicModule* GetBasicModule() const { return m_pBasicModule.get(); }
   ICodec_FaxModule* GetFaxModule() const { return m_pFaxModule.get(); }
   ICodec_JpegModule* GetJpegModule() const { return m_pJpegModule.get(); }
   ICodec_JpxModule* GetJpxModule() const { return m_pJpxModule.get(); }
   ICodec_Jbig2Module* GetJbig2Module() const { return m_pJbig2Module.get(); }
   ICodec_IccModule* GetIccModule() const { return m_pIccModule.get(); }
   ICodec_FlateModule* GetFlateModule() const { return m_pFlateModule.get(); }
 
+#ifdef PDF_ENABLE_XFA
   ICodec_ProgressiveDecoder* CreateProgressiveDecoder();
   ICodec_PngModule* GetPngModule() const { return m_pPngModule.get(); }
   ICodec_GifModule* GetGifModule() const { return m_pGifModule.get(); }
   ICodec_BmpModule* GetBmpModule() const { return m_pBmpModule.get(); }
   ICodec_TiffModule* GetTiffModule() const { return m_pTiffModule.get(); }
 
+#endif
  protected:
   nonstd::unique_ptr<ICodec_BasicModule> m_pBasicModule;
   nonstd::unique_ptr<ICodec_FaxModule> m_pFaxModule;
   nonstd::unique_ptr<ICodec_JpegModule> m_pJpegModule;
   nonstd::unique_ptr<ICodec_JpxModule> m_pJpxModule;
   nonstd::unique_ptr<ICodec_Jbig2Module> m_pJbig2Module;
   nonstd::unique_ptr<ICodec_IccModule> m_pIccModule;
   nonstd::unique_ptr<ICodec_FlateModule> m_pFlateModule;
+#ifdef PDF_ENABLE_XFA

[Lei Zhang, 2015/11/24 23:36:04]

blink line above, not below.

 
   nonstd::unique_ptr<ICodec_PngModule> m_pPngModule;
   nonstd::unique_ptr<ICodec_GifModule> m_pGifModule;
   nonstd::unique_ptr<ICodec_BmpModule> m_pBmpModule;
   nonstd::unique_ptr<ICodec_TiffModule> m_pTiffModule;
+#endif
 };
 class ICodec_BasicModule {
  public:
   virtual ~ICodec_BasicModule() {}
   virtual FX_BOOL RunLengthEncode(const uint8_t* src_buf,
                                   FX_DWORD src_size,
                                   uint8_t*& dest_buf,
                                   FX_DWORD& dest_size) = 0;
   virtual FX_BOOL A85Encode(const uint8_t* src_buf,
                             FX_DWORD src_size,
@@ skipping 123 matching lines @@
 
   virtual void Finish(void* pContext) = 0;
 
   virtual void Input(void* pContext,
                      const uint8_t* src_buf,
                      FX_DWORD src_size) = 0;
 
   virtual int ReadHeader(void* pContext,
                          int* width,
                          int* height,
+#ifndef PDF_ENABLE_XFA

[Lei Zhang, 2015/11/24 23:36:04]

#ifdef PDF_ENABLE_XFA
... nComps,\n...pAttribute...
#else
... nComps,\n
#endif

[Tom Sepez, 2015/11/25 00:12:06]

Making this purely "additive" (by that I mean no "#else"), followed by git
format gives:

  virtual int ReadHeader(void* pContext,
                         int* width,
                         int* height,
                         int* nComps
#ifdef PDF_ENABLE_XFA
                         ,
                         CFX_DIBAttribute* pAttribute
#endif
                         ) = 0;

which i think is pretty readable.  What do you think?

+                         int* nComps) = 0;
+#else
                          int* nComps,
                          CFX_DIBAttribute* pAttribute) = 0;
+#endif
 
   virtual int StartScanline(void* pContext, int down_scale) = 0;
 
   virtual FX_BOOL ReadScanline(void* pContext, uint8_t* dest_buf) = 0;
 
   virtual FX_DWORD GetAvailInput(void* pContext,
                                  uint8_t** avail_buf_ptr = NULL) = 0;
 };
 
 class ICodec_JpxModule {
  public:
   virtual ~ICodec_JpxModule() {}
 
   virtual CJPX_Decoder* CreateDecoder(const uint8_t* src_buf,
                                       FX_DWORD src_size,
                                       bool use_colorspace) = 0;
 
   virtual void GetImageInfo(CJPX_Decoder* pDecoder,
                             FX_DWORD* width,
                             FX_DWORD* height,
                             FX_DWORD* components) = 0;
 
   virtual bool Decode(CJPX_Decoder* pDecoder,
                       uint8_t* dest_data,
                       int pitch,
                       const std::vector<uint8_t>& offsets) = 0;
 
   virtual void DestroyDecoder(CJPX_Decoder* pDecoder) = 0;
 };
+#ifdef PDF_ENABLE_XFA
 class ICodec_PngModule {
  public:
   virtual ~ICodec_PngModule() {}
 
   virtual void* Start(void* pModule) = 0;
 
   virtual void Finish(void* pContext) = 0;
 
   virtual FX_BOOL Input(void* pContext,
                         const uint8_t* src_buf,
@@ skipping 107 matching lines @@
                                 FX_DWORD& width,
                                 FX_DWORD& height,
                                 FX_DWORD& comps,
                                 FX_DWORD& bpc,
                                 CFX_DIBAttribute* pAttribute) = 0;
 
   virtual FX_BOOL Decode(void* ctx, class CFX_DIBitmap* pDIBitmap) = 0;
 
   virtual void DestroyDecoder(void* ctx) = 0;
 };
+#endif

[Lei Zhang, 2015/11/24 23:36:04]

How about adding // PDF_ENABLE_XFA if the block is more than, say, 50 lines
long?

 
 class ICodec_Jbig2Module {
  public:
   virtual ~ICodec_Jbig2Module() {}
 
   virtual void* CreateJbig2Context() = 0;
 
   virtual FXCODEC_STATUS StartDecode(void* pJbig2Context,
                                      CFX_PrivateData* pPrivateData,
                                      FX_DWORD width,
                                      FX_DWORD height,
                                      CPDF_StreamAcc* src_stream,
                                      CPDF_StreamAcc* global_stream,
                                      uint8_t* dest_buf,
                                      FX_DWORD dest_pitch,
                                      IFX_Pause* pPause) = 0;
 
   virtual FXCODEC_STATUS ContinueDecode(void* pJbig2Content,
                                         IFX_Pause* pPause) = 0;
   virtual void DestroyJbig2Context(void* pJbig2Content) = 0;
 };
+#ifdef PDF_ENABLE_XFA
 class ICodec_ProgressiveDecoder {
  public:
   virtual ~ICodec_ProgressiveDecoder() {}
 
   virtual FXCODEC_STATUS LoadImageInfo(IFX_FileRead* pFile,
                                        FXCODEC_IMAGE_TYPE imageType,
                                        CFX_DIBAttribute* pAttribute) = 0;
 
   virtual FXCODEC_IMAGE_TYPE GetType() const = 0;
   virtual int32_t GetWidth() const = 0;
   virtual int32_t GetHeight() const = 0;
   virtual int32_t GetNumComponents() const = 0;
   virtual int32_t GetBPC() const = 0;
 
   virtual void SetClipBox(FX_RECT* clip) = 0;
 
   virtual FXCODEC_STATUS GetFrames(int32_t& frames,
                                    IFX_Pause* pPause = NULL) = 0;
 
   virtual FXCODEC_STATUS StartDecode(class CFX_DIBitmap* pDIBitmap,
                                      int32_t start_x,
                                      int32_t start_y,
                                      int32_t size_x,
                                      int32_t size_y,
                                      int32_t frames = 0,
                                      FX_BOOL bInterpol = TRUE) = 0;
 
   virtual FXCODEC_STATUS ContinueDecode(IFX_Pause* pPause = NULL) = 0;
 };
+#endif
 class ICodec_Jbig2Encoder {
  public:
   virtual ~ICodec_Jbig2Encoder() {}
 };
 class ICodec_IccModule {
  public:
   typedef enum {
     IccCS_Unknown = 0,
     IccCS_XYZ,
     IccCS_Lab,
@@ skipping 80 matching lines @@
 FX_BOOL MD5ComputeID(const void* buf, FX_DWORD dwSize, uint8_t ID[16]);
 void FaxG4Decode(const uint8_t* src_buf,
                  FX_DWORD src_size,
                  int* pbitpos,
                  uint8_t* dest_buf,
                  int width,
                  int height,
                  int pitch);
 
 #endif  // CORE_INCLUDE_FXCODEC_FX_CODEC_H_