Reland "Fix chromium-style errors."

core/include/fpdfapi/fpdf_resource.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_FPDFAPI_FPDF_RESOURCE_H_
 #define CORE_INCLUDE_FPDFAPI_FPDF_RESOURCE_H_
 
 #include <map>
@@ skipping 84 matching lines @@
 class CPDF_Font {
  public:
   static CPDF_Font* CreateFontF(CPDF_Document* pDoc,
                                 CPDF_Dictionary* pFontDict);
   static CPDF_Font* GetStockFont(CPDF_Document* pDoc,
                                  const CFX_ByteStringC& fontname);
   static const FX_DWORD kInvalidCharCode = static_cast<FX_DWORD>(-1);
 
   virtual ~CPDF_Font();
 
-  virtual bool IsType1Font() const { return false; }
-  virtual bool IsTrueTypeFont() const { return false; }
-  virtual bool IsType3Font() const { return false; }
-  virtual bool IsCIDFont() const { return false; }
-  virtual const CPDF_Type1Font* AsType1Font() const { return nullptr; }
-  virtual CPDF_Type1Font* AsType1Font() { return nullptr; }
-  virtual const CPDF_TrueTypeFont* AsTrueTypeFont() const { return nullptr; }
-  virtual CPDF_TrueTypeFont* AsTrueTypeFont() { return nullptr; }
-  virtual const CPDF_Type3Font* AsType3Font() const { return nullptr; }
-  virtual CPDF_Type3Font* AsType3Font() { return nullptr; }
-  virtual const CPDF_CIDFont* AsCIDFont() const { return nullptr; }
-  virtual CPDF_CIDFont* AsCIDFont() { return nullptr; }
+  virtual bool IsType1Font() const;
+  virtual bool IsTrueTypeFont() const;
+  virtual bool IsType3Font() const;
+  virtual bool IsCIDFont() const;
+  virtual const CPDF_Type1Font* AsType1Font() const;
+  virtual CPDF_Type1Font* AsType1Font();
+  virtual const CPDF_TrueTypeFont* AsTrueTypeFont() const;
+  virtual CPDF_TrueTypeFont* AsTrueTypeFont();
+  virtual const CPDF_Type3Font* AsType3Font() const;
+  virtual CPDF_Type3Font* AsType3Font();
+  virtual const CPDF_CIDFont* AsCIDFont() const;
+  virtual CPDF_CIDFont* AsCIDFont();
 
   virtual FX_BOOL IsVertWriting() const;
-  virtual FX_BOOL IsUnicodeCompatible() const { return FALSE; }
+  virtual FX_BOOL IsUnicodeCompatible() const;
   virtual FX_DWORD GetNextChar(const FX_CHAR* pString,
                                int nStrLen,
                                int& offset) const;
-  virtual int CountChar(const FX_CHAR* pString, int size) const { return size; }
+  virtual int CountChar(const FX_CHAR* pString, int size) const;
   virtual int AppendChar(FX_CHAR* buf, FX_DWORD charcode) const;
-  virtual int GetCharSize(FX_DWORD charcode) const { return 1; }
+  virtual int GetCharSize(FX_DWORD charcode) const;
   virtual int GlyphFromCharCode(FX_DWORD charcode,
-                                FX_BOOL* pVertGlyph = NULL) = 0;
-  virtual int GlyphFromCharCodeExt(FX_DWORD charcode) {
-    return GlyphFromCharCode(charcode);
-  }
+                                FX_BOOL* pVertGlyph = nullptr);
+  virtual int GlyphFromCharCodeExt(FX_DWORD charcode);
   virtual CFX_WideString UnicodeFromCharCode(FX_DWORD charcode) const;
   virtual FX_DWORD CharCodeFromUnicode(FX_WCHAR Unicode) const;
 
   const CFX_ByteString& GetBaseFont() const { return m_BaseFont; }
   const CFX_SubstFont* GetSubstFont() const { return m_Font.GetSubstFont(); }
   FX_DWORD GetFlags() const { return m_Flags; }
-  FX_BOOL IsEmbedded() const { return IsType3Font() || m_pFontFile != NULL; }
+  FX_BOOL IsEmbedded() const { return IsType3Font() || m_pFontFile != nullptr; }
   CPDF_StreamAcc* GetFontFile() const { return m_pFontFile; }
   CPDF_Dictionary* GetFontDict() const { return m_pFontDict; }
   FX_BOOL IsStandardFont() const;
   FXFT_Face GetFace() const { return m_Font.GetFace(); }
   void AppendChar(CFX_ByteString& str, FX_DWORD charcode) const;
 
   void GetFontBBox(FX_RECT& rect) const { rect = m_FontBBox; }
   int GetTypeAscent() const { return m_Ascent; }
   int GetTypeDescent() const { return m_Descent; }
   int GetItalicAngle() const { return m_ItalicAngle; }
@@ skipping 102 matching lines @@
   FX_WORD m_CharWidth[256];
   FX_SMALL_RECT m_CharBBox[256];
   FX_BOOL m_bUseFontWidth;
 };
 
 class CPDF_Type1Font : public CPDF_SimpleFont {
  public:
   CPDF_Type1Font();
 
   // CPDF_Font:
-  bool IsType1Font() const override { return true; }
-  const CPDF_Type1Font* AsType1Font() const override { return this; }
-  CPDF_Type1Font* AsType1Font() override { return this; }
+  bool IsType1Font() const override;
+  const CPDF_Type1Font* AsType1Font() const override;
+  CPDF_Type1Font* AsType1Font() override;
   int GlyphFromCharCodeExt(FX_DWORD charcode) override;
 
   int GetBase14Font() const { return m_Base14Font; }
 
  protected:
   // CPDF_Font:
   FX_BOOL Load() override;
 
   // CPDF_SimpleFont:
   void LoadGlyphMap() override;
 
   int m_Base14Font;
 };
 
 class CPDF_TrueTypeFont : public CPDF_SimpleFont {
  public:
   CPDF_TrueTypeFont();
 
   // CPDF_Font:
-  bool IsTrueTypeFont() const override { return true; }
-  const CPDF_TrueTypeFont* AsTrueTypeFont() const override { return this; }
-  CPDF_TrueTypeFont* AsTrueTypeFont() override { return this; }
+  bool IsTrueTypeFont() const override;
+  const CPDF_TrueTypeFont* AsTrueTypeFont() const override;
+  CPDF_TrueTypeFont* AsTrueTypeFont() override;
 
  protected:
   // CPDF_Font:
   FX_BOOL Load() override;
 
   // CPDF_SimpleFont:
   void LoadGlyphMap() override;
 };
 
 class CPDF_Type3Char {
@@ skipping 11 matching lines @@
   CFX_Matrix m_ImageMatrix;
   FX_RECT m_BBox;
 };
 
 class CPDF_Type3Font : public CPDF_SimpleFont {
  public:
   CPDF_Type3Font();
   ~CPDF_Type3Font() override;
 
   // CPDF_Font:
-  bool IsType3Font() const override { return true; }
-  const CPDF_Type3Font* AsType3Font() const override { return this; }
-  CPDF_Type3Font* AsType3Font() override { return this; }
+  bool IsType3Font() const override;
+  const CPDF_Type3Font* AsType3Font() const override;
+  CPDF_Type3Font* AsType3Font() override;
   int GetCharWidthF(FX_DWORD charcode, int level = 0) override;
   FX_RECT GetCharBBox(FX_DWORD charcode, int level = 0) override;
 
   void SetPageResources(CPDF_Dictionary* pResources) {
     m_pPageResources = pResources;
   }
   CPDF_Type3Char* LoadChar(FX_DWORD charcode, int level = 0);
   void CheckType3FontMetrics();
 
   CFX_Matrix& GetFontMatrix() { return m_FontMatrix; }
@@ skipping 26 matching lines @@
 };
 
 class CPDF_CIDFont : public CPDF_Font {
  public:
   CPDF_CIDFont();
   ~CPDF_CIDFont() override;
 
   static FX_FLOAT CIDTransformToFloat(uint8_t ch);
 
   // CPDF_Font:
-  bool IsCIDFont() const override { return true; }
-  const CPDF_CIDFont* AsCIDFont() const override { return this; }
-  CPDF_CIDFont* AsCIDFont() override { return this; }
+  bool IsCIDFont() const override;
+  const CPDF_CIDFont* AsCIDFont() const override;
+  CPDF_CIDFont* AsCIDFont() override;
   int GlyphFromCharCode(FX_DWORD charcode, FX_BOOL* pVertGlyph = NULL) override;
   int GetCharWidthF(FX_DWORD charcode, int level = 0) override;
   FX_RECT GetCharBBox(FX_DWORD charcode, int level = 0) override;
   FX_DWORD GetNextChar(const FX_CHAR* pString,
                        int nStrLen,
                        int& offset) const override;
   int CountChar(const FX_CHAR* pString, int size) const override;
   int AppendChar(FX_CHAR* str, FX_DWORD charcode) const override;
   int GetCharSize(FX_DWORD charcode) const override;
   FX_BOOL IsVertWriting() const override;
@@ skipping 49 matching lines @@
 
 class CPDF_ColorSpace {
  public:
   static CPDF_ColorSpace* GetStockCS(int Family);
 
   static CPDF_ColorSpace* Load(CPDF_Document* pDoc, CPDF_Object* pCSObj);
 
   void ReleaseCS();
 
   int GetBufSize() const;
-
   FX_FLOAT* CreateBuf();
-
   void GetDefaultColor(FX_FLOAT* buf) const;
-
   int CountComponents() const { return m_nComponents; }
-
   int GetFamily() const { return m_Family; }
-
   virtual void GetDefaultValue(int iComponent,
                                FX_FLOAT& value,
                                FX_FLOAT& min,
                                FX_FLOAT& max) const {
     value = 0;
     min = 0;
     max = 1.0f;
   }
 
   FX_BOOL sRGB() const;
-
   virtual FX_BOOL GetRGB(FX_FLOAT* pBuf,
                          FX_FLOAT& R,
                          FX_FLOAT& G,
                          FX_FLOAT& B) const = 0;
-
   virtual FX_BOOL SetRGB(FX_FLOAT* pBuf,
                          FX_FLOAT R,
                          FX_FLOAT G,
                          FX_FLOAT B) const {
     return FALSE;
   }
 
   FX_BOOL GetCMYK(FX_FLOAT* pBuf,
                   FX_FLOAT& c,
                   FX_FLOAT& m,
                   FX_FLOAT& y,
                   FX_FLOAT& k) const;
-
   FX_BOOL SetCMYK(FX_FLOAT* pBuf,
                   FX_FLOAT c,
                   FX_FLOAT m,
                   FX_FLOAT y,
                   FX_FLOAT k) const;
 
   virtual void TranslateImageLine(uint8_t* dest_buf,
                                   const uint8_t* src_buf,
                                   int pixels,
                                   int image_width,
                                   int image_height,
                                   FX_BOOL bTransMask = FALSE) const;
 
   CPDF_Array*& GetArray() { return m_pArray; }
-
   int GetMaxIndex() const;
-
   virtual CPDF_ColorSpace* GetBaseCS() const { return NULL; }
 
   virtual void EnableStdConversion(FX_BOOL bEnabled);
 
   CPDF_Document* const m_pDocument;
 
  protected:
   CPDF_ColorSpace(CPDF_Document* pDoc, int family, int nComponents)
       : m_pDocument(pDoc),
         m_Family(family),
@@ skipping 276 matching lines @@
 
   FX_BOOL m_bInterpolate;
 
   CPDF_Document* m_pDocument;
 
   CPDF_Dictionary* m_pOC;
   CPDF_Dictionary* InitJPEG(uint8_t* pData, FX_DWORD size);
 };
 
 #endif  // CORE_INCLUDE_FPDFAPI_FPDF_RESOURCE_H_