Avoid re-iterate out-of-order display items

Source/platform/graphics/paint/DisplayItem.h

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef DisplayItem_h
 #define DisplayItem_h
 
 #include "platform/PlatformExport.h"
 #include "platform/graphics/ContiguousContainer.h"
 #include "platform/graphics/paint/DisplayItemClient.h"
@@ skipping 166 matching lines @@
         UninitializedType,
         TypeLast = UninitializedType
     };
 
     DisplayItem(const DisplayItemClientWrapper& client, Type type, size_t derivedSize)
         : m_client(client.displayItemClient())
         , m_scope(0)
         , m_type(type)
         , m_derivedSize(derivedSize)
         , m_skippedCache(false)
-        , m_ignoredFromList(false)
 #ifndef NDEBUG
         , m_clientDebugString(client.debugName())
 #endif
     {
         // derivedSize must fit in m_derivedSize.
         // If it doesn't, enlarge m_derivedSize and fix this assert.
         ASSERT_WITH_SECURITY_IMPLICATION(derivedSize < (1 << 8));
         ASSERT_WITH_SECURITY_IMPLICATION(derivedSize >= sizeof(*this));
     }
 
@@ skipping 124 matching lines @@
 
     virtual bool isBegin() const { return false; }
     virtual bool isEnd() const { return false; }
 
 #if ENABLE(ASSERT)
     virtual bool isEndAndPairedWith(DisplayItem::Type otherType) const { return false; }
 #endif
 
     virtual bool drawsContent() const { return false; }
 
-    bool ignoreFromDisplayList() const { return m_ignoredFromList; }
-    void setIgnoredFromDisplayList() { m_ignoredFromList = true; }
+    bool isValid() const { return m_client; }
+    void invalidate() { new (this) DisplayItem; }

[pdr., 2015/08/17 23:28:50]

Will this run the DisplayItem subclass destructors?

The in-place new constructor is rarely used in blink. Can you add a comment such
as:
// Re-construct this display item as a permanently invalid item with no client
set.

[Xianzhu, 2015/08/17 23:46:58]

No but needed. Added an in-place destructor call.
Done.

 
 #ifndef NDEBUG
     static WTF::String typeAsDebugString(DisplayItem::Type);
     const WTF::String& clientDebugString() const { return m_clientDebugString; }
     WTF::String asDebugString() const;
     virtual void dumpPropertiesAsDebugString(WTF::StringBuilder&) const;
 #endif
 
 private:
     // The default DisplayItem constructor is only used by
     // ContiguousContainer::appendByMoving where an invalid DisplaItem is
     // constructed at the source location.
     template <typename T, unsigned alignment> friend class ContiguousContainer;
 
     DisplayItem()
         : m_client(nullptr)
         , m_scope(0)
         , m_type(UninitializedType)
         , m_derivedSize(sizeof(*this))
         , m_skippedCache(false)
-        , m_ignoredFromList(true)
 #ifndef NDEBUG
         , m_clientDebugString("invalid")
 #endif
     { }
 
     const DisplayItemClient m_client;
     unsigned m_scope;
     static_assert(TypeLast < (1 << 16), "DisplayItem::Type should fit in 16 bits");
     const Type m_type : 16;
     unsigned m_derivedSize : 8; // size of the actual derived class
     unsigned m_skippedCache : 1;
-    unsigned m_ignoredFromList : 1;
 
 #ifndef NDEBUG
     WTF::String m_clientDebugString;
 #endif
 };
 
 class PLATFORM_EXPORT PairedBeginDisplayItem : public DisplayItem {
 protected:
     PairedBeginDisplayItem(const DisplayItemClientWrapper& client, Type type, size_t derivedSize) : DisplayItem(client, type, derivedSize) { }
 
 private:
     bool isBegin() const final { return true; }
 };
 
 class PLATFORM_EXPORT PairedEndDisplayItem : public DisplayItem {
 protected:
     PairedEndDisplayItem(const DisplayItemClientWrapper& client, Type type, size_t derivedSize) : DisplayItem(client, type, derivedSize) { }
 
 #if ENABLE(ASSERT)
     bool isEndAndPairedWith(DisplayItem::Type otherType) const override = 0;
 #endif
 
 private:
     bool isEnd() const final { return true; }
 };
 
 } // namespace blink
 
 #endif // DisplayItem_h