WebKit merge 40500:40539 [WebKit side]

third_party/WebKit/WebCore/dom/WorkerMessagingProxy.cpp

 /*
  * Copyright (C) 2008 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 15 matching lines @@
 
 #include "config.h"
 
 #if ENABLE(WORKERS)
 
 #include "WorkerMessagingProxy.h"
 
 #include "DOMWindow.h"
 #include "Document.h"
 #include "MessageEvent.h"
+#include "ScriptExecutionContext.h"
 #include "Worker.h"
 #include "WorkerContext.h"
-#include "WorkerTask.h"
 #include "WorkerThread.h"
 
 namespace WebCore {
 
-class MessageWorkerContextTask : public WorkerTask {
+class MessageWorkerContextTask : public ScriptExecutionContext::Task {
 public:
     static PassRefPtr<MessageWorkerContextTask> create(const String& message)
     {
         return adoptRef(new MessageWorkerContextTask(message));
     }
 
 private:
     MessageWorkerContextTask(const String& message)
         : m_message(message.copy())
     {
     }
 
-    virtual void performTask(WorkerContext* context)
+    virtual void performTask(ScriptExecutionContext* scriptContext)
     {
+        ASSERT(scriptContext->isWorkerContext());
+        WorkerContext* context = static_cast<WorkerContext*>(scriptContext);
+
         RefPtr<Event> evt = MessageEvent::create(m_message, "", "", 0, 0);
 
         if (context->onmessage()) {
             evt->setTarget(context);
             evt->setCurrentTarget(context);
             context->onmessage()->handleEvent(evt.get(), false);
         }
 
         ExceptionCode ec = 0;
         context->dispatchEvent(evt.release(), ec);
@@ skipping 138 matching lines @@
         || (m_scriptExecutionContext->isWorkerContext() && currentThread() == static_cast<WorkerContext*>(m_scriptExecutionContext.get())->thread()->threadID()));
 }
 
 void WorkerMessagingProxy::postMessageToWorkerObject(const String& message)
 {
     m_scriptExecutionContext->postTask(MessageWorkerTask::create(message, this));
 }
 
 void WorkerMessagingProxy::postMessageToWorkerContext(const String& message)
 {
+    postTaskToWorkerContext(MessageWorkerContextTask::create(message));
+}
+
+void WorkerMessagingProxy::postTaskToWorkerContext(PassRefPtr<ScriptExecutionContext::Task> task)
+{
     if (m_askedToTerminate)
         return;
 
     if (m_workerThread) {
         ++m_unconfirmedMessageCount;
-        m_workerThread->runLoop().postTask(MessageWorkerContextTask::create(message));
+        m_workerThread->runLoop().postTask(task);
     } else
-        m_queuedEarlyTasks.append(MessageWorkerContextTask::create(message));
+        m_queuedEarlyTasks.append(task);
 }
 
-void WorkerMessagingProxy::postTaskToParentContext(PassRefPtr<ScriptExecutionContext::Task> task)
+void WorkerMessagingProxy::postTaskToWorkerObject(PassRefPtr<ScriptExecutionContext::Task> task)
 {
     m_scriptExecutionContext->postTask(task);
 }
 
 void WorkerMessagingProxy::postWorkerException(const String& errorMessage, int lineNumber, const String& sourceURL)
 {
     m_scriptExecutionContext->postTask(WorkerExceptionTask::create(errorMessage, lineNumber, sourceURL, this));
 }
 
 void WorkerMessagingProxy::workerThreadCreated(PassRefPtr<WorkerThread> workerThread)
@@ skipping 13 matching lines @@
         m_queuedEarlyTasks.clear();
     }
 }
 
 void WorkerMessagingProxy::workerObjectDestroyed()
 {
     m_workerObject = 0;
     if (m_workerThread)
         terminate();
     else
-        workerContextDestroyedInternal(); // It never existed, just do our cleanup.
+        workerContextDestroyedInternal();
 }
 
 void WorkerMessagingProxy::workerContextDestroyed()
 {
     m_scriptExecutionContext->postTask(WorkerContextDestroyedTask::create(this));
     // Will execute workerContextDestroyedInternal() on context's thread.
 }
 
 void WorkerMessagingProxy::workerContextDestroyedInternal()
 {
     // WorkerContextDestroyedTask is always the last to be performed, so the proxy is not needed for communication
     // in either side any more. However, the Worker object may still exist, and it assumes that the proxy exists, too.
+    m_workerThread = 0;
     if (!m_workerObject)
         delete this;
 }
 
 void WorkerMessagingProxy::terminate()
 {
     if (m_askedToTerminate)
         return;
     m_askedToTerminate = true;
 
@@ skipping 26 matching lines @@
 bool WorkerMessagingProxy::workerThreadHasPendingActivity() const
 {
     return (m_unconfirmedMessageCount || m_workerThreadHadPendingActivity) && !m_askedToTerminate;
 }
 
 } // namespace WebCore
 
 #endif // ENABLE(WORKERS)