Oilpan: Move all supplements of Page, Document, and WorkerClients to the managed heap.

Source/core/dom/EventHandlerRegistry.cpp

 // 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.
 
 #include "config.h"
 #include "core/dom/EventHandlerRegistry.h"
 
 #include "core/dom/Document.h"
 #include "core/events/ThreadLocalEventNames.h"
 #include "core/events/WheelEvent.h"
@@ skipping 26 matching lines @@
 const char* EventHandlerRegistry::supplementName()
 {
     return "EventHandlerRegistry";
 }
 
 EventHandlerRegistry* EventHandlerRegistry::from(Document& document)
 {
     EventHandlerRegistry* registry = static_cast<EventHandlerRegistry*>(DocumentSupplement::from(document, supplementName()));
     if (!registry) {
         registry = new EventHandlerRegistry(document);
-        DocumentSupplement::provideTo(document, supplementName(), adoptPtr(registry));
+        DocumentSupplement::provideTo(document, supplementName(), adoptPtrWillBeNoop(registry));
     }
     return registry;
 }
 
 bool EventHandlerRegistry::eventTypeToClass(const AtomicString& eventType, EventHandlerClass* result)
 {
     if (eventType == EventTypeNames::scroll) {
         *result = ScrollEvent;
     } else {
         return false;
@@ skipping 134 matching lines @@
     case ScrollEvent:
         if (scrollingCoordinator)
             scrollingCoordinator->updateHaveScrollEventHandlers();
         break;
     default:
         ASSERT_NOT_REACHED();
         break;
     }
 }
 
+void EventHandlerRegistry::trace(Visitor* visitor)
+{
+    // FIXME: Oilpan: This is pretty funky. The current code disables all modifications of the
+    // EventHandlerRegistry when the document becomes inactive. To keep that behavior we only
+    // perform weak processing of the registry when the document is active.
+    if (m_document.isActive())

[haraken, 2014/04/30 02:41:22]

Nit: This is OK but I'd move the m_document.isActive() check and the comment
into clearWeakMembers. trace() should just trace things and we don't want to do
something non-trivial into trace().

[zerny-chromium, 2014/04/30 08:29:34]

Done.

+        visitor->registerWeakMembers<EventHandlerRegistry, &EventHandlerRegistry::clearWeakMembers>(this);
+}
+
 void EventHandlerRegistry::clearWeakMembers(Visitor* visitor)
 {
     Vector<EventTarget*> deadNodeTargets;
     for (size_t i = 0; i < EventHandlerClassCount; ++i) {
         EventHandlerClass handlerClass = static_cast<EventHandlerClass>(i);
         const EventTargetSet* targets = eventHandlerTargets(handlerClass);
         if (!targets)
             continue;
         for (EventTargetSet::const_iterator it = targets->begin(); it != targets->end(); ++it) {
             Node* node = it->key->toNode();
             if (node && !visitor->isAlive(node))
                 deadNodeTargets.append(node);
         }
     }
     for (size_t i = 0; i < deadNodeTargets.size(); ++i)
         didRemoveAllEventHandlers(*deadNodeTargets[i]);
 }
 
 } // namespace WebCore