Add type cast definitions for CPDF_Stream.

core/src/fpdfapi/fpdf_parser/fpdf_parser_objects.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 "../../../include/fpdfapi/fpdf_parser.h"
 #include "../../../include/fxcrt/fx_string.h"
 
 // static
@@ skipping 13 matching lines @@
     case PDFOBJ_NAME:
       delete AsName();
       break;
     case PDFOBJ_ARRAY:
       delete AsArray();
       break;
     case PDFOBJ_DICTIONARY:
       delete AsDictionary();
       break;
     case PDFOBJ_STREAM:
-      delete (CPDF_Stream*)this;
+      delete AsStream();
       break;
     default:
       delete this;
   }
 }
 CFX_ByteString CPDF_Object::GetString() const {
   switch (m_Type) {
     case PDFOBJ_BOOLEAN:
       return AsBoolean()->m_bValue ? "true" : "false";
     case PDFOBJ_NUMBER:
@@ skipping 92 matching lines @@
   return 0;
 }
 
 CPDF_Dictionary* CPDF_Object::GetDict() const {
   switch (m_Type) {
     case PDFOBJ_DICTIONARY:
       // The method should be made non-const if we want to not be const.
       // See bug #234.
       return const_cast<CPDF_Dictionary*>(AsDictionary());
     case PDFOBJ_STREAM:
-      return ((CPDF_Stream*)this)->GetDict();
+      return AsStream()->GetDict();
     case PDFOBJ_REFERENCE: {
       CPDF_Reference* pRef = (CPDF_Reference*)this;
       CPDF_IndirectObjects* pIndirect = pRef->GetObjList();
       if (!pIndirect)
         return nullptr;
       CPDF_Object* pObj = pIndirect->GetIndirectObject(pRef->GetRefObjNum());
       if (!pObj || (pObj == this))
         return nullptr;
       return pObj->GetDict();
     }
@@ skipping 57 matching lines @@
       return AsString()->Identical(pOther->AsString());
     case PDFOBJ_NAME:
       return AsName()->Identical(pOther->AsName());
     case PDFOBJ_ARRAY:
       return AsArray()->Identical(pOther->AsArray());
     case PDFOBJ_DICTIONARY:
       return AsDictionary()->Identical(pOther->AsDictionary());
     case PDFOBJ_NULL:
       return TRUE;
     case PDFOBJ_STREAM:
-      return (((CPDF_Stream*)this)->Identical((CPDF_Stream*)pOther));
+      return AsStream()->Identical(pOther->AsStream());
     case PDFOBJ_REFERENCE:
       return (((CPDF_Reference*)this)->Identical((CPDF_Reference*)pOther));
   }
   return FALSE;
 }
 CPDF_Object* CPDF_Object::GetDirect() const {
   if (m_Type != PDFOBJ_REFERENCE) {
     return (CPDF_Object*)this;
   }
   CPDF_Reference* pRef = (CPDF_Reference*)(void*)this;
@@ skipping 41 matching lines @@
         CPDF_Object* value;
         pThis->m_Map.GetNextAssoc(pos, key, (void*&)value);
         pCopy->m_Map.SetAt(key, value->CloneInternal(bDirect, visited));
       }
       return pCopy;
     }
     case PDFOBJ_NULL: {
       return new CPDF_Null;
     }
     case PDFOBJ_STREAM: {
-      CPDF_Stream* pThis = (CPDF_Stream*)this;
+      const CPDF_Stream* pThis = AsStream();
       CPDF_StreamAcc acc;
       acc.LoadAllData(pThis, TRUE);
       FX_DWORD streamSize = acc.GetSize();
       CPDF_Dictionary* pDict = pThis->GetDict();
       if (pDict) {
         pDict = ToDictionary(pDict->CloneInternal(bDirect, visited));
       }
       return new CPDF_Stream(acc.DetachData(), streamSize, pDict);
     }
     case PDFOBJ_REFERENCE: {
@@ skipping 14 matching lines @@
 CPDF_Object* CPDF_Object::CloneRef(CPDF_IndirectObjects* pDoc) const {
   if (m_ObjNum) {
     return new CPDF_Reference(pDoc, m_ObjNum);
   }
   return Clone();
 }
 CFX_WideString CPDF_Object::GetUnicodeText(CFX_CharMap* pCharMap) const {
   if (const CPDF_String* pString = AsString())
     return PDF_DecodeText(pString->m_String, pCharMap);
 
-  if (m_Type == PDFOBJ_STREAM) {
+  if (const CPDF_Stream* pStream = AsStream()) {
     CPDF_StreamAcc stream;
-    stream.LoadAllData((CPDF_Stream*)this, FALSE);
+    stream.LoadAllData(pStream, FALSE);
     CFX_WideString result =
         PDF_DecodeText(stream.GetData(), stream.GetSize(), pCharMap);
     return result;
   }
   if (const CPDF_Name* pName = AsName())
     return PDF_DecodeText(pName->m_Name, pCharMap);
   return CFX_WideString();
 }
 void CPDF_Object::SetUnicodeText(const FX_WCHAR* pUnicodes, int len) {
   if (CPDF_String* pString = AsString()) {
     pString->m_String = PDF_EncodeText(pUnicodes, len);
-  } else if (m_Type == PDFOBJ_STREAM) {
+  } else if (CPDF_Stream* pStream = AsStream()) {
     CFX_ByteString result = PDF_EncodeText(pUnicodes, len);
-    ((CPDF_Stream*)this)
-        ->SetData((uint8_t*)result.c_str(), result.GetLength(), FALSE, FALSE);
+    pStream->SetData((uint8_t*)result.c_str(), result.GetLength(), FALSE,
+                     FALSE);
   }
 }
 
 CPDF_Array* CPDF_Object::AsArray() {
   return IsArray() ? static_cast<CPDF_Array*>(this) : nullptr;
 }
 
 const CPDF_Array* CPDF_Object::AsArray() const {
   return IsArray() ? static_cast<const CPDF_Array*>(this) : nullptr;
 }
@@ skipping 23 matching lines @@
 }
 
 CPDF_Number* CPDF_Object::AsNumber() {
   return IsNumber() ? static_cast<CPDF_Number*>(this) : nullptr;
 }
 
 const CPDF_Number* CPDF_Object::AsNumber() const {
   return IsNumber() ? static_cast<const CPDF_Number*>(this) : nullptr;
 }
 
+CPDF_Stream* CPDF_Object::AsStream() {
+  return IsStream() ? static_cast<CPDF_Stream*>(this) : nullptr;
+}
+
+const CPDF_Stream* CPDF_Object::AsStream() const {
+  return IsStream() ? static_cast<const CPDF_Stream*>(this) : nullptr;
+}
+
 CPDF_String* CPDF_Object::AsString() {
   return IsString() ? static_cast<CPDF_String*>(this) : nullptr;
 }
 
 const CPDF_String* CPDF_Object::AsString() const {
   return IsString() ? static_cast<const CPDF_String*>(this) : nullptr;
 }
 
 CPDF_Number::CPDF_Number(int value)
     : CPDF_Object(PDFOBJ_NUMBER), m_bInteger(TRUE), m_Integer(value) {}
@@ skipping 87 matching lines @@
 }
 FX_FLOAT CPDF_Array::GetNumber(FX_DWORD i) const {
   if (i >= (FX_DWORD)m_Objects.GetSize()) {
     return 0;
   }
   CPDF_Object* p = (CPDF_Object*)m_Objects.GetAt(i);
   return p->GetNumber();
 }
 CPDF_Dictionary* CPDF_Array::GetDict(FX_DWORD i) const {
   CPDF_Object* p = GetElementValue(i);
-  if (!p) {
+  if (!p)
     return NULL;
-  }
-  if (CPDF_Dictionary* pDict = p->AsDictionary()) {
+  if (CPDF_Dictionary* pDict = p->AsDictionary())
     return pDict;
-  }
-  if (p->GetType() == PDFOBJ_STREAM) {
-    return ((CPDF_Stream*)p)->GetDict();
-  }
+  if (CPDF_Stream* pStream = p->AsStream())
+    return pStream->GetDict();
   return NULL;
 }
 CPDF_Stream* CPDF_Array::GetStream(FX_DWORD i) const {
-  CPDF_Object* p = GetElementValue(i);
-  if (p == NULL || p->GetType() != PDFOBJ_STREAM) {
-    return NULL;
-  }
-  return (CPDF_Stream*)p;
+  return ToStream(GetElementValue(i));
 }
 CPDF_Array* CPDF_Array::GetArray(FX_DWORD i) const {
   return ToArray(GetElementValue(i));
 }
 void CPDF_Array::RemoveAt(FX_DWORD i) {
   ASSERT(IsArray());
   if (i >= (FX_DWORD)m_Objects.GetSize()) {
     return;
   }
   CPDF_Object* p = (CPDF_Object*)m_Objects.GetAt(i);
@@ skipping 179 matching lines @@
 FX_BOOL CPDF_Dictionary::GetBoolean(const CFX_ByteStringC& key,
                                     FX_BOOL bDefault) const {
   CPDF_Object* p = NULL;
   m_Map.Lookup(key, (void*&)p);
   if (ToBoolean(p))
     return p->GetInteger();
   return bDefault;
 }
 CPDF_Dictionary* CPDF_Dictionary::GetDict(const CFX_ByteStringC& key) const {
   CPDF_Object* p = GetElementValue(key);
-  if (!p) {
+  if (!p)
     return nullptr;
-  }
-  if (CPDF_Dictionary* pDict = p->AsDictionary()) {
+  if (CPDF_Dictionary* pDict = p->AsDictionary())
     return pDict;
-  }
-  if (p->GetType() == PDFOBJ_STREAM) {
-    return ((CPDF_Stream*)p)->GetDict();
-  }
+  if (CPDF_Stream* pStream = p->AsStream())
+    return pStream->GetDict();
   return nullptr;
 }
 CPDF_Array* CPDF_Dictionary::GetArray(const CFX_ByteStringC& key) const {
   return ToArray(GetElementValue(key));
 }
 CPDF_Stream* CPDF_Dictionary::GetStream(const CFX_ByteStringC& key) const {
-  CPDF_Object* p = GetElementValue(key);
-  if (p == NULL || p->GetType() != PDFOBJ_STREAM) {
-    return NULL;
-  }
-  return (CPDF_Stream*)p;
+  return ToStream(GetElementValue(key));
 }
 CFX_FloatRect CPDF_Dictionary::GetRect(const CFX_ByteStringC& key) const {
   CFX_FloatRect rect;
   CPDF_Array* pArray = GetArray(key);
   if (pArray) {
     rect = pArray->GetRect();
   }
   return rect;
 }
 CFX_AffineMatrix CPDF_Dictionary::GetMatrix(const CFX_ByteStringC& key) const {
@@ skipping 292 matching lines @@
   m_pData = NULL;
   m_dwSize = 0;
   m_pImageParam = NULL;
   m_pStream = NULL;
   m_pSrcData = NULL;
 }
 void CPDF_StreamAcc::LoadAllData(const CPDF_Stream* pStream,
                                  FX_BOOL bRawAccess,
                                  FX_DWORD estimated_size,
                                  FX_BOOL bImageAcc) {
-  if (pStream == NULL || pStream->GetType() != PDFOBJ_STREAM) {
+  if (!pStream)
     return;
-  }
+
   m_pStream = pStream;
   if (pStream->IsMemoryBased() &&
       (!pStream->GetDict()->KeyExist(FX_BSTRC("Filter")) || bRawAccess)) {
     m_dwSize = pStream->m_dwSize;
     m_pData = (uint8_t*)pStream->m_pDataBuf;
     return;
   }
   uint8_t* pSrcData;
   FX_DWORD dwSrcSize = pStream->m_dwSize;
-  if (dwSrcSize == 0) {
+  if (dwSrcSize == 0)
     return;
-  }
+
   if (!pStream->IsMemoryBased()) {
     pSrcData = m_pSrcData = FX_Alloc(uint8_t, dwSrcSize);
-    if (!pStream->ReadRawData(0, pSrcData, dwSrcSize)) {
+    if (!pStream->ReadRawData(0, pSrcData, dwSrcSize))
       return;
-    }
   } else {
     pSrcData = pStream->m_pDataBuf;
   }
   uint8_t* pDecryptedData;
   FX_DWORD dwDecryptedSize;
   if (pStream->m_pCryptoHandler) {
     CFX_BinaryBuf dest_buf;
     dest_buf.EstimateSize(pStream->m_pCryptoHandler->DecryptGetSize(dwSrcSize));
     void* context = pStream->m_pCryptoHandler->DecryptStart(
         pStream->GetObjNum(), pStream->m_GenNum);
@@ skipping 169 matching lines @@
   }
   pObj->m_ObjNum = objnum;
   m_IndirectObjs.SetAt((void*)(uintptr_t)objnum, pObj);
   if (m_LastObjNum < objnum) {
     m_LastObjNum = objnum;
   }
 }
 FX_DWORD CPDF_IndirectObjects::GetLastObjNum() const {
   return m_LastObjNum;
 }