Split the XFA_OBJECTTYPE enum into two parts.

xfa/fxfa/parser/xfa_object.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 XFA_FXFA_PARSER_XFA_OBJECT_H_
 #define XFA_FXFA_PARSER_XFA_OBJECT_H_
 
 #include <unordered_set>
 
 #include "fxjse/include/cfxjse_arguments.h"
 #include "xfa/fde/xml/fde_xml.h"
 #include "xfa/fxfa/parser/xfa_utils.h"
 
 class CXFA_Document;
 class CXFA_Node;
 class CXFA_NodeList;
 class CXFA_OrdinaryObject;
 
-enum XFA_OBJECTTYPE {
-  XFA_OBJECTTYPE_OrdinaryObject = 0x0,
-  XFA_OBJECTTYPE_OrdinaryList = 0x1,
-  XFA_OBJECTTYPE_NodeList = 0x2,
-  XFA_OBJECTTYPE_Node = 0x4,
-  XFA_OBJECTTYPE_NodeC = 0x5,
-  XFA_OBJECTTYPE_NodeV = 0x6,
-  XFA_OBJECTTYPE_ModelNode = 0x8,
-  XFA_OBJECTTYPE_TextNode = 0x9,
-  XFA_OBJECTTYPE_ContainerNode = 0xA,
-  XFA_OBJECTTYPE_ContentNode = 0xB,
-  XFA_OBJECTTYPE_VariablesThis = 0xC,
-  XFA_OBJECTTYPEMASK = 0xF,
-  XFA_NODEFLAG_Initialized = 0x00020,
-  XFA_NODEFLAG_HasRemoved = 0x00200,
-  XFA_NODEFLAG_NeedsInitApp = 0x00400,
-  XFA_NODEFLAG_BindFormItems = 0x00800,
-  XFA_NODEFLAG_UserInteractive = 0x01000,
-  XFA_NODEFLAG_SkipDataBinding = 0x02000,
-  XFA_NODEFLAG_OwnXMLNode = 0x04000,
-  XFA_NODEFLAG_UnusedNode = 0x08000,
-  XFA_NODEFLAG_LayoutGeneratedNode = 0x10000,
+enum class XFA_ObjectType {
+  OrdinaryObject,
+  OrdinaryList,
+  NodeList,
+  Node,
+  NodeC,
+  NodeV,
+  ModelNode,
+  TextNode,
+  ContainerNode,
+  ContentNode,
+  VariablesThis
+};
+
+enum XFA_NodeFlag {
+  XFA_NodeFlag_None = 0,
+  XFA_NodeFlag_Initialized = 1 << 0,
+  XFA_NodeFlag_HasRemovedChildren = 1 << 1,
+  XFA_NodeFlag_NeedsInitApp = 1 << 2,
+  XFA_NodeFlag_BindFormItems = 1 << 3,
+  XFA_NodeFlag_UserInteractive = 1 << 4,
+  XFA_NodeFlag_SkipDataBinding = 1 << 5,
+  XFA_NodeFlag_OwnXMLNode = 1 << 6,
+  XFA_NodeFlag_UnusedNode = 1 << 7,
+  XFA_NodeFlag_LayoutGeneratedNode = 1 << 8
 };
 
 class CXFA_Object : public CFXJSE_HostObject {
  public:
-  CXFA_Object(CXFA_Document* pDocument, uint32_t uFlags);
+  CXFA_Object(CXFA_Document* pDocument, XFA_ObjectType type);
   ~CXFA_Object() override;
 
   CXFA_Document* GetDocument() const { return m_pDocument; }
-  uint32_t GetFlag() const { return m_uFlags; }
-  XFA_OBJECTTYPE GetObjectType() const {
-    return (XFA_OBJECTTYPE)(m_uFlags & XFA_OBJECTTYPEMASK);
-  }
+  XFA_ObjectType GetObjectType() const { return m_objectType; }
 
   bool IsNode() const {
-    return (m_uFlags & XFA_OBJECTTYPEMASK) >= XFA_OBJECTTYPE_Node;
+    return m_objectType == XFA_ObjectType::Node ||
+           m_objectType == XFA_ObjectType::NodeC ||
+           m_objectType == XFA_ObjectType::NodeV ||
+           m_objectType == XFA_ObjectType::ModelNode ||
+           m_objectType == XFA_ObjectType::TextNode ||
+           m_objectType == XFA_ObjectType::ContainerNode ||
+           m_objectType == XFA_ObjectType::ContentNode ||
+           m_objectType == XFA_ObjectType::VariablesThis;
   }
   bool IsOrdinaryObject() const {
-    return (m_uFlags & XFA_OBJECTTYPEMASK) == XFA_OBJECTTYPE_OrdinaryObject;
+    return m_objectType == XFA_ObjectType::OrdinaryObject;
   }
-  bool IsNodeList() const {
-    return (m_uFlags & XFA_OBJECTTYPEMASK) == XFA_OBJECTTYPE_NodeList;
-  }
+  bool IsNodeList() const { return m_objectType == XFA_ObjectType::NodeList; }
   bool IsOrdinaryList() const {
-    return (m_uFlags & XFA_OBJECTTYPEMASK) == XFA_OBJECTTYPE_OrdinaryList;
+    return m_objectType == XFA_ObjectType::OrdinaryList;
   }
   bool IsContentNode() const {
-    return (m_uFlags & XFA_OBJECTTYPEMASK) == XFA_OBJECTTYPE_ContentNode;
+    return m_objectType == XFA_ObjectType::ContentNode;
   }
   bool IsContainerNode() const {
-    return (m_uFlags & XFA_OBJECTTYPEMASK) == XFA_OBJECTTYPE_ContainerNode;
+    return m_objectType == XFA_ObjectType::ContainerNode;
+  }
+  bool IsModelNode() const { return m_objectType == XFA_ObjectType::ModelNode; }
+  bool IsNodeV() const { return m_objectType == XFA_ObjectType::NodeV; }
+  bool IsVariablesThis() const {
+    return m_objectType == XFA_ObjectType::VariablesThis;
   }
 
   CXFA_Node* AsNode();
   CXFA_OrdinaryObject* AsOrdinaryObject();
   CXFA_NodeList* AsNodeList();
 
   const CXFA_Node* AsNode() const;
   const CXFA_OrdinaryObject* AsOrdinaryObject() const;
   const CXFA_NodeList* AsNodeList() const;
 
   XFA_ELEMENT GetClassID() const;
   void GetClassName(CFX_WideStringC& wsName) const;
   uint32_t GetClassHashCode() const;
   void Script_ObjectClass_ClassName(CFXJSE_Value* pValue,
                                     FX_BOOL bSetting,
                                     XFA_ATTRIBUTE eAttribute);
   void ThrowException(int32_t iStringID, ...);
 
  protected:
   CXFA_Document* const m_pDocument;
-  uint32_t m_uFlags;
+  XFA_ObjectType m_objectType;
 };
 using CXFA_ObjArray = CFX_ArrayTemplate<CXFA_Object*>;
 
 #define XFA_NODEFILTER_Children 0x01
 #define XFA_NODEFILTER_Properties 0x02
 #define XFA_NODEFILTER_OneOfProperty 0x04
 #define XFA_CLONEFLAG_Content 0x01
 enum XFA_NODEITEM {
   XFA_NODEITEM_Parent,
   XFA_NODEITEM_FirstChild,
@@ skipping 29 matching lines @@
   CFX_MapPtrToPtr m_ValueMap;
   CFX_MapPtrTemplate<void*, XFA_MAPDATABLOCK*> m_BufferMap;
 };
 
 #define XFA_CalcRefCount (void*)(uintptr_t) FXBSTR_ID('X', 'F', 'A', 'R')
 #define XFA_CalcData (void*)(uintptr_t) FXBSTR_ID('X', 'F', 'A', 'C')
 #define XFA_LAYOUTITEMKEY (void*)(uintptr_t) FXBSTR_ID('L', 'Y', 'I', 'M')
 
 class CXFA_Node : public CXFA_Object {
  public:
-  XFA_ELEMENT GetClassID() const { return (XFA_ELEMENT)m_eNodeClass; }
+  XFA_ELEMENT GetClassID() const { return m_eNodeClass; }
   uint32_t GetPacketID() const { return m_ePacket; }
-  FX_BOOL HasFlag(uint32_t dwFlag) const;
+
   void SetFlag(uint32_t dwFlag, bool bNotify);
   void ClearFlag(uint32_t dwFlag);
 
+  bool IsInitialized() const { return HasFlag(XFA_NodeFlag_Initialized); }
+  bool IsOwnXMLNode() const { return HasFlag(XFA_NodeFlag_OwnXMLNode); }
+  bool IsUserInteractive() const {
+    return HasFlag(XFA_NodeFlag_UserInteractive);
+  }
+  bool IsUnusedNode() const { return HasFlag(XFA_NodeFlag_UnusedNode); }
+  bool IsLayoutGeneratedNode() const {
+    return HasFlag(XFA_NodeFlag_LayoutGeneratedNode);
+  }
+  bool BindsFormItems() const {
+    return !!(m_uNodeFlags & XFA_NodeFlag_BindFormItems);

[Lei Zhang, 2016/06/20 17:24:06]

Why can't this just call HasFlag() ?

[dsinclair, 2016/06/20 17:28:40]

Done. 

+  }
+  bool HasRemovedChildren() const {
+    return HasFlag(XFA_NodeFlag_HasRemovedChildren);
+  }
+  bool NeedsInitApp() const { return HasFlag(XFA_NodeFlag_NeedsInitApp); }
+
   FX_BOOL IsAttributeInXML();
   bool IsFormContainer() const {
     return m_ePacket == XFA_XDPPACKET_Form && IsContainerNode();
   }
   void SetXMLMappingNode(CFDE_XMLNode* pXMLNode) { m_pXMLNode = pXMLNode; }
   CFDE_XMLNode* GetXMLMappingNode() const { return m_pXMLNode; }
   CFDE_XMLNode* CreateXMLMappingNode();
   FX_BOOL IsNeedSavingXMLNode();
   uint32_t GetNameHash() const { return m_dwNameHash; }
   bool IsUnnamed() const { return m_dwNameHash == 0; }
@@ skipping 112 matching lines @@
                          FX_BOOL bCreateProperty = TRUE);
   int32_t CountChildren(XFA_ELEMENT eElement, FX_BOOL bOnlyChild = FALSE);
   CXFA_Node* GetChild(int32_t index,
                       XFA_ELEMENT eElement,
                       FX_BOOL bOnlyChild = FALSE);
   int32_t InsertChild(int32_t index, CXFA_Node* pNode);
   FX_BOOL InsertChild(CXFA_Node* pNode, CXFA_Node* pBeforeNode = NULL);
   FX_BOOL RemoveChild(CXFA_Node* pNode, bool bNotify = true);
   CXFA_Node* Clone(FX_BOOL bRecursive);
   CXFA_Node* GetNodeItem(XFA_NODEITEM eItem) const;
-  CXFA_Node* GetNodeItem(XFA_NODEITEM eItem, XFA_OBJECTTYPE eType) const;
+  CXFA_Node* GetNodeItem(XFA_NODEITEM eItem, XFA_ObjectType eType) const;
   int32_t GetNodeList(CXFA_NodeArray& nodes,
                       uint32_t dwTypeFilter = XFA_NODEFILTER_Children |
                                               XFA_NODEFILTER_Properties,
                       XFA_ELEMENT eElementFilter = XFA_ELEMENT_UNKNOWN,
                       int32_t iLevel = 1);
   CXFA_Node* CreateSamePacketNode(XFA_ELEMENT eElement,
-                                  uint32_t dwFlags = XFA_NODEFLAG_Initialized);
+                                  uint32_t dwFlags = XFA_NodeFlag_Initialized);
   CXFA_Node* CloneTemplateToForm(FX_BOOL bRecursive);
   CXFA_Node* GetTemplateNode() const;
   void SetTemplateNode(CXFA_Node* pTemplateNode);
   CXFA_Node* GetDataDescriptionNode();
   void SetDataDescriptionNode(CXFA_Node* pDataDescriptionNode);
   CXFA_Node* GetBindData();
   int32_t GetBindItems(CXFA_NodeArray& formItems);
   int32_t AddBindItem(CXFA_Node* pFormNode);
   int32_t RemoveBindItem(CXFA_Node* pFormNode);
   FX_BOOL HasBindItem();
@@ skipping 290 matching lines @@
                           FX_BOOL bSetting,
                           XFA_ATTRIBUTE eAttribute);
   void Script_Encrypt_Format(CFXJSE_Value* pValue,
                              FX_BOOL bSetting,
                              XFA_ATTRIBUTE eAttribute);
   void Script_Script_Stateless(CFXJSE_Value* pValue,
                                FX_BOOL bSetting,
                                XFA_ATTRIBUTE eAttribute);
 
  protected:
+  friend class CXFA_Document;
+
   CXFA_Node(CXFA_Document* pDoc, uint16_t ePacket, XFA_ELEMENT eElement);
   ~CXFA_Node() override;
-  friend class CXFA_Document;
+
+  bool HasFlag(XFA_NodeFlag dwFlag) const;
   CXFA_Node* Deprecated_GetPrevSibling();
   FX_BOOL SetValue(XFA_ATTRIBUTE eAttr,
                    XFA_ATTRIBUTETYPE eType,
                    void* pValue,
                    bool bNotify);
   FX_BOOL GetValue(XFA_ATTRIBUTE eAttr,
                    XFA_ATTRIBUTETYPE eType,
                    FX_BOOL bUseDefault,
                    void*& pValue);
   void OnRemoved(bool bNotify);
@@ skipping 30 matching lines @@
                          void* pKey,
                          FX_BOOL bRecursive = FALSE);
 
   CXFA_Node* m_pNext;
   CXFA_Node* m_pChild;
   CXFA_Node* m_pLastChild;
   CXFA_Node* m_pParent;
   CFDE_XMLNode* m_pXMLNode;
   XFA_ELEMENT m_eNodeClass;
   uint16_t m_ePacket;
+  uint16_t m_uNodeFlags;
   uint32_t m_dwNameHash;
   CXFA_Node* m_pAuxNode;
   XFA_MAPMODULEDATA* m_pMapModuleData;
 };
 
 class CXFA_OrdinaryObject : public CXFA_Object {
  public:
   CXFA_OrdinaryObject(CXFA_Document* pDocument, XFA_ELEMENT eElement);
   ~CXFA_OrdinaryObject() override;
 
@@ skipping 72 matching lines @@
   CXFA_Node* Item(int32_t iIndex) override;
 
  protected:
   CXFA_Node* m_pAttachNode;
 };
 class CXFA_TraverseStrategy_XFAContainerNode {
  public:
   static CXFA_Node* GetFirstChild(CXFA_Node* pTemplateNode,
                                   void* pUserData = NULL) {
     return pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild,
-                                      XFA_OBJECTTYPE_ContainerNode);
+                                      XFA_ObjectType::ContainerNode);
   }
   static CXFA_Node* GetNextSibling(CXFA_Node* pTemplateNode,
                                    void* pUserData = NULL) {
     return pTemplateNode->GetNodeItem(XFA_NODEITEM_NextSibling,
-                                      XFA_OBJECTTYPE_ContainerNode);
+                                      XFA_ObjectType::ContainerNode);
   }
   static CXFA_Node* GetParent(CXFA_Node* pTemplateNode,
                               void* pUserData = NULL) {
     return pTemplateNode->GetNodeItem(XFA_NODEITEM_Parent,
-                                      XFA_OBJECTTYPE_ContainerNode);
+                                      XFA_ObjectType::ContainerNode);
   }
 };
 typedef CXFA_NodeIteratorTemplate<CXFA_Node,
                                   CXFA_TraverseStrategy_XFAContainerNode>
     CXFA_ContainerIterator;
 class CXFA_TraverseStrategy_XFANode {
  public:
   static inline CXFA_Node* GetFirstChild(CXFA_Node* pTemplateNode) {
     return pTemplateNode->GetNodeItem(XFA_NODEITEM_FirstChild);
   }
@@ skipping 30 matching lines @@
 
 inline CXFA_Node* ToNode(CXFA_Object* pObj) {
   return pObj ? pObj->AsNode() : nullptr;
 }
 
 inline const CXFA_Node* ToNode(const CXFA_Object* pObj) {
   return pObj ? pObj->AsNode() : nullptr;
 }
 
 #endif  // XFA_FXFA_PARSER_XFA_OBJECT_H_