Separate display item clients for negative and normal/positive z-order children

third_party/WebKit/Source/platform/graphics/paint/DisplayItemClient.h

 // Copyright 2015 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 DisplayItemClient_h
 #define DisplayItemClient_h
 
 #include "platform/PlatformExport.h"
 #include "platform/heap/Heap.h"
 #include "wtf/text/WTFString.h"
 
 namespace blink {
 
 class DisplayItemClientInternalVoid;
 using DisplayItemClient = const DisplayItemClientInternalVoid*;
 
 inline DisplayItemClient toDisplayItemClient(const void* object) { return static_cast<DisplayItemClient>(object); }
 
+// Allows one object to create multiple sub display item clients, each identified by subClientId.
+template <size_t subClientId, typename T>
+inline DisplayItemClient toSubDisplayItemClient(const T* object)
+{
+    static_assert(subClientId > 0 && subClientId < sizeof(T), "subClientId must be non-zero and within the size of the object");
+    return reinterpret_cast<DisplayItemClient>(reinterpret_cast<const char*>(object) + subClientId);

[chrishtr, 2015/11/04 23:37:11]

This is kind of hacky. Why do it this way?

[Xianzhu, 2015/11/05 00:30:28]

To allow one object to have multiple DisplayItemClient, the above code treats an
object as char[sizeof(object)], so that we can use the address of each char to
identify a sub-DisplayItemClient.

Another way is to make DisplayItemClient a tuple <void*, subClientId>, but this
may increase memory and cpu cost dealing with DisplayItemClient.

+}
+
 // Used to pass DisplayItemClient and debugName() (called only when needed) from
 // core/layout module etc. to platform/paint module.
 // The instance must not out-live the object. Long-time reference to a client must
 // use DisplayItemClient.
 class PLATFORM_EXPORT DisplayItemClientWrapper {
-    DISALLOW_NEW(); // Allow allocated in stack or in another object only.
+    DISALLOW_NEW_EXCEPT_PLACEMENT_NEW(); // Allow allocated in stack or in another object only.
 public:
     template <typename T>
     DisplayItemClientWrapper(const T& object)
         : m_displayItemClient(object.displayItemClient())
         , m_object(reinterpret_cast<const GenericClass&>(object))
         , m_debugNameInvoker(&invokeDebugName<T>)
     { }
 
+    // Allows one object to create multiple sub display item clients. Use like:
+    // DisplayItemClientWrapper(object, toSubDisplayItemClient<SubClientId>(&object), functionToGetDebugNameOfSubClient)
+    template <typename T>
+    DisplayItemClientWrapper(const T& object, DisplayItemClient displayItemClient, String (*debugNameInvoker)(const T&))
+        : m_displayItemClient(displayItemClient)
+        , m_object(reinterpret_cast<const GenericClass&>(object))
+        , m_debugNameInvoker(reinterpret_cast<DebugNameInvoker>(debugNameInvoker))
+    { }
+
     DisplayItemClientWrapper(const DisplayItemClientWrapper& other)
         : m_displayItemClient(other.m_displayItemClient)
         , m_object(other.m_object)
         , m_debugNameInvoker(other.m_debugNameInvoker)
     { }
 
     DisplayItemClient displayItemClient() const { return m_displayItemClient; }
     String debugName() const { return m_debugNameInvoker(m_object); }
 
 private:
     DisplayItemClientWrapper& operator=(const DisplayItemClientWrapper&) = delete;
 
     class GenericClass;
     template <typename T>
     static String invokeDebugName(const GenericClass& object) { return reinterpret_cast<const T&>(object).debugName(); }
 
+    using DebugNameInvoker = String (*)(const GenericClass&);
     DisplayItemClient m_displayItemClient;
     const GenericClass& m_object;
-    using DebugNameInvoker = String(*)(const GenericClass&);
     DebugNameInvoker m_debugNameInvoker;
 };
 
 }
 
 #endif // DisplayItemClient_h