Source/WebCore/workers/DefaultSharedWorkerRepository.cpp

   1 /*
   2  * Copyright (C) 2009 Google Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are
   6  * met:
   7  *
   8  *     * Redistributions of source code must retain the above copyright
   9  * notice, this list of conditions and the following disclaimer.
  10  *     * Redistributions in binary form must reproduce the above
  11  * copyright notice, this list of conditions and the following disclaimer
  12  * in the documentation and/or other materials provided with the
  13  * distribution.
  14  *     * Neither the name of Google Inc. nor the names of its
  15  * contributors may be used to endorse or promote products derived from
  16  * this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 #include "config.h"
  32
  33 #if ENABLE(SHARED_WORKERS)
  34
  35 #include "DefaultSharedWorkerRepository.h"
  36
  37 #include "ActiveDOMObject.h"
  38 #include "CrossThreadTask.h"
  39 #include "Document.h"
  40 #include "InspectorInstrumentation.h"
  41 #include "MessageEvent.h"
  42 #include "MessagePort.h"
  43 #include "NotImplemented.h"
  44 #include "PlatformString.h"
  45 #include "ScriptCallStack.h"
  46 #include "SecurityOrigin.h"
  47 #include "SecurityOriginHash.h"
  48 #include "SharedWorker.h"
  49 #include "SharedWorkerContext.h"
  50 #include "SharedWorkerRepository.h"
  51 #include "SharedWorkerThread.h"
  52 #include "WorkerLoaderProxy.h"
  53 #include "WorkerReportingProxy.h"
  54 #include "WorkerScriptLoader.h"
  55 #include "WorkerScriptLoaderClient.h"
  56 #include <wtf/HashSet.h>
  57 #include <wtf/Threading.h>
  58
  59 namespace WebCore {
  60
  61 class SharedWorkerProxy : public ThreadSafeRefCounted<SharedWorkerProxy>, public WorkerLoaderProxy, public WorkerReportingProxy {
  62 public:
  63     static PassRefPtr<SharedWorkerProxy> create(const String& name, const KURL& url, PassRefPtr<SecurityOrigin> origin) { return adoptRef(new SharedWorkerProxy(name, url, origin)); }
  64
  65     void setThread(PassRefPtr<SharedWorkerThread> thread) { m_thread = thread; }
  66     SharedWorkerThread* thread() { return m_thread.get(); }
  67     bool isClosing() const { return m_closing; }
  68     KURL url() const
  69     {
  70         // Don't use m_url.copy() because it isn't a threadsafe method.
  71         return KURL(ParsedURLString, m_url.string().threadsafeCopy());
  72     }
  73
  74     String name() const { return m_name.threadsafeCopy(); }
  75     bool matches(const String& name, PassRefPtr<SecurityOrigin> origin, const KURL& urlToMatch) const;
  76
  77     // WorkerLoaderProxy
  78     virtual void postTaskToLoader(PassOwnPtr<ScriptExecutionContext::Task>);
  79     virtual void postTaskForModeToWorkerContext(PassOwnPtr<ScriptExecutionContext::Task>, const String&);
  80
  81     // WorkerReportingProxy
  82     virtual void postExceptionToWorkerObject(const String& errorMessage, int lineNumber, const String& sourceURL);
  83     virtual void postConsoleMessageToWorkerObject(MessageSource, MessageType, MessageLevel, const String& message, int lineNumber, const String& sourceURL);
  84 #if ENABLE(INSPECTOR)
  85     virtual void postMessageToPageInspector(const String&);
  86 #endif
  87     virtual void workerContextClosed();
  88     virtual void workerContextDestroyed();
  89
  90     // Updates the list of the worker's documents, per section 4.5 of the WebWorkers spec.
  91     void addToWorkerDocuments(ScriptExecutionContext*);
  92
  93     bool isInWorkerDocuments(Document* document) { return m_workerDocuments.contains(document); }
  94
  95     // Removes a detached document from the list of worker's documents. May set the closing flag if this is the last document in the list.
  96     void documentDetached(Document*);
  97
  98 private:
  99     SharedWorkerProxy(const String& name, const KURL&, PassRefPtr<SecurityOrigin>);
 100     void close();
 101
 102     bool m_closing;
 103     String m_name;
 104     KURL m_url;
 105     // The thread is freed when the proxy is destroyed, so we need to make sure that the proxy stays around until the SharedWorkerContext exits.
 106     RefPtr<SharedWorkerThread> m_thread;
 107     RefPtr<SecurityOrigin> m_origin;
 108     HashSet<Document*> m_workerDocuments;
 109     // Ensures exclusive access to the worker documents. Must not grab any other locks (such as the DefaultSharedWorkerRepository lock) while holding this one.
 110     Mutex m_workerDocumentsLock;
 111 };
 112
 113 SharedWorkerProxy::SharedWorkerProxy(const String& name, const KURL& url, PassRefPtr<SecurityOrigin> origin)
 114     : m_closing(false)
 115     , m_name(name.crossThreadString())
 116     , m_url(url.copy())
 117     , m_origin(origin)
 118 {
 119     // We should be the sole owner of the SecurityOrigin, as we will free it on another thread.
 120     ASSERT(m_origin->hasOneRef());
 121 }
 122
 123 bool SharedWorkerProxy::matches(const String& name, PassRefPtr<SecurityOrigin> origin, const KURL& urlToMatch) const
 124 {
 125     // If the origins don't match, or the names don't match, then this is not the proxy we are looking for.
 126     if (!origin->equal(m_origin.get()))
 127         return false;
 128
 129     // If the names are both empty, compares the URLs instead per the Web Workers spec.
 130     if (name.isEmpty() && m_name.isEmpty())
 131         return urlToMatch == url();
 132
 133     return name == m_name;
 134 }
 135
 136 void SharedWorkerProxy::postTaskToLoader(PassOwnPtr<ScriptExecutionContext::Task> task)
 137 {
 138     MutexLocker lock(m_workerDocumentsLock);
 139
 140     if (isClosing())
 141         return;
 142
 143     // If we aren't closing, then we must have at least one document.
 144     ASSERT(m_workerDocuments.size());
 145
 146     // Just pick an arbitrary active document from the HashSet and pass load requests to it.
 147     // FIXME: Do we need to deal with the case where the user closes the document mid-load, via a shadow document or some other solution?
 148     Document* document = *(m_workerDocuments.begin());
 149     document->postTask(task);
 150 }
 151
 152 void SharedWorkerProxy::postTaskForModeToWorkerContext(PassOwnPtr<ScriptExecutionContext::Task> task, const String& mode)
 153 {
 154     if (isClosing())
 155         return;
 156     ASSERT(m_thread);
 157     m_thread->runLoop().postTaskForMode(task, mode);
 158 }
 159
 160 static void postExceptionTask(ScriptExecutionContext* context, const String& errorMessage, int lineNumber, const String& sourceURL)
 161 {
 162     context->reportException(errorMessage, lineNumber, sourceURL, 0);
 163 }
 164
 165 void SharedWorkerProxy::postExceptionToWorkerObject(const String& errorMessage, int lineNumber, const String& sourceURL)
 166 {
 167     MutexLocker lock(m_workerDocumentsLock);
 168     for (HashSet<Document*>::iterator iter = m_workerDocuments.begin(); iter != m_workerDocuments.end(); ++iter)
 169         (*iter)->postTask(createCallbackTask(&postExceptionTask, errorMessage, lineNumber, sourceURL));
 170 }
 171
 172 static void postConsoleMessageTask(ScriptExecutionContext* document, MessageSource source, MessageType type, MessageLevel level, const String& message, unsigned lineNumber, const String& sourceURL)
 173 {
 174     document->addMessage(source, type, level, message, lineNumber, sourceURL, 0);
 175 }
 176
 177 void SharedWorkerProxy::postConsoleMessageToWorkerObject(MessageSource source, MessageType type, MessageLevel level, const String& message, int lineNumber, const String& sourceURL)
 178 {
 179     MutexLocker lock(m_workerDocumentsLock);
 180     for (HashSet<Document*>::iterator iter = m_workerDocuments.begin(); iter != m_workerDocuments.end(); ++iter)
 181         (*iter)->postTask(createCallbackTask(&postConsoleMessageTask, source, type, level, message, lineNumber, sourceURL));
 182 }
 183
 184 #if ENABLE(INSPECTOR)
 185 void SharedWorkerProxy::postMessageToPageInspector(const String&)
 186 {
 187 }
 188 #endif
 189
 190 void SharedWorkerProxy::workerContextClosed()
 191 {
 192     if (isClosing())
 193         return;
 194     close();
 195 }
 196
 197 void SharedWorkerProxy::workerContextDestroyed()
 198 {
 199     // The proxy may be freed by this call, so do not reference it any further.
 200     DefaultSharedWorkerRepository::instance().removeProxy(this);
 201 }
 202
 203 void SharedWorkerProxy::addToWorkerDocuments(ScriptExecutionContext* context)
 204 {
 205     // Nested workers are not yet supported, so passed-in context should always be a Document.
 206     ASSERT(context->isDocument());
 207     ASSERT(!isClosing());
 208     MutexLocker lock(m_workerDocumentsLock);
 209     Document* document = static_cast<Document*>(context);
 210     m_workerDocuments.add(document);
 211 }
 212
 213 void SharedWorkerProxy::documentDetached(Document* document)
 214 {
 215     if (isClosing())
 216         return;
 217     // Remove the document from our set (if it's there) and if that was the last document in the set, mark the proxy as closed.
 218     MutexLocker lock(m_workerDocumentsLock);
 219     m_workerDocuments.remove(document);
 220     if (!m_workerDocuments.size())
 221         close();
 222 }
 223
 224 void SharedWorkerProxy::close()
 225 {
 226     ASSERT(!isClosing());
 227     m_closing = true;
 228     // Stop the worker thread - the proxy will stay around until we get workerThreadExited() notification.
 229     if (m_thread)
 230         m_thread->stop();
 231 }
 232
 233 class SharedWorkerConnectTask : public ScriptExecutionContext::Task {
 234 public:
 235     static PassOwnPtr<SharedWorkerConnectTask> create(PassOwnPtr<MessagePortChannel> channel)
 236     {
 237         return adoptPtr(new SharedWorkerConnectTask(channel));
 238     }
 239
 240 private:
 241     SharedWorkerConnectTask(PassOwnPtr<MessagePortChannel> channel)
 242         : m_channel(channel)
 243     {
 244     }
 245
 246     virtual void performTask(ScriptExecutionContext* scriptContext)
 247     {
 248         RefPtr<MessagePort> port = MessagePort::create(*scriptContext);
 249         port->entangle(m_channel.release());
 250         ASSERT(scriptContext->isWorkerContext());
 251         WorkerContext* workerContext = static_cast<WorkerContext*>(scriptContext);
 252         // Since close() stops the thread event loop, this should not ever get called while closing.
 253         ASSERT(!workerContext->isClosing());
 254         ASSERT(workerContext->isSharedWorkerContext());
 255         workerContext->toSharedWorkerContext()->dispatchEvent(createConnectEvent(port));
 256     }
 257
 258     OwnPtr<MessagePortChannel> m_channel;
 259 };
 260
 261 // Loads the script on behalf of a worker.
 262 class SharedWorkerScriptLoader : public RefCounted<SharedWorkerScriptLoader>, private WorkerScriptLoaderClient {
 263 public:
 264     SharedWorkerScriptLoader(PassRefPtr<SharedWorker>, PassOwnPtr<MessagePortChannel>, PassRefPtr<SharedWorkerProxy>);
 265     void load(const KURL&);
 266
 267 private:
 268     // WorkerScriptLoaderClient callback
 269     virtual void notifyFinished();
 270
 271     RefPtr<SharedWorker> m_worker;
 272     OwnPtr<MessagePortChannel> m_port;
 273     RefPtr<SharedWorkerProxy> m_proxy;
 274     RefPtr<WorkerScriptLoader> m_scriptLoader;
 275 };
 276
 277 SharedWorkerScriptLoader::SharedWorkerScriptLoader(PassRefPtr<SharedWorker> worker, PassOwnPtr<MessagePortChannel> port, PassRefPtr<SharedWorkerProxy> proxy)
 278     : m_worker(worker)
 279     , m_port(port)
 280     , m_proxy(proxy)
 281 {
 282 }
 283
 284 void SharedWorkerScriptLoader::load(const KURL& url)
 285 {
 286     // Stay alive (and keep the SharedWorker and JS wrapper alive) until the load finishes.
 287     this->ref();
 288     m_worker->setPendingActivity(m_worker.get());
 289
 290     // Mark this object as active for the duration of the load.
 291     m_scriptLoader = WorkerScriptLoader::create(ResourceRequestBase::TargetIsSharedWorker);
 292     m_scriptLoader->loadAsynchronously(m_worker->scriptExecutionContext(), url, DenyCrossOriginRequests, this);
 293 }
 294
 295 void SharedWorkerScriptLoader::notifyFinished()
 296 {
 297     // FIXME: This method is not guaranteed to be invoked if we are loading from WorkerContext (see comment for WorkerScriptLoaderClient::notifyFinished()).
 298     // We need to address this before supporting nested workers.
 299
 300     // Hand off the just-loaded code to the repository to start up the worker thread.
 301     if (m_scriptLoader->failed())
 302         m_worker->dispatchEvent(Event::create(eventNames().errorEvent, false, true));
 303     else {
 304         InspectorInstrumentation::scriptImported(m_worker->scriptExecutionContext(), m_scriptLoader->identifier(), m_scriptLoader->script());
 305         DefaultSharedWorkerRepository::instance().workerScriptLoaded(*m_proxy, m_worker->scriptExecutionContext()->userAgent(m_scriptLoader->url()), m_scriptLoader->script(), m_port.release());
 306     }
 307     m_worker->unsetPendingActivity(m_worker.get());
 308     this->deref(); // This frees this object - must be the last action in this function.
 309 }
 310
 311 DefaultSharedWorkerRepository& DefaultSharedWorkerRepository::instance()
 312 {
 313     AtomicallyInitializedStatic(DefaultSharedWorkerRepository*, instance = new DefaultSharedWorkerRepository);
 314     return *instance;
 315 }
 316
 317 void DefaultSharedWorkerRepository::workerScriptLoaded(SharedWorkerProxy& proxy, const String& userAgent, const String& workerScript, PassOwnPtr<MessagePortChannel> port)
 318 {
 319     MutexLocker lock(m_lock);
 320     if (proxy.isClosing())
 321         return;
 322
 323     // Another loader may have already started up a thread for this proxy - if so, just send a connect to the pre-existing thread.
 324     if (!proxy.thread()) {
 325         RefPtr<SharedWorkerThread> thread = SharedWorkerThread::create(proxy.name(), proxy.url(), userAgent, workerScript, proxy, proxy);
 326         proxy.setThread(thread);
 327         thread->start();
 328     }
 329     proxy.thread()->runLoop().postTask(SharedWorkerConnectTask::create(port));
 330 }
 331
 332 bool SharedWorkerRepository::isAvailable()
 333 {
 334     // SharedWorkers are enabled on the default WebKit platform.
 335     return true;
 336 }
 337
 338 void SharedWorkerRepository::connect(PassRefPtr<SharedWorker> worker, PassOwnPtr<MessagePortChannel> port, const KURL& url, const String& name, ExceptionCode& ec)
 339 {
 340     DefaultSharedWorkerRepository::instance().connectToWorker(worker, port, url, name, ec);
 341 }
 342
 343 void SharedWorkerRepository::documentDetached(Document* document)
 344 {
 345     DefaultSharedWorkerRepository::instance().documentDetached(document);
 346 }
 347
 348 bool SharedWorkerRepository::hasSharedWorkers(Document* document)
 349 {
 350     return DefaultSharedWorkerRepository::instance().hasSharedWorkers(document);
 351 }
 352
 353 bool DefaultSharedWorkerRepository::hasSharedWorkers(Document* document)
 354 {
 355     MutexLocker lock(m_lock);
 356     for (unsigned i = 0; i < m_proxies.size(); i++) {
 357         if (m_proxies[i]->isInWorkerDocuments(document))
 358             return true;
 359     }
 360     return false;
 361 }
 362
 363 void DefaultSharedWorkerRepository::removeProxy(SharedWorkerProxy* proxy)
 364 {
 365     MutexLocker lock(m_lock);
 366     for (unsigned i = 0; i < m_proxies.size(); i++) {
 367         if (proxy == m_proxies[i].get()) {
 368             m_proxies.remove(i);
 369             return;
 370         }
 371     }
 372 }
 373
 374 void DefaultSharedWorkerRepository::documentDetached(Document* document)
 375 {
 376     MutexLocker lock(m_lock);
 377     for (unsigned i = 0; i < m_proxies.size(); i++)
 378         m_proxies[i]->documentDetached(document);
 379 }
 380
 381 void DefaultSharedWorkerRepository::connectToWorker(PassRefPtr<SharedWorker> worker, PassOwnPtr<MessagePortChannel> port, const KURL& url, const String& name, ExceptionCode& ec)
 382 {
 383     MutexLocker lock(m_lock);
 384     ASSERT(worker->scriptExecutionContext()->securityOrigin()->canAccess(SecurityOrigin::create(url).get()));
 385     // Fetch a proxy corresponding to this SharedWorker.
 386     RefPtr<SharedWorkerProxy> proxy = getProxy(name, url);
 387     proxy->addToWorkerDocuments(worker->scriptExecutionContext());
 388     if (proxy->url() != url) {
 389         // Proxy already existed under alternate URL - return an error.
 390         ec = URL_MISMATCH_ERR;
 391         return;
 392     }
 393     // If proxy is already running, just connect to it - otherwise, kick off a loader to load the script.
 394     if (proxy->thread())
 395         proxy->thread()->runLoop().postTask(SharedWorkerConnectTask::create(port));
 396     else {
 397         RefPtr<SharedWorkerScriptLoader> loader = adoptRef(new SharedWorkerScriptLoader(worker, port, proxy.release()));
 398         loader->load(url);
 399     }
 400 }
 401
 402 // Creates a new SharedWorkerProxy or returns an existing one from the repository. Must only be called while the repository mutex is held.
 403 PassRefPtr<SharedWorkerProxy> DefaultSharedWorkerRepository::getProxy(const String& name, const KURL& url)
 404 {
 405     // Look for an existing worker, and create one if it doesn't exist.
 406     // Items in the cache are freed on another thread, so do a threadsafe copy of the URL before creating the origin,
 407     // to make sure no references to external strings linger.
 408     RefPtr<SecurityOrigin> origin = SecurityOrigin::create(KURL(ParsedURLString, url.string().threadsafeCopy()));
 409     for (unsigned i = 0; i < m_proxies.size(); i++) {
 410         if (!m_proxies[i]->isClosing() && m_proxies[i]->matches(name, origin, url))
 411             return m_proxies[i];
 412     }
 413     // Proxy is not in the repository currently - create a new one.
 414     RefPtr<SharedWorkerProxy> proxy = SharedWorkerProxy::create(name, url, origin.release());
 415     m_proxies.append(proxy);
 416     return proxy.release();
 417 }
 418
 419 DefaultSharedWorkerRepository::DefaultSharedWorkerRepository()
 420 {
 421 }
 422
 423 DefaultSharedWorkerRepository::~DefaultSharedWorkerRepository()
 424 {
 425 }
 426
 427 } // namespace WebCore
 428
 429 #endif // ENABLE(SHARED_WORKERS)