Oilpan: Prepare moving InspectorAgent related classes to oilpan

Source/core/inspector/InspectorDOMAgent.cpp

 /*
  * Copyright (C) 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2011 Google Inc. All rights reserved.
  * Copyright (C) 2009 Joseph Pecoraro
  *
  * 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
@@ skipping 162 matching lines @@
 }
 
 static Node* hoveredNodeForEvent(LocalFrame* frame, const PlatformTouchEvent& event, bool ignorePointerEventsNone)
 {
     const Vector<PlatformTouchPoint>& points = event.touchPoints();
     if (!points.size())
         return 0;
     return hoveredNodeForPoint(frame, roundedIntPoint(points[0].pos()), ignorePointerEventsNone);
 }
 
-class RevalidateStyleAttributeTask {
-    WTF_MAKE_FAST_ALLOCATED;
+class RevalidateStyleAttributeTask : public NoBaseWillBeGarbageCollectedFinalized<RevalidateStyleAttributeTask> {
+    WTF_MAKE_FAST_ALLOCATED_WILL_BE_REMOVED;
 public:
     RevalidateStyleAttributeTask(InspectorDOMAgent*);

[haraken, 2014/06/19 05:49:53]

Add explicit.

[keishi, 2014/07/24 02:15:02]

Done.

     void scheduleFor(Element*);
     void reset() { m_timer.stop(); }
     void onTimer(Timer<RevalidateStyleAttributeTask>*);
+    void trace(Visitor*);
 
 private:
-    InspectorDOMAgent* m_domAgent;
+    RawPtrWillBeMember<InspectorDOMAgent> m_domAgent;
     Timer<RevalidateStyleAttributeTask> m_timer;
-    WillBePersistentHeapHashSet<RefPtrWillBeMember<Element> > m_elements;
+    WillBeHeapHashSet<RefPtrWillBeMember<Element> > m_elements;
 };
 
 RevalidateStyleAttributeTask::RevalidateStyleAttributeTask(InspectorDOMAgent* domAgent)
     : m_domAgent(domAgent)
     , m_timer(this, &RevalidateStyleAttributeTask::onTimer)
 {
 }
 
 void RevalidateStyleAttributeTask::scheduleFor(Element* element)
 {
     m_elements.add(element);
     if (!m_timer.isActive())
         m_timer.startOneShot(0, FROM_HERE);
 }
 
 void RevalidateStyleAttributeTask::onTimer(Timer<RevalidateStyleAttributeTask>*)
 {
     // The timer is stopped on m_domAgent destruction, so this method will never be called after m_domAgent has been destroyed.
     WillBeHeapVector<RawPtrWillBeMember<Element> > elements;
     for (WillBePersistentHeapHashSet<RefPtrWillBeMember<Element> >::iterator it = m_elements.begin(), end = m_elements.end(); it != end; ++it)
         elements.append(it->get());
     m_domAgent->styleAttributeInvalidated(elements);
 
     m_elements.clear();
 }
 
+void RevalidateStyleAttributeTask::trace(Visitor* visitor)
+{
+    visitor->trace(m_domAgent);
+    visitor->trace(m_elements);
+}
+
 String InspectorDOMAgent::toErrorString(ExceptionState& exceptionState)
 {
     if (exceptionState.hadException())
         return DOMException::getErrorName(exceptionState.code()) + " " + exceptionState.message();
     return "";
 }
 
 InspectorDOMAgent::InspectorDOMAgent(InspectorPageAgent* pageAgent, InjectedScriptManager* injectedScriptManager, InspectorOverlay* overlay)
     : InspectorBaseAgent<InspectorDOMAgent>("DOM")
     , m_pageAgent(pageAgent)
@@ skipping 403 matching lines @@
     for (unsigned i = 0; i < nodes->length(); ++i)
         result->addItem(pushNodePathToFrontend(nodes->item(i)));
 }
 
 int InspectorDOMAgent::pushNodePathToFrontend(Node* nodeToPush)
 {
     ASSERT(nodeToPush);  // Invalid input
 
     if (!m_document)
         return 0;
-    // FIXME: Oilpan: .get will be unnecessary if m_document is a Member<>.
-    if (!m_documentNodeToIdMap->contains(m_document.get()))
+    if (!m_documentNodeToIdMap->contains(m_document))
         return 0;
 
     // Return id in case the node is known.
     int result = m_documentNodeToIdMap->get(nodeToPush);
     if (result)
         return result;
 
     Node* node = nodeToPush;
     Vector<Node*> path;
     NodeToIdMap* danglingMap = 0;
@@ skipping 1253 matching lines @@
 }
 
 void InspectorDOMAgent::didInvalidateStyleAttr(Node* node)
 {
     int id = m_documentNodeToIdMap->get(node);
     // If node is not mapped yet -> ignore the event.
     if (!id)
         return;
 
     if (!m_revalidateStyleAttrTask)
-        m_revalidateStyleAttrTask = adoptPtr(new RevalidateStyleAttributeTask(this));
+        m_revalidateStyleAttrTask = adoptPtrWillBeNoop(new RevalidateStyleAttributeTask(this));
     m_revalidateStyleAttrTask->scheduleFor(toElement(node));
 }
 
 void InspectorDOMAgent::didPushShadowRoot(Element* host, ShadowRoot* root)
 {
     if (!host->ownerDocument())
         return;
 
     int hostId = m_documentNodeToIdMap->get(host);
     if (!hostId)
@@ skipping 159 matching lines @@
 
     InjectedScript injectedScript = m_injectedScriptManager->injectedScriptFor(ScriptState::forMainWorld(frame));
     if (injectedScript.isEmpty())
         return nullptr;
 
     return injectedScript.wrapNode(node, objectGroup);
 }
 
 bool InspectorDOMAgent::pushDocumentUponHandlelessOperation(ErrorString* errorString)
 {
-    // FIXME: Oilpan: .get will be unnecessary if m_document is a Member<>.
-    if (!m_documentNodeToIdMap->contains(m_document.get())) {
+    if (!m_documentNodeToIdMap->contains(m_document)) {
         RefPtr<TypeBuilder::DOM::Node> root;
         getDocument(errorString, root);
         return errorString->isEmpty();
     }
     return true;
 }
 
 void InspectorDOMAgent::trace(Visitor* visitor)
 {
     visitor->trace(m_domListener);
     visitor->trace(m_pageAgent);
+    visitor->trace(m_injectedScriptManager);
 #if ENABLE(OILPAN)
     visitor->trace(m_documentNodeToIdMap);
     visitor->trace(m_danglingNodeToIdMaps);
     visitor->trace(m_idToNode);
 #endif
     visitor->trace(m_idToNodesMap);
     visitor->trace(m_document);
+    visitor->trace(m_revalidateStyleAttrTask);
     visitor->trace(m_searchResults);
     visitor->trace(m_history);
     visitor->trace(m_domEditor);
     visitor->trace(m_listener);
     InspectorBaseAgent::trace(visitor);
 }
 
 } // namespace WebCore