Fixed worker startup issue

webkit/api/src/SharedWorkerRepository.cpp

 /*
  * Copyright (C) 2009 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 42 matching lines @@
 #include "WorkerScriptLoaderClient.h"
 
 namespace WebCore {
 
 class Document;
 using WebKit::WebFrameImpl;;
 using WebKit::WebMessagePortChannel;
 using WebKit::WebSharedWorker;
 using WebKit::WebSharedWorkerRepository;
 
-// Callback class that keeps the Worker object alive while loads are potentially happening, and also translates load errors into error events on the worker.
-class SharedWorkerScriptLoader : public RefCounted<SharedWorkerScriptLoader>, private WorkerScriptLoaderClient {
+// Callback class that keeps the SharedWorker and WebSharedWorker objects alive while loads are potentially happening, and also translates load errors into error events on the worker.
+class SharedWorkerScriptLoader : private WorkerScriptLoaderClient, private WebSharedWorker::ConnectListener, private ActiveDOMObject {
 public:
   SharedWorkerScriptLoader(PassRefPtr<SharedWorker> worker, const KURL& url, const String& name, PassOwnPtr<MessagePortChannel> port, PassOwnPtr<WebSharedWorker> webWorker)
-      : m_worker(worker),
-        m_url(url),
-        m_name(name),
-        m_webWorker(webWorker),
-        m_port(port)
+      : ActiveDOMObject(worker->scriptExecutionContext(), this)
+      , m_worker(worker)
+      , m_url(url)
+      , m_name(name)
+      , m_webWorker(webWorker)
+      , m_port(port)
     {
     }
 
     void load();
-
+    virtual void contextDestroyed();
 private:
     // WorkerScriptLoaderClient callback
     virtual void notifyFinished();
 
+    virtual void connected();
+
+    void sendConnect();
+
     RefPtr<SharedWorker> m_worker;
     KURL m_url;
     String m_name;
     OwnPtr<WebSharedWorker> m_webWorker;
     OwnPtr<MessagePortChannel> m_port;
     WorkerScriptLoader m_scriptLoader;
 };
 
 void SharedWorkerScriptLoader::load()
 {
-    m_scriptLoader.loadAsynchronously(m_worker->scriptExecutionContext(), m_url, DenyCrossOriginRequests, this);
+    // If the shared worker is not yet running, load the script resource for it, otherwise just send it a connect event.
+    if (m_webWorker->isStarted())
+        sendConnect();
+    else
+        m_scriptLoader.loadAsynchronously(m_worker->scriptExecutionContext(), m_url, DenyCrossOriginRequests, this);
 }
 
 // Extracts a WebMessagePortChannel from a MessagePortChannel.
 static WebMessagePortChannel* getWebPort(PassOwnPtr<MessagePortChannel> port)
 {
     // Extract the WebMessagePortChannel to send to the worker.
     PlatformMessagePortChannel* platformChannel = port->channel();
     WebMessagePortChannel* webPort = platformChannel->webChannelRelease();
     webPort->setClient(0);
     return webPort;
 }
 
 void SharedWorkerScriptLoader::notifyFinished()
 {
-    if (m_scriptLoader.failed())
+    if (m_scriptLoader.failed()) {
         m_worker->dispatchEvent(Event::create(eventNames().errorEvent, false, true));
-    else {
+        delete this;
+    } else {
+        // Pass the script off to the worker, then send a connect event.
         m_webWorker->startWorkerContext(m_url, m_name, m_worker->scriptExecutionContext()->userAgent(m_url), m_scriptLoader.script());
-        m_webWorker->connect(getWebPort(m_port.release()));
+        sendConnect();
     }
+}
 
+void SharedWorkerScriptLoader::sendConnect()
+{
+    // Send the connect event off, and linger until it is done sending.
+    m_webWorker->connect(getWebPort(m_port.release()), this);
+}
+
+void SharedWorkerScriptLoader::contextDestroyed()
+{
+    ActiveDOMObject::contextDestroyed();
+    delete this;
+}
+
+void SharedWorkerScriptLoader::connected()
+{
     // Connect event has been sent, so free ourselves (this releases the SharedWorker so it can be freed as well if unreferenced).
     delete this;
 }
 
 bool SharedWorkerRepository::isAvailable()
 {
     // Allow the WebKitClient to determine if SharedWorkers are available.
     return WebKit::webKitClient()->sharedWorkerRepository();
 }
 
@@ skipping 15 matching lines @@
     WebFrameImpl* webFrame = WebFrameImpl::fromFrame(document->frame());
     OwnPtr<WebSharedWorker> webWorker;
     webWorker = webFrame->client()->createSharedWorker(webFrame, url, name, getId(document));
 
     if (!webWorker) {
         // Existing worker does not match this url, so return an error back to the caller.
         ec = URL_MISMATCH_ERR;
         return;
     }
 
-    if (!webWorker->isStarted()) {
-        // Need to kick off a load for the worker. The loader will connect to the worker once the script has been loaded, then free itself.
-        SharedWorkerScriptLoader* loader = new SharedWorkerScriptLoader(worker, url, name, port.release(), webWorker.release());
-        loader->load();
-    } else
-        webWorker->connect(getWebPort(port.release()));
+    // The loader object manages its own lifecycle (and the lifecycles of the two worker objects).
+    // It will free itself once loading is completed.
+    SharedWorkerScriptLoader* loader = new SharedWorkerScriptLoader(worker, url, name, port.release(), webWorker.release());
+    loader->load();
 }
 
 void SharedWorkerRepository::documentDetached(Document* document)
 {
     WebSharedWorkerRepository* repo = WebKit::webKitClient()->sharedWorkerRepository();
     if (repo)
         repo->documentDetached(getId(document));
 }
 
 bool SharedWorkerRepository::hasSharedWorkers(Document* document)
 {
     WebSharedWorkerRepository* repo = WebKit::webKitClient()->sharedWorkerRepository();
     return repo && repo->hasSharedWorkers(getId(document));
 }
 
 
 
 } // namespace WebCore
 
 #endif // ENABLE(SHARED_WORKERS)