Make ifdefs consistent in WebKit/Source/core/

third_party/WebKit/Source/core/layout/LayoutObject.h

 /*
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
  *           (C) 2000 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  *           (C) 2004 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2012 Apple Inc.
  *               All rights reserved.
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 78 matching lines @@
 struct AnnotatedRegionValue {
   DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
   bool operator==(const AnnotatedRegionValue& o) const {
     return draggable == o.draggable && bounds == o.bounds;
   }
 
   LayoutRect bounds;
   bool draggable;
 };
 
-#ifndef NDEBUG
+#if DCHECK_IS_ON()
 const int showTreeCharacterOffset = 39;
 #endif
 
 // LayoutObject is the base class for all layout tree objects.
 //
 // LayoutObjects form a tree structure that is a close mapping of the DOM tree.
 // The root of the LayoutObject tree is the LayoutView, which is the
 // LayoutObject associated with the Document.
 //
 // Some LayoutObjects don't have an associated Node and are called "anonymous"
@@ skipping 175 matching lines @@
   LayoutBox* enclosingScrollableBox() const;
 
   // Function to return our enclosing flow thread if we are contained inside
   // one. This function follows the containing block chain.
   LayoutFlowThread* flowThreadContainingBlock() const {
     if (!isInsideFlowThread())
       return nullptr;
     return locateFlowThreadContainingBlock();
   }
 
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
   void setHasAXObject(bool flag) { m_hasAXObject = flag; }
   bool hasAXObject() const { return m_hasAXObject; }
 
   // Helper class forbidding calls to setNeedsLayout() during its lifetime.
   class SetLayoutNeededForbiddenScope {
    public:
     explicit SetLayoutNeededForbiddenScope(LayoutObject&);
     ~SetLayoutNeededForbiddenScope();
 
    private:
     LayoutObject& m_layoutObject;
     bool m_preexistingForbidden;
   };
 
   void assertLaidOut() const {
-#ifndef NDEBUG
     if (needsLayout())
       showLayoutTreeForThis();
-#endif
     SECURITY_DCHECK(!needsLayout());
   }
 
   void assertSubtreeIsLaidOut() const {
     for (const LayoutObject* layoutObject = this; layoutObject;
          layoutObject = layoutObject->nextInPreOrder())
       layoutObject->assertLaidOut();
   }
 
   void assertClearedPaintInvalidationFlags() const {
-#ifndef NDEBUG
     if (paintInvalidationStateIsDirty()) {
       showLayoutTreeForThis();
       ASSERT_NOT_REACHED();
     }
-#endif
   }
 
   void assertSubtreeClearedPaintInvalidationFlags() const {
     for (const LayoutObject* layoutObject = this; layoutObject;
          layoutObject = layoutObject->nextInPreOrder())
       layoutObject->assertClearedPaintInvalidationFlags();
   }
 
 #endif
 
@@ skipping 71 matching lines @@
     // if we're not a LayoutFlowThread.
     // A LayoutFlowThread is always considered to be inside itself, so it never
     // has to change its state in response to parent changes.
     bool insideFlowThread = parent && parent->isInsideFlowThread();
     if (insideFlowThread != isInsideFlowThread() && !isLayoutFlowThread())
       setIsInsideFlowThreadIncludingDescendants(insideFlowThread);
   }
 
   //////////////////////////////////////////
  private:
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
   bool isSetNeedsLayoutForbidden() const { return m_setNeedsLayoutForbidden; }
   void setNeedsLayoutIsForbidden(bool flag) {
     m_setNeedsLayoutForbidden = flag;
   }
 #endif
 
   void addAbsoluteRectForLayer(IntRect& result);
   bool requiresAnonymousTableWrappers(const LayoutObject*) const;
 
   // Gets pseudoStyle from Shadow host(in case of input elements)
   // or from Parent element.
   PassRefPtr<ComputedStyle> getUncachedPseudoStyleFromParentOrShadowHost()
       const;
 
  public:
-#ifndef NDEBUG
+#if DCHECK_IS_ON()

[mstensho (USE GERRIT), 2016/11/29 12:06:12]

I don't think these have anything to do with assertions. I call them from gdb. I
don't know if they are used for other things conditioned on !NDEBUG in the code,
but probably not.

Anyway, I think #ifndef NDEBUG is the right way here.

   void showTreeForThis() const;
   void showLayoutTreeForThis() const;
   void showLineTreeForThis() const;
 
   void showLayoutObject() const;
   // We don't make stringBuilder an optional parameter so that
   // showLayoutObject can be called from gdb easily.
   void showLayoutObject(StringBuilder&) const;
   void showLayoutTreeAndMark(const LayoutObject* markedObject1 = nullptr,
                              const char* markedLabel1 = nullptr,
@@ skipping 1583 matching lines @@
   void removeFromLayoutFlowThreadRecursive(LayoutFlowThread*);
 
   ComputedStyle* cachedFirstLineStyle() const;
   StyleDifference adjustStyleDifference(StyleDifference) const;
 
   Color selectionColor(int colorProperty, const GlobalPaintFlags) const;
 
   void removeShapeImageClient(ShapeValue*);
   void removeCursorImageClient(const CursorList*);
 
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
   void checkBlockPositionedObjectsNeedLayout();
 #endif
 
   bool isTextOrSVGChild() const {
     return isText() || (isSVG() && !isSVGRoot());
   }
 
   static bool isAllowedToModifyLayoutTreeStructure(Document&);
 
   // Returns the parent for paint invalidation.
   // - For LayoutView, returns the owner layout object in the containing frame
   //   if any or nullptr;
   // - For multi-column spanner, returns the spanner placeholder;
   // - Otherwise returns parent().
   LayoutObject* paintInvalidationParent() const;
 
   RefPtr<ComputedStyle> m_style;
 
   // Oilpan: This untraced pointer to the owning Node is considered safe.
   UntracedMember<Node> m_node;
 
   LayoutObject* m_parent;
   LayoutObject* m_previous;
   LayoutObject* m_next;
 
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
   unsigned m_hasAXObject : 1;
   unsigned m_setNeedsLayoutForbidden : 1;
 #endif
 
 #define ADD_BOOLEAN_BITFIELD(name, Name) \
  private:                                \
   unsigned m_##name : 1;                 \
                                          \
  public:                                 \
   bool name() const { return m_##name; } \
@@ skipping 434 matching lines @@
   setMayNeedPaintInvalidation();
 
   // Clear needsLayout flags.
   setSelfNeedsLayout(false);
   setPosChildNeedsLayout(false);
   setNeedsSimplifiedNormalFlowLayout(false);
   setNormalChildNeedsLayout(false);
   setNeedsPositionedMovementLayout(false);
   setAncestorLineBoxDirty(false);
 
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
   checkBlockPositionedObjectsNeedLayout();
 #endif
 
   setScrollAnchorDisablingStyleChanged(false);
 }
 
 inline void LayoutObject::setChildNeedsLayout(MarkingBehavior markParents,
                                               SubtreeLayoutScope* layouter) {
   ASSERT(!isSetNeedsLayoutForbidden());
   bool alreadyNeededLayout = normalChildNeedsLayout();
@@ skipping 98 matching lines @@
   ASSERT(layoutObject.style());
   return adjustScrollForAbsoluteZoom(value, *layoutObject.style());
 }
 
 #define DEFINE_LAYOUT_OBJECT_TYPE_CASTS(thisType, predicate)           \
   DEFINE_TYPE_CASTS(thisType, LayoutObject, object, object->predicate, \
                     object.predicate)
 
 }  // namespace blink
 
-#ifndef NDEBUG
+#if DCHECK_IS_ON()
 // Outside the blink namespace for ease of invocation from gdb.
 CORE_EXPORT void showTree(const blink::LayoutObject*);
 CORE_EXPORT void showLineTree(const blink::LayoutObject*);
 CORE_EXPORT void showLayoutTree(const blink::LayoutObject* object1);
 // We don't make object2 an optional parameter so that showLayoutTree
 // can be called from gdb easily.
 CORE_EXPORT void showLayoutTree(const blink::LayoutObject* object1,
                                 const blink::LayoutObject* object2);
 
 #endif
 
 #endif  // LayoutObject_h