Oilpan: have PendingScripts trace their script elements.

Source/core/dom/ScriptRunner.h

 /*
  * Copyright (C) 2010 Google, 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 21 matching lines @@
 #include "wtf/Noncopyable.h"
 #include "wtf/PassOwnPtr.h"
 #include "wtf/Vector.h"
 
 namespace WebCore {
 
 class ScriptResource;
 class Document;
 class PendingScript;
 class ScriptLoader;
+class Visitor;
 
 class ScriptRunner {

[Mads Ager (chromium), 2014/05/26 13:55:36]

I think we could move ScriptRunner to the oilpan heap without issues.
ScriptRunner is owned by the Document and as far as I can tell it is only ever
destructed when the document is going away as well. The only thing it does is
decrement delay-the-load event counts in the document. However, if the document
is going away that shouldn't be necessary (we will not dispatch a load event
when the document is dead anyway)? If that reasoning is correct we should be
able to move this to the heap and have traced Members in both directions and not
update any counts in the destructor here.

[sof, 2014/05/27 08:31:04]

Yes, moving ScriptRunner is doable and easier than its parser counter part
HTMLScriptRunner.

Decrementing those Document counts doesn't seem like a productive operation
Oilpan or not; I emptied the destructor.

     WTF_MAKE_NONCOPYABLE(ScriptRunner); WTF_MAKE_FAST_ALLOCATED;
 public:
     static PassOwnPtr<ScriptRunner> create(Document* document) { return adoptPtr(new ScriptRunner(document)); }
     ~ScriptRunner();
 
     enum ExecutionType { ASYNC_EXECUTION, IN_ORDER_EXECUTION };
     void queueScriptForExecution(ScriptLoader*, ResourcePtr<ScriptResource>, ExecutionType);
     bool hasPendingScripts() const { return !m_scriptsToExecuteSoon.isEmpty() || !m_scriptsToExecuteInOrder.isEmpty() || !m_pendingAsyncScripts.isEmpty(); }
     void suspend();
     void resume();
     void notifyScriptReady(ScriptLoader*, ExecutionType);
     void notifyScriptLoadError(ScriptLoader*, ExecutionType);
 
+    void trace(Visitor*);
+
 private:
     explicit ScriptRunner(Document*);
 
     void timerFired(Timer<ScriptRunner>*);
 
     Document* m_document;
     Vector<PendingScript> m_scriptsToExecuteInOrder;
     Vector<PendingScript> m_scriptsToExecuteSoon; // http://www.whatwg.org/specs/web-apps/current-work/#set-of-scripts-that-will-execute-as-soon-as-possible
     HashMap<ScriptLoader*, PendingScript> m_pendingAsyncScripts;
     Timer<ScriptRunner> m_timer;
 };
 
 }
 
 #endif