Preliminary paint property walk implementation for SPv2

third_party/WebKit/Source/core/paint/ObjectPaintProperties.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 ObjectPaintProperties_h
 #define ObjectPaintProperties_h
 
 #include "platform/graphics/paint/TransformPaintPropertyNode.h"
+#include "wtf/HashMap.h"
+#include "wtf/OwnPtr.h"
+#include "wtf/PassOwnPtr.h"
 #include "wtf/PassRefPtr.h"
 #include "wtf/RefPtr.h"
 
 namespace blink {
 
 // The minimal set of paint properties created by a |LayoutObject|. These
 // properties encode a hierachy of transforms, clips, effects, etc, both between
 // LayoutObjects (each property has a parent) and among the properties of a
 // single LayoutObject (e.g., transform and perspective with the correct parent
 // relationship to represent ordering).
 //
 // This differs from |PaintChunkProperties| because it can store multiple
 // properties of the same type (e.g., transform and perspective which are both
 // transforms).
 class ObjectPaintProperties {
     WTF_MAKE_NONCOPYABLE(ObjectPaintProperties);
     WTF_MAKE_FAST_ALLOCATED(ObjectPaintProperties);
 public:
+    // This is intended to be inherited by FrameView and LayoutObject to hold ownership to

[pdr., 2015/10/15 04:53:52]

Would it be possible to use a simpler approach to handle FrameView where the
LayoutView includes the FrameView's transform?

It's very convenient to have a mapping from LayoutObject to PaintProperties.
Just as a small example, if you have a Owner pointer in a debugger, there's not
much you can do with that.

[pdr., 2015/10/15 22:05:59]

Talked with Tien-Ren about this and wanted to brain dump our findings. There
will only ever be one property node for the combination of frameview and
layoutview. In root-layer-scrolls mode (the future), layoutview holds the scroll
node. In non-root-layer-scrolls mode (going away), the frameview would hold the
scroll node. Tien-Ren is going to pursue this patch assuming root-layer-scrolls
so only LayoutObjects have paint properties, and he's going to put a TODO about
handling non-root-layer-scrolling.

[trchen, 2015/10/15 23:24:31]

Nah it's pretty simple to support. Also we always need to create a transform
node to establish the viewport anyway. No big deal to add another node for frame
scrolling.

+    // ObjectPaintProperties. Ideally we should simply use an OwnPtr but at this moment we
+    // use a global HashMap to avoid regressing non-SPv2 memory use. Thus we need this class
+    // to maintain RAII.
+    class Owner {
+    public:
+        ObjectPaintProperties* objectPaintProperties() const;
+        ObjectPaintProperties& ensureObjectPaintProperties();
+        void clearObjectPaintProperties();
+    protected:
+        ~Owner();
+    private:
+        typedef HashMap<const ObjectPaintProperties::Owner*, OwnPtr<ObjectPaintProperties>> NodeMapping;
+        static NodeMapping* s_nodeMapping;
+    };
+
     static PassOwnPtr<ObjectPaintProperties> create()
     {
         return adoptPtr(new ObjectPaintProperties());
     }
 
-    bool hasTransform() const { return m_transform; }
-    void setTransform(PassRefPtr<TransformPaintPropertyNode> transform) { m_transform = transform; }
-    const TransformPaintPropertyNode* transform() const { return m_transform.get(); }
+    void setTransformNodeForSelf(PassRefPtr<TransformPaintPropertyNode> node) { m_transformNodeForSelf = node; }
+    const TransformPaintPropertyNode* transformNodeForSelf() const { return m_transformNodeForSelf.get(); }
 
-    bool hasPerspective() const { return m_perspective; }
-    void setPerspective(PassRefPtr<TransformPaintPropertyNode> perspective) { m_perspective = perspective; }
-    const TransformPaintPropertyNode* perspective() const { return m_perspective.get(); }
+    void setTransformNodeForDescendants(PassRefPtr<TransformPaintPropertyNode> node) { m_transformNodeForDescendants = node; }
+    const TransformPaintPropertyNode* transformNodeForDescendants() const { return m_transformNodeForDescendants.get(); }
 
 private:
     ObjectPaintProperties() { }
 
-    RefPtr<TransformPaintPropertyNode> m_transform;
-    RefPtr<TransformPaintPropertyNode> m_perspective;
+    RefPtr<TransformPaintPropertyNode> m_transformNodeForSelf;
+    RefPtr<TransformPaintPropertyNode> m_transformNodeForDescendants;
 };
 
 } // namespace blink
 
 #endif // ObjectPaintProperties_h