/*

 * 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

 * copyright notice, this list of conditions and the following disclaimer

 * in the documentation and/or other materials provided with the

 * distribution.

 *     * Neither the name of Google Inc. nor the names of its

 * contributors may be used to endorse or promote products derived from

 * this software without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

#include "config.h"

#if ENABLE(SHARED_WORKERS)

#include "DefaultSharedWorkerRepository.h"

#include "ActiveDOMObject.h"

#include "CrossThreadTask.h"

#include "Document.h"

#include "InspectorController.h"

#include "MessageEvent.h"

#include "MessagePort.h"

#include "NotImplemented.h"

#include "PlatformString.h"

#include "SecurityOrigin.h"

#include "SecurityOriginHash.h"

#include "SharedWorker.h"

#include "SharedWorkerContext.h"

#include "SharedWorkerRepository.h"

#include "SharedWorkerThread.h"

#include "WorkerLoaderProxy.h"

#include "WorkerReportingProxy.h"

#include "WorkerScriptLoader.h"

#include "WorkerScriptLoaderClient.h"

#include <wtf/HashSet.h>

#include <wtf/Threading.h>

namespace WebCore {

class SharedWorkerProxy : public ThreadSafeShared<SharedWorkerProxy>, public WorkerLoaderProxy, public WorkerReportingProxy {

public:

    static PassRefPtr<SharedWorkerProxy> create(const String& name, const KURL& url, PassRefPtr<SecurityOrigin> origin) { return adoptRef(new SharedWorkerProxy(name, url, origin)); }

    void setThread(PassRefPtr<SharedWorkerThread> thread) { m_thread = thread; }

    SharedWorkerThread* thread() { return m_thread.get(); }

    bool isClosing() const { return m_closing; }

    KURL url() const

    {

        // Don't use m_url.copy() because it isn't a threadsafe method.

        return KURL(ParsedURLString, m_url.string().threadsafeCopy());

    }

    String name() const { return m_name.threadsafeCopy(); }

    bool matches(const String& name, PassRefPtr<SecurityOrigin> origin, const KURL& urlToMatch) const;

    // WorkerLoaderProxy

    virtual void postTaskToLoader(PassOwnPtr<ScriptExecutionContext::Task>);

    virtual void postTaskForModeToWorkerContext(PassOwnPtr<ScriptExecutionContext::Task>, const String&);

    // WorkerReportingProxy

    virtual void postExceptionToWorkerObject(const String& errorMessage, int lineNumber, const String& sourceURL);

    virtual void postConsoleMessageToWorkerObject(MessageSource, MessageType, MessageLevel, const String& message, int lineNumber, const String& sourceURL);

    virtual void workerContextClosed();

    virtual void workerContextDestroyed();

    // Updates the list of the worker's documents, per section 4.5 of the WebWorkers spec.

    void addToWorkerDocuments(ScriptExecutionContext*);

    bool isInWorkerDocuments(Document* document) { return m_workerDocuments.contains(document); }

    // 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.

    void documentDetached(Document*);

private:

    SharedWorkerProxy(const String& name, const KURL&, PassRefPtr<SecurityOrigin>);

    void close();

    bool m_closing;

    String m_name;

    KURL m_url;

    // The thread is freed when the proxy is destroyed, so we need to make sure that the proxy stays around until the SharedWorkerContext exits.

    RefPtr<SharedWorkerThread> m_thread;

    RefPtr<SecurityOrigin> m_origin;

    HashSet<Document*> m_workerDocuments;

    // Ensures exclusive access to the worker documents. Must not grab any other locks (such as the DefaultSharedWorkerRepository lock) while holding this one.

    Mutex m_workerDocumentsLock;

};

SharedWorkerProxy::SharedWorkerProxy(const String& name, const KURL& url, PassRefPtr<SecurityOrigin> origin)

    : m_closing(false)

    , m_name(name.crossThreadString())

    , m_url(url.copy())

    , m_origin(origin)

{

    // We should be the sole owner of the SecurityOrigin, as we will free it on another thread.

    ASSERT(m_origin->hasOneRef());

}

bool SharedWorkerProxy::matches(const String& name, PassRefPtr<SecurityOrigin> origin, const KURL& urlToMatch) const

{

    // If the origins don't match, or the names don't match, then this is not the proxy we are looking for.

    if (!origin->equal(m_origin.get()))

        return false;

    // If the names are both empty, compares the URLs instead per the Web Workers spec.

    if (name.isEmpty() && m_name.isEmpty())

        return urlToMatch == url();

    return name == m_name;

}

void SharedWorkerProxy::postTaskToLoader(PassOwnPtr<ScriptExecutionContext::Task> task)

{

    MutexLocker lock(m_workerDocumentsLock);

    if (isClosing())

        return;

    // If we aren't closing, then we must have at least one document.

    ASSERT(m_workerDocuments.size());

    // Just pick an arbitrary active document from the HashSet and pass load requests to it.

    // 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?

    Document* document = *(m_workerDocuments.begin());

    document->postTask(task);

}

void SharedWorkerProxy::postTaskForModeToWorkerContext(PassOwnPtr<ScriptExecutionContext::Task> task, const String& mode)

{

    if (isClosing())

        return;

    ASSERT(m_thread);

    m_thread->runLoop().postTaskForMode(task, mode);

}

static void postExceptionTask(ScriptExecutionContext* context, const String& errorMessage, int lineNumber, const String& sourceURL)

{

    context->reportException(errorMessage, lineNumber, sourceURL);

}

void SharedWorkerProxy::postExceptionToWorkerObject(const String& errorMessage, int lineNumber, const String& sourceURL)

{

    MutexLocker lock(m_workerDocumentsLock);

    for (HashSet<Document*>::iterator iter = m_workerDocuments.begin(); iter != m_workerDocuments.end(); ++iter)

        (*iter)->postTask(createCallbackTask(&postExceptionTask, errorMessage, lineNumber, sourceURL));

}

static void postConsoleMessageTask(ScriptExecutionContext* document, MessageSource source, MessageType type, MessageLevel level, const String& message, unsigned lineNumber, const String& sourceURL)

{

    document->addMessage(source, type, level, message, lineNumber, sourceURL);

}

void SharedWorkerProxy::postConsoleMessageToWorkerObject(MessageSource source, MessageType type, MessageLevel level, const String& message, int lineNumber, const String& sourceURL)

{

    MutexLocker lock(m_workerDocumentsLock);

    for (HashSet<Document*>::iterator iter = m_workerDocuments.begin(); iter != m_workerDocuments.end(); ++iter)

        (*iter)->postTask(createCallbackTask(&postConsoleMessageTask, source, type, level, message, lineNumber, sourceURL));

}

void SharedWorkerProxy::workerContextClosed()

{

    if (isClosing())

        return;

    close();

}

void SharedWorkerProxy::workerContextDestroyed()

{

    // The proxy may be freed by this call, so do not reference it any further.

    DefaultSharedWorkerRepository::instance().removeProxy(this);

}

void SharedWorkerProxy::addToWorkerDocuments(ScriptExecutionContext* context)

{

    // Nested workers are not yet supported, so passed-in context should always be a Document.

    ASSERT(context->isDocument());

    ASSERT(!isClosing());

    MutexLocker lock(m_workerDocumentsLock);

    Document* document = static_cast<Document*>(context);

    m_workerDocuments.add(document);

}

void SharedWorkerProxy::documentDetached(Document* document)

{

    if (isClosing())

        return;

    // 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.

    MutexLocker lock(m_workerDocumentsLock);

    m_workerDocuments.remove(document);

    if (!m_workerDocuments.size())

        close();

}

void SharedWorkerProxy::close()

{

    ASSERT(!isClosing());

    m_closing = true;

    // Stop the worker thread - the proxy will stay around until we get workerThreadExited() notification.

    if (m_thread)

        m_thread->stop();

}

class SharedWorkerConnectTask : public ScriptExecutionContext::Task {

public:

    static PassOwnPtr<SharedWorkerConnectTask> create(PassOwnPtr<MessagePortChannel> channel)

    {

        return new SharedWorkerConnectTask(channel);

    }

private:

    SharedWorkerConnectTask(PassOwnPtr<MessagePortChannel> channel)

        : m_channel(channel)

    {

    }

    virtual void performTask(ScriptExecutionContext* scriptContext)

    {

        RefPtr<MessagePort> port = MessagePort::create(*scriptContext);

        port->entangle(m_channel.release());

        ASSERT(scriptContext->isWorkerContext());

        WorkerContext* workerContext = static_cast<WorkerContext*>(scriptContext);

        // Since close() stops the thread event loop, this should not ever get called while closing.

        ASSERT(!workerContext->isClosing());

        ASSERT(workerContext->isSharedWorkerContext());

        workerContext->toSharedWorkerContext()->dispatchEvent(createConnectEvent(port));

    }

    OwnPtr<MessagePortChannel> m_channel;

};

// Loads the script on behalf of a worker.

class SharedWorkerScriptLoader : public RefCounted<SharedWorkerScriptLoader>, private WorkerScriptLoaderClient {

public:

    SharedWorkerScriptLoader(PassRefPtr<SharedWorker>, PassOwnPtr<MessagePortChannel>, PassRefPtr<SharedWorkerProxy>);

    void load(const KURL&);

private:

    // WorkerScriptLoaderClient callback

    virtual void notifyFinished();

    RefPtr<SharedWorker> m_worker;

    OwnPtr<MessagePortChannel> m_port;

    RefPtr<SharedWorkerProxy> m_proxy;

    OwnPtr<WorkerScriptLoader> m_scriptLoader;

};

SharedWorkerScriptLoader::SharedWorkerScriptLoader(PassRefPtr<SharedWorker> worker, PassOwnPtr<MessagePortChannel> port, PassRefPtr<SharedWorkerProxy> proxy)

    : m_worker(worker)

    , m_port(port)

    , m_proxy(proxy)

{

}

void SharedWorkerScriptLoader::load(const KURL& url)

{

    // Mark this object as active for the duration of the load.

    m_scriptLoader = new WorkerScriptLoader(ResourceRequestBase::TargetIsSharedWorker);

    m_scriptLoader->loadAsynchronously(m_worker->scriptExecutionContext(), url, DenyCrossOriginRequests, this);

    // Stay alive (and keep the SharedWorker and JS wrapper alive) until the load finishes.

    this->ref();

    m_worker->setPendingActivity(m_worker.get());

}

void SharedWorkerScriptLoader::notifyFinished()

{

    // FIXME: This method is not guaranteed to be invoked if we are loading from WorkerContext (see comment for WorkerScriptLoaderClient::notifyFinished()).

    // We need to address this before supporting nested workers.

    // Hand off the just-loaded code to the repository to start up the worker thread.

    if (m_scriptLoader->failed())

        m_worker->dispatchEvent(Event::create(eventNames().errorEvent, false, true));

    else {

#if ENABLE(INSPECTOR)

        if (InspectorController* inspector = m_worker->scriptExecutionContext()->inspectorController())

            inspector->scriptImported(m_scriptLoader->identifier(), m_scriptLoader->script());

#endif

        DefaultSharedWorkerRepository::instance().workerScriptLoaded(*m_proxy, m_worker->scriptExecutionContext()->userAgent(m_scriptLoader->url()), m_scriptLoader->script(), m_port.release());

    }

    m_worker->unsetPendingActivity(m_worker.get());

    this->deref(); // This frees this object - must be the last action in this function.

}

DefaultSharedWorkerRepository& DefaultSharedWorkerRepository::instance()

{

    AtomicallyInitializedStatic(DefaultSharedWorkerRepository*, instance = new DefaultSharedWorkerRepository);

    return *instance;

}

void DefaultSharedWorkerRepository::workerScriptLoaded(SharedWorkerProxy& proxy, const String& userAgent, const String& workerScript, PassOwnPtr<MessagePortChannel> port)

{

    MutexLocker lock(m_lock);

    if (proxy.isClosing())

        return;

    // Another loader may have already started up a thread for this proxy - if so, just send a connect to the pre-existing thread.

    if (!proxy.thread()) {

        RefPtr<SharedWorkerThread> thread = SharedWorkerThread::create(proxy.name(), proxy.url(), userAgent, workerScript, proxy, proxy);

        proxy.setThread(thread);

        thread->start();

    }

    proxy.thread()->runLoop().postTask(SharedWorkerConnectTask::create(port));

}

bool SharedWorkerRepository::isAvailable()

{

    // SharedWorkers are enabled on the default WebKit platform.

    return true;

}

void SharedWorkerRepository::connect(PassRefPtr<SharedWorker> worker, PassOwnPtr<MessagePortChannel> port, const KURL& url, const String& name, ExceptionCode& ec)

{

    DefaultSharedWorkerRepository::instance().connectToWorker(worker, port, url, name, ec);

}

void SharedWorkerRepository::documentDetached(Document* document)

{

    DefaultSharedWorkerRepository::instance().documentDetached(document);

}

bool SharedWorkerRepository::hasSharedWorkers(Document* document)

{

    return DefaultSharedWorkerRepository::instance().hasSharedWorkers(document);

}

bool DefaultSharedWorkerRepository::hasSharedWorkers(Document* document)

{

    MutexLocker lock(m_lock);

    for (unsigned i = 0; i < m_proxies.size(); i++) {

        if (m_proxies[i]->isInWorkerDocuments(document))

            return true;

    }

    return false;

}

void DefaultSharedWorkerRepository::removeProxy(SharedWorkerProxy* proxy)

{

    MutexLocker lock(m_lock);

    for (unsigned i = 0; i < m_proxies.size(); i++) {

        if (proxy == m_proxies[i].get()) {

            m_proxies.remove(i);

            return;

        }

    }

}

void DefaultSharedWorkerRepository::documentDetached(Document* document)

{

    MutexLocker lock(m_lock);

    for (unsigned i = 0; i < m_proxies.size(); i++)

        m_proxies[i]->documentDetached(document);

}

void DefaultSharedWorkerRepository::connectToWorker(PassRefPtr<SharedWorker> worker, PassOwnPtr<MessagePortChannel> port, const KURL& url, const String& name, ExceptionCode& ec)

{

    MutexLocker lock(m_lock);

    ASSERT(worker->scriptExecutionContext()->securityOrigin()->canAccess(SecurityOrigin::create(url).get()));

    // Fetch a proxy corresponding to this SharedWorker.

    RefPtr<SharedWorkerProxy> proxy = getProxy(name, url);

    proxy->addToWorkerDocuments(worker->scriptExecutionContext());

    if (proxy->url() != url) {

        // Proxy already existed under alternate URL - return an error.

        ec = URL_MISMATCH_ERR;

        return;

    }

    // If proxy is already running, just connect to it - otherwise, kick off a loader to load the script.

    if (proxy->thread())

        proxy->thread()->runLoop().postTask(SharedWorkerConnectTask::create(port));

    else {

        RefPtr<SharedWorkerScriptLoader> loader = adoptRef(new SharedWorkerScriptLoader(worker, port, proxy.release()));

        loader->load(url);

    }

}

// Creates a new SharedWorkerProxy or returns an existing one from the repository. Must only be called while the repository mutex is held.

PassRefPtr<SharedWorkerProxy> DefaultSharedWorkerRepository::getProxy(const String& name, const KURL& url)

{

    // Look for an existing worker, and create one if it doesn't exist.

    // Items in the cache are freed on another thread, so do a threadsafe copy of the URL before creating the origin,

    // to make sure no references to external strings linger.

    RefPtr<SecurityOrigin> origin = SecurityOrigin::create(KURL(ParsedURLString, url.string().threadsafeCopy()));

    for (unsigned i = 0; i < m_proxies.size(); i++) {

        if (!m_proxies[i]->isClosing() && m_proxies[i]->matches(name, origin, url))

            return m_proxies[i];

    }

    // Proxy is not in the repository currently - create a new one.

    RefPtr<SharedWorkerProxy> proxy = SharedWorkerProxy::create(name, url, origin.release());

    m_proxies.append(proxy);

    return proxy.release();

}

DefaultSharedWorkerRepository::DefaultSharedWorkerRepository()

{

}

DefaultSharedWorkerRepository::~DefaultSharedWorkerRepository()

{

}

} // namespace WebCore

#endif // ENABLE(SHARED_WORKERS)