Preliminary paint property walk implementation for SPv2

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

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  *           (C) 2004 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Google Inc. All rights reserved.
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 56 matching lines @@
 #include "core/layout/LayoutScrollbarPart.h"
 #include "core/layout/LayoutTableCaption.h"
 #include "core/layout/LayoutTableCell.h"
 #include "core/layout/LayoutTableCol.h"
 #include "core/layout/LayoutTableRow.h"
 #include "core/layout/LayoutTheme.h"
 #include "core/layout/LayoutView.h"
 #include "core/layout/compositing/PaintLayerCompositor.h"
 #include "core/page/AutoscrollController.h"
 #include "core/page/Page.h"
+#include "core/paint/ObjectPaintProperties.h"
 #include "core/paint/ObjectPainter.h"
 #include "core/paint/PaintInfo.h"
 #include "core/paint/PaintLayer.h"
 #include "core/style/ContentData.h"
 #include "core/style/ShadowList.h"
 #include "platform/HostWindow.h"
 #include "platform/JSONValues.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/TraceEvent.h"
 #include "platform/TracedValue.h"
@@ skipping 54 matching lines @@
     LayoutPoint position; // Stores the previous position from the paint invalidation container.
 };
 
 static_assert(sizeof(LayoutObject) == sizeof(SameSizeAsLayoutObject), "LayoutObject should stay small");
 
 bool LayoutObject::s_affectsParentBlock = false;
 
 typedef HashMap<const LayoutObject*, LayoutRect> SelectionPaintInvalidationMap;
 static SelectionPaintInvalidationMap* selectionPaintInvalidationMap = nullptr;
 
+typedef HashMap<const LayoutObject*, OwnPtr<ObjectPaintProperties>> ObjectPaintPropertiesMap;
+static ObjectPaintPropertiesMap* objectPaintPropertiesMap = nullptr;
+

[pdr., 2015/10/20 22:02:30]

To avoid having to create this map in ensureObjectPaintProperties, lets add a
static here:

// The storage for paint properties is temporarily implemented as a static
// map to avoid a memory regression if this were on LayoutObject. This is
// only used in slimming paint v2.
typedef HashMap<const LayoutObject*, OwnPtr<ObjectPaintProperties>>
ObjectPaintPropertiesMap;
static ObjectPaintPropertiesMap& objectPaintPropertiesMap()
{
    DEFINE_STATIC_LOCAL(ObjectPaintPropertiesMap,
staticObjectPaintPropertiesMap, ());
    return staticObjectPaintPropertiesMap;
}

[trchen, 2015/10/21 06:16:19]

Done.

 void* LayoutObject::operator new(size_t sz)
 {
     ASSERT(isMainThread());
     return partitionAlloc(WTF::Partitions::layoutPartition(), sz);
 }
 
 void LayoutObject::operator delete(void* ptr)
 {
     ASSERT(isMainThread());
     partitionFree(ptr);
@@ skipping 2345 matching lines @@
         EventHandlerRegistry& registry = document().frameHost()->eventHandlerRegistry();
         if (registry.eventHandlerTargets(EventHandlerRegistry::TouchEvent)->contains(node()))
             registry.didRemoveEventHandler(*node(), EventHandlerRegistry::TouchEvent);
     }
 
     setAncestorLineBoxDirty(false);
 
     if (selectionPaintInvalidationMap)
         selectionPaintInvalidationMap->remove(this);
 
+    if (objectPaintPropertiesMap) {

[pdr., 2015/10/20 22:02:30]

We should check for the property here instead of the map:

if (objectPaintProperties()) {
    ...
}

May need to update objectPaintProperties like so:
ObjectPaintProperties* LayoutObject::objectPaintProperties() const
{
    if (RuntimeEnabledFeatures::slimmingPaintV2Enabled())
        return objectPaintPropertiesMap().get(this);
    return nullptr;
}

[jbroman, 2015/10/20 23:50:13]

We could just do it unconditionally (well, perhaps with a REF check just to
avoid the assert). No need to search the hashmap twice (once to see if it's
there, and again to remove it). It should be safe to remove a non-existent
element.

[trchen, 2015/10/21 06:16:19]

Done as jbroman's proposal.

The check was to make sure there is no ObjectPaintProperties ever created in
non-SPv2 mode, but I agree the check was extraneous.

+        ASSERT(RuntimeEnabledFeatures::slimmingPaintV2Enabled());
+        clearObjectPaintProperties();
+    }
+
     clearLayoutRootIfNeeded();
 
     if (m_style) {
         for (const FillLayer* bgLayer = &m_style->backgroundLayers(); bgLayer; bgLayer = bgLayer->next()) {
             if (StyleImage* backgroundImage = bgLayer->image())
                 backgroundImage->removeClient(this);
         }
 
         for (const FillLayer* maskLayer = &m_style->maskLayers(); maskLayer; maskLayer = maskLayer->next()) {
             if (StyleImage* maskImage = maskLayer->image())
@@ skipping 925 matching lines @@
     ASSERT(frameView());
     if (m_bitfields.isSlowRepaintObject() == isSlowRepaintObject)
         return;
     m_bitfields.setIsSlowRepaintObject(isSlowRepaintObject);
     if (isSlowRepaintObject)
         frameView()->addSlowRepaintObject();
     else
         frameView()->removeSlowRepaintObject();
 }
 
+ObjectPaintProperties* LayoutObject::objectPaintProperties() const
+{
+    ASSERT(RuntimeEnabledFeatures::slimmingPaintV2Enabled());
+
+    if (!objectPaintPropertiesMap)
+        return nullptr;
+
+    return objectPaintPropertiesMap->get(this);
+}
+
+ObjectPaintProperties& LayoutObject::ensureObjectPaintProperties()
+{
+    ASSERT(RuntimeEnabledFeatures::slimmingPaintV2Enabled());
+
+    if (ObjectPaintProperties* properties = objectPaintProperties())
+        return *properties;
+
+    if (!objectPaintPropertiesMap)
+        objectPaintPropertiesMap = new ObjectPaintPropertiesMap;
+
+    return *objectPaintPropertiesMap->set(this, ObjectPaintProperties::create()).storedValue->value.get();
+}
+
+void LayoutObject::clearObjectPaintProperties()
+{
+    ASSERT(RuntimeEnabledFeatures::slimmingPaintV2Enabled());
+
+    if (!objectPaintPropertiesMap)
+        return;
+    objectPaintPropertiesMap->remove(this);
+}
+
 } // namespace blink
 
 #ifndef NDEBUG
 
 void showTree(const blink::LayoutObject* object)
 {
     if (object)
         object->showTreeForThis();
     else
         fprintf(stderr, "Cannot showTree. Root is (nil)\n");
@@ skipping 18 matching lines @@
         const blink::LayoutObject* root = object1;
         while (root->parent())
             root = root->parent();
         root->showLayoutTreeAndMark(object1, "*", object2, "-", 0);
     } else {
         fprintf(stderr, "Cannot showLayoutTree. Root is (nil)\n");
     }
 }
 
 #endif