Move the Widget hierarchy to the Oilpan heap.

Source/core/rendering/RenderScrollbar.cpp

 /*
  * Copyright (C) 2008, 2009 Apple Inc. All Rights Reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 18 matching lines @@
 #include "core/css/PseudoStyleRequest.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/rendering/RenderPart.h"
 #include "core/rendering/RenderScrollbarPart.h"
 #include "core/rendering/RenderScrollbarTheme.h"
 #include "platform/graphics/GraphicsContext.h"
 
 namespace blink {
 
-PassRefPtr<Scrollbar> RenderScrollbar::createCustomScrollbar(ScrollableArea* scrollableArea, ScrollbarOrientation orientation, Node* ownerNode, LocalFrame* owningFrame)
+PassRefPtrWillBeRawPtr<Scrollbar> RenderScrollbar::createCustomScrollbar(ScrollableArea* scrollableArea, ScrollbarOrientation orientation, Node* ownerNode, LocalFrame* owningFrame)
 {
-    return adoptRef(new RenderScrollbar(scrollableArea, orientation, ownerNode, owningFrame));
+    return adoptRefWillBeNoop(new RenderScrollbar(scrollableArea, orientation, ownerNode, owningFrame));
 }
 
 RenderScrollbar::RenderScrollbar(ScrollableArea* scrollableArea, ScrollbarOrientation orientation, Node* ownerNode, LocalFrame* owningFrame)
     : Scrollbar(scrollableArea, orientation, RegularScrollbar, RenderScrollbarTheme::renderScrollbarTheme())
     , m_owner(ownerNode)
     , m_owningFrame(owningFrame)
+#if ENABLE(OILPAN)
+    , m_updatePartsMap(true)
+#endif
 {
     ASSERT(ownerNode || owningFrame);
 
     // FIXME: We need to do this because RenderScrollbar::styleChanged is called as soon as the scrollbar is created.
 
     // Update the scrollbar size.
     int width = 0;
     int height = 0;
     updateScrollbarPart(ScrollbarBGPart);
     if (RenderScrollbarPart* part = m_parts.get(ScrollbarBGPart)) {
         part->layout();
         width = part->width();
         height = part->height();
     } else if (this->orientation() == HorizontalScrollbar)
         width = this->width();
     else
         height = this->height();
 
     setFrameRect(IntRect(0, 0, width, height));
+
+#if ENABLE(OILPAN)
+    ThreadState::current()->registerPreFinalizer(*this);
+#endif
 }
 
 RenderScrollbar::~RenderScrollbar()
 {
-    if (!m_parts.isEmpty()) {
-        // When a scrollbar is detached from its parent (causing all parts removal) and
-        // ready to be destroyed, its destruction can be delayed because of RefPtr
-        // maintained in other classes such as EventHandler (m_lastScrollbarUnderMouse).
-        // Meanwhile, we can have a call to updateScrollbarPart which recreates the
-        // scrollbar part. So, we need to destroy these parts since we don't want them
-        // to call on a destroyed scrollbar. See webkit bug 68009.
-        updateScrollbarParts(true);
-    }
+    // Oilpan: to be able to access the hash map that's
+    // also on the heap, a pre-destruction finalizer is used.
+#if !ENABLE(OILPAN)
+    destroyParts();
+#endif
+}
+
+void RenderScrollbar::destroyParts()
+{
+    if (m_parts.isEmpty())
+        return;
+
+#if ENABLE(OILPAN)
+    m_updatePartsMap = false;
+#endif
+
+    // When a scrollbar is detached from its parent (causing all parts removal) and
+    // ready to be destroyed, its destruction can be delayed because of RefPtr
+    // maintained in other classes such as EventHandler (m_lastScrollbarUnderMouse).
+    // Meanwhile, we can have a call to updateScrollbarPart which recreates the
+    // scrollbar part. So, we need to destroy these parts since we don't want them
+    // to call on a destroyed scrollbar. See webkit bug 68009.
+    //
+    updateScrollbarParts(true);
+}
+
+void RenderScrollbar::trace(Visitor* visitor)
+{
+#if ENABLE(OILPAN)
+    visitor->trace(m_owner);
+    visitor->trace(m_owningFrame);
+    visitor->trace(m_parts);
+#endif
+    Scrollbar::trace(visitor);
 }
 
 RenderBox* RenderScrollbar::owningRenderer() const
 {
     if (m_owningFrame) {
         RenderBox* currentRenderer = m_owningFrame->ownerRenderer();
         return currentRenderer;
     }
     return m_owner && m_owner->renderer() ? m_owner->renderer()->enclosingBox() : 0;
 }
@@ skipping 145 matching lines @@
                 break;
             case ForwardButtonEndPart:
                 needRenderer = (buttonsPlacement == ScrollbarButtonsSingle || buttonsPlacement == ScrollbarButtonsDoubleEnd ||
                                 buttonsPlacement == ScrollbarButtonsDoubleBoth);
                 break;
             default:
                 break;
         }
     }
 
+#if ENABLE(OILPAN)
+    const bool updatePartsMap = m_updatePartsMap;
+#else
+    const bool updatePartsMap = true;
+#endif
     RenderScrollbarPart* partRenderer = m_parts.get(partType);
     if (!partRenderer && needRenderer) {
         partRenderer = RenderScrollbarPart::createAnonymous(&owningRenderer()->document(), this, partType);
-        m_parts.set(partType, partRenderer);
+        if (updatePartsMap)

[haraken, 2014/10/10 02:50:32]

Why do you need this condition? Given that m_parts is a HeapHashMap, rehashing
of the hash map is disabled while pre-finalizers are running. Thus I guess we
won't need the m_updatePartsMap flag.

[sof, 2014/10/10 05:22:19]

ok, I simply prefer not to rely on there being no work/allocation done.

[sof, 2014/10/10 08:40:55]

To drive things forward, dropped the flag & rely on HeapHashMap.

+            m_parts.set(partType, partRenderer);
     } else if (partRenderer && !needRenderer) {
-        m_parts.remove(partType);
+        if (updatePartsMap)
+            m_parts.remove(partType);
         partRenderer->destroy();
         partRenderer = 0;
     }
 
     if (partRenderer)
         partRenderer->setStyle(partStyle.release());
 }
 
 IntRect RenderScrollbar::buttonRect(ScrollbarPart partType)
 {
@@ skipping 73 matching lines @@
 int RenderScrollbar::minimumThumbLength()
 {
     RenderScrollbarPart* partRenderer = m_parts.get(ThumbPart);
     if (!partRenderer)
         return 0;
     partRenderer->layout();
     return orientation() == HorizontalScrollbar ? partRenderer->width() : partRenderer->height();
 }
 
 }