Don't be so CRASH happy in the bindings layer.

WebCore/bindings/generic/ActiveDOMCallback.cpp

Index: WebCore/bindings/generic/ActiveDOMCallback.cpp
===================================================================
--- WebCore/bindings/generic/ActiveDOMCallback.cpp	(revision 109601)
+++ WebCore/bindings/generic/ActiveDOMCallback.cpp	(working copy)
@@ -33,111 +33,34 @@
 
 #include "ActiveDOMObject.h"
 #include "ScriptExecutionContext.h"
-#include <wtf/PassOwnPtr.h>
-#include <wtf/ThreadingPrimitives.h>
+#include "WorkerContext.h"
 
 namespace WebCore {
 
-static void destroyOnContextThread(PassOwnPtr<ActiveDOMObjectCallbackImpl>);
-
-class DestroyOnContextThreadTask : public ScriptExecutionContext::Task {
-public:
-    static PassOwnPtr<DestroyOnContextThreadTask> create(PassOwnPtr<ActiveDOMObjectCallbackImpl> impl)
-    {
-        return adoptPtr(new DestroyOnContextThreadTask(impl));
-    }
-
-    virtual void performTask(ScriptExecutionContext*)
-    {
-        destroyOnContextThread(m_impl.release());
-    }
-
-private:
-    DestroyOnContextThreadTask(PassOwnPtr<ActiveDOMObjectCallbackImpl> impl)
-        : m_impl(impl)
-    {
-    }
-
-    OwnPtr<ActiveDOMObjectCallbackImpl> m_impl;
-};
-
-class ActiveDOMObjectCallbackImpl : public ActiveDOMObject {
-public:
-    ActiveDOMObjectCallbackImpl(ScriptExecutionContext* context)
-        : ActiveDOMObject(context, this)
-        , m_suspended(false)
-        , m_stopped(false)
-    {
-    }
-
-    virtual void contextDestroyed()
-    {
-        MutexLocker locker(m_mutex);
-        ActiveDOMObject::contextDestroyed();
-    }
-    virtual bool canSuspend() const { return false; }
-    virtual void suspend(ReasonForSuspension)
-    {
-        MutexLocker locker(m_mutex);
-        m_suspended = true;
-    }
-    virtual void resume()
-    {
-        MutexLocker locker(m_mutex);
-        m_suspended = false;
-    }
-    virtual void stop()
-    {
-        MutexLocker locker(m_mutex);
-        m_stopped = true;
-    }
-    bool canInvokeCallback()
-    {
-        MutexLocker locker(m_mutex);
-        return (!m_suspended && !m_stopped);
-    }
-    ScriptExecutionContext* scriptExecutionContext()
-    {
-        MutexLocker locker(m_mutex);
-        return ActiveDOMObject::scriptExecutionContext();
-    }
-    Mutex& mutex() { return m_mutex; }
-
-private:
-    Mutex m_mutex;
-    bool m_suspended;
-    bool m_stopped;
-};
-
-static void destroyOnContextThread(PassOwnPtr<ActiveDOMObjectCallbackImpl> impl)
-{
-    OwnPtr<ActiveDOMObjectCallbackImpl> implOwnPtr = impl;
-
-    ScriptExecutionContext* context = implOwnPtr->scriptExecutionContext();
-    MutexLocker locker(implOwnPtr->mutex());
-    if (context && !context->isContextThread())
-        context->postTask(DestroyOnContextThreadTask::create(implOwnPtr.release()));
-}
-
 ActiveDOMCallback::ActiveDOMCallback(ScriptExecutionContext* context)
-    : m_impl(adoptPtr(new ActiveDOMObjectCallbackImpl(context)))
+    : ContextDestructionObserver(context)
 {
-    m_impl->suspendIfNeeded();
 }
 
 ActiveDOMCallback::~ActiveDOMCallback()
 {
-    destroyOnContextThread(m_impl.release());
 }
 
 bool ActiveDOMCallback::canInvokeCallback() const
 {
-    return m_impl->canInvokeCallback();
+    ScriptExecutionContext* context = scriptExecutionContext();
+    return context && !context->activeDOMObjectsAreSuspended() && !context->activeDOMObjectsAreStopped();
 }
 
-ScriptExecutionContext* ActiveDOMCallback::scriptExecutionContext() const
+bool ActiveDOMCallback::isScriptControllerTerminating() const
 {
-    return m_impl->scriptExecutionContext();
+    ScriptExecutionContext* context = scriptExecutionContext();
+    if (context && context->isWorkerContext()) {
+        WorkerScriptController* scriptController = static_cast<WorkerContext*>(context)->script();
+        if (!scriptController || scriptController->isExecutionForbidden() || scriptController->isExecutionTerminating())
+            return true;
+    }
+    return false;
 }
 
 } // namespace WebCore