/*

 * Copyright (C) 2008, 2009, 2010 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

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``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 APPLE INC. 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"

#include "ApplicationCacheGroup.h"

#if ENABLE(OFFLINE_WEB_APPLICATIONS)

#include "ApplicationCache.h"

#include "ApplicationCacheHost.h"

#include "ApplicationCacheResource.h"

#include "ApplicationCacheStorage.h"

#include "Chrome.h"

#include "ChromeClient.h"

#include "DocumentLoader.h"

#include "DOMApplicationCache.h"

#include "DOMWindow.h"

#include "Frame.h"

#include "FrameLoader.h"

#include "MainResourceLoader.h"

#include "ManifestParser.h"

#include "Page.h"

#include "Settings.h"

#include <wtf/HashMap.h>

#if ENABLE(INSPECTOR)

#include "InspectorApplicationCacheAgent.h"

#include "InspectorController.h"

#include "ProgressTracker.h"

#else

#include <wtf/UnusedParam.h>

#endif

namespace WebCore {

ApplicationCacheGroup::ApplicationCacheGroup(const KURL& manifestURL, bool isCopy)

    : m_manifestURL(manifestURL)

    , m_updateStatus(Idle)

    , m_downloadingPendingMasterResourceLoadersCount(0)

    , m_progressTotal(0)

    , m_progressDone(0)

    , m_frame(0)

    , m_storageID(0)

    , m_isObsolete(false)

    , m_completionType(None)

    , m_isCopy(isCopy)

    , m_calledReachedMaxAppCacheSize(false)

{

}

ApplicationCacheGroup::~ApplicationCacheGroup()

{

    if (m_isCopy) {

        ASSERT(m_newestCache);

        ASSERT(m_caches.size() == 1);

        ASSERT(m_caches.contains(m_newestCache.get()));

        ASSERT(!m_cacheBeingUpdated);

        ASSERT(m_associatedDocumentLoaders.isEmpty());

        ASSERT(m_pendingMasterResourceLoaders.isEmpty());

        ASSERT(m_newestCache->group() == this);

        return;

    }

    ASSERT(!m_newestCache);

    ASSERT(m_caches.isEmpty());

    stopLoading();

    cacheStorage().cacheGroupDestroyed(this);

}

ApplicationCache* ApplicationCacheGroup::cacheForMainRequest(const ResourceRequest& request, DocumentLoader*)

{

    if (!ApplicationCache::requestIsHTTPOrHTTPSGet(request))

        return 0;

    KURL url(request.url());

    if (url.hasFragmentIdentifier())

        url.removeFragmentIdentifier();

    if (ApplicationCacheGroup* group = cacheStorage().cacheGroupForURL(url)) {

        ASSERT(group->newestCache());

        ASSERT(!group->isObsolete());

        return group->newestCache();

    }

    return 0;

}

ApplicationCache* ApplicationCacheGroup::fallbackCacheForMainRequest(const ResourceRequest& request, DocumentLoader*)

{

    if (!ApplicationCache::requestIsHTTPOrHTTPSGet(request))

        return 0;

    KURL url(request.url());

    if (url.hasFragmentIdentifier())

        url.removeFragmentIdentifier();

    if (ApplicationCacheGroup* group = cacheStorage().fallbackCacheGroupForURL(url)) {

        ASSERT(group->newestCache());

        ASSERT(!group->isObsolete());

        return group->newestCache();

    }

    return 0;

}

void ApplicationCacheGroup::selectCache(Frame* frame, const KURL& passedManifestURL)

{

    ASSERT(frame && frame->page());

    if (!frame->settings()->offlineWebApplicationCacheEnabled())

        return;

    DocumentLoader* documentLoader = frame->loader()->documentLoader();

    ASSERT(!documentLoader->applicationCacheHost()->applicationCache());

    if (passedManifestURL.isNull()) {

        selectCacheWithoutManifestURL(frame);        

        return;

    }

    KURL manifestURL(passedManifestURL);

    if (manifestURL.hasFragmentIdentifier())

        manifestURL.removeFragmentIdentifier();

    ApplicationCache* mainResourceCache = documentLoader->applicationCacheHost()->mainResourceApplicationCache();

    if (mainResourceCache) {

        if (manifestURL == mainResourceCache->group()->m_manifestURL) {

            mainResourceCache->group()->associateDocumentLoaderWithCache(documentLoader, mainResourceCache);

            mainResourceCache->group()->update(frame, ApplicationCacheUpdateWithBrowsingContext);

        } else {

            // The main resource was loaded from cache, so the cache must have an entry for it. Mark it as foreign.

            KURL documentURL(documentLoader->url());

            if (documentURL.hasFragmentIdentifier())

                documentURL.removeFragmentIdentifier();

            ApplicationCacheResource* resource = mainResourceCache->resourceForURL(documentURL);

            bool inStorage = resource->storageID();

            resource->addType(ApplicationCacheResource::Foreign);

            if (inStorage)

                cacheStorage().storeUpdatedType(resource, mainResourceCache);

            // Restart the current navigation from the top of the navigation algorithm, undoing any changes that were made

            // as part of the initial load.

            // The navigation will not result in the same resource being loaded, because "foreign" entries are never picked during navigation.

            frame->redirectScheduler()->scheduleLocationChange(documentLoader->url(), frame->loader()->referrer(), true);

        }

        return;

    }

    // The resource was loaded from the network, check if it is a HTTP/HTTPS GET.    

    const ResourceRequest& request = frame->loader()->activeDocumentLoader()->request();

    if (!ApplicationCache::requestIsHTTPOrHTTPSGet(request))

        return;

    // Check that the resource URL has the same scheme/host/port as the manifest URL.

    if (!protocolHostAndPortAreEqual(manifestURL, request.url()))

        return;

    // Don't change anything on disk if private browsing is enabled.

    if (!frame->settings() || frame->settings()->privateBrowsingEnabled()) {

        postListenerTask(ApplicationCacheHost::CHECKING_EVENT, documentLoader);

        postListenerTask(ApplicationCacheHost::ERROR_EVENT, documentLoader);

        return;

    }

    ApplicationCacheGroup* group = cacheStorage().findOrCreateCacheGroup(manifestURL);

    documentLoader->applicationCacheHost()->setCandidateApplicationCacheGroup(group);

    group->m_pendingMasterResourceLoaders.add(documentLoader);

    group->m_downloadingPendingMasterResourceLoadersCount++;

    ASSERT(!group->m_cacheBeingUpdated || group->m_updateStatus != Idle);

    group->update(frame, ApplicationCacheUpdateWithBrowsingContext);

}

void ApplicationCacheGroup::selectCacheWithoutManifestURL(Frame* frame)

{

    if (!frame->settings()->offlineWebApplicationCacheEnabled())

        return;

    DocumentLoader* documentLoader = frame->loader()->documentLoader();

    ASSERT(!documentLoader->applicationCacheHost()->applicationCache());

    ApplicationCache* mainResourceCache = documentLoader->applicationCacheHost()->mainResourceApplicationCache();

    if (mainResourceCache) {

        mainResourceCache->group()->associateDocumentLoaderWithCache(documentLoader, mainResourceCache);

        mainResourceCache->group()->update(frame, ApplicationCacheUpdateWithBrowsingContext);

    }

}

void ApplicationCacheGroup::finishedLoadingMainResource(DocumentLoader* loader)

{

    ASSERT(m_pendingMasterResourceLoaders.contains(loader));

    ASSERT(m_completionType == None || m_pendingEntries.isEmpty());

    KURL url = loader->url();

    if (url.hasFragmentIdentifier())

        url.removeFragmentIdentifier();

    switch (m_completionType) {

    case None:

        // The main resource finished loading before the manifest was ready. It will be handled via dispatchMainResources() later.

        return;

    case NoUpdate:

        ASSERT(!m_cacheBeingUpdated);

        associateDocumentLoaderWithCache(loader, m_newestCache.get());

        if (ApplicationCacheResource* resource = m_newestCache->resourceForURL(url)) {

            if (!(resource->type() & ApplicationCacheResource::Master)) {

                resource->addType(ApplicationCacheResource::Master);

                ASSERT(!resource->storageID());

            }

        } else

            m_newestCache->addResource(ApplicationCacheResource::create(url, loader->response(), ApplicationCacheResource::Master, loader->mainResourceData()));

        break;

    case Failure:

        // Cache update has been a failure, so there is no reason to keep the document associated with the incomplete cache

        // (its main resource was not cached yet, so it is likely that the application changed significantly server-side).

        ASSERT(!m_cacheBeingUpdated); // Already cleared out by stopLoading().

        loader->applicationCacheHost()->setApplicationCache(0); // Will unset candidate, too.

        m_associatedDocumentLoaders.remove(loader);

        postListenerTask(ApplicationCacheHost::ERROR_EVENT, loader);

        break;

    case Completed:

        ASSERT(m_associatedDocumentLoaders.contains(loader));

        if (ApplicationCacheResource* resource = m_cacheBeingUpdated->resourceForURL(url)) {

            if (!(resource->type() & ApplicationCacheResource::Master)) {

                resource->addType(ApplicationCacheResource::Master);

                ASSERT(!resource->storageID());

            }

        } else

            m_cacheBeingUpdated->addResource(ApplicationCacheResource::create(url, loader->response(), ApplicationCacheResource::Master, loader->mainResourceData()));

        // The "cached" event will be posted to all associated documents once update is complete.

        break;

    }

    m_downloadingPendingMasterResourceLoadersCount--;

    checkIfLoadIsComplete();

}

void ApplicationCacheGroup::failedLoadingMainResource(DocumentLoader* loader)

{

    ASSERT(m_pendingMasterResourceLoaders.contains(loader));

    ASSERT(m_completionType == None || m_pendingEntries.isEmpty());

    switch (m_completionType) {

    case None:

        // The main resource finished loading before the manifest was ready. It will be handled via dispatchMainResources() later.

        return;

    case NoUpdate:

        ASSERT(!m_cacheBeingUpdated);

        // The manifest didn't change, and we have a relevant cache - but the main resource download failed mid-way, so it cannot be stored to the cache,

        // and the loader does not get associated to it. If there are other main resources being downloaded for this cache group, they may still succeed.

        postListenerTask(ApplicationCacheHost::ERROR_EVENT, loader);

        break;

    case Failure:

        // Cache update failed, too.

        ASSERT(!m_cacheBeingUpdated); // Already cleared out by stopLoading().

        ASSERT(!loader->applicationCacheHost()->applicationCache() || loader->applicationCacheHost()->applicationCache() == m_cacheBeingUpdated);

        loader->applicationCacheHost()->setApplicationCache(0); // Will unset candidate, too.

        m_associatedDocumentLoaders.remove(loader);

        postListenerTask(ApplicationCacheHost::ERROR_EVENT, loader);

        break;

    case Completed:

        // The cache manifest didn't list this main resource, and all cache entries were already updated successfully - but the main resource failed to load,

        // so it cannot be stored to the cache. If there are other main resources being downloaded for this cache group, they may still succeed.

        ASSERT(m_associatedDocumentLoaders.contains(loader));

        ASSERT(loader->applicationCacheHost()->applicationCache() == m_cacheBeingUpdated);

        ASSERT(!loader->applicationCacheHost()->candidateApplicationCacheGroup());

        m_associatedDocumentLoaders.remove(loader);

        loader->applicationCacheHost()->setApplicationCache(0);

        postListenerTask(ApplicationCacheHost::ERROR_EVENT, loader);

        break;

    }

    m_downloadingPendingMasterResourceLoadersCount--;

    checkIfLoadIsComplete();

}

void ApplicationCacheGroup::stopLoading()

{

    if (m_manifestHandle) {

        ASSERT(!m_currentHandle);

        m_manifestHandle->setClient(0);

        m_manifestHandle->cancel();

        m_manifestHandle = 0;

    }

    if (m_currentHandle) {

        ASSERT(!m_manifestHandle);

        ASSERT(m_cacheBeingUpdated);

        m_currentHandle->setClient(0);

        m_currentHandle->cancel();

        m_currentHandle = 0;

    }    

    m_cacheBeingUpdated = 0;

    m_pendingEntries.clear();

}    

void ApplicationCacheGroup::disassociateDocumentLoader(DocumentLoader* loader)

{

    HashSet<DocumentLoader*>::iterator it = m_associatedDocumentLoaders.find(loader);

    if (it != m_associatedDocumentLoaders.end())

        m_associatedDocumentLoaders.remove(it);

    m_pendingMasterResourceLoaders.remove(loader);

    loader->applicationCacheHost()->setApplicationCache(0); // Will set candidate to 0, too.

    if (!m_associatedDocumentLoaders.isEmpty() || !m_pendingMasterResourceLoaders.isEmpty())

        return;

    if (m_caches.isEmpty()) {

        // There is an initial cache attempt in progress.

        ASSERT(!m_newestCache);

        // Delete ourselves, causing the cache attempt to be stopped.

        delete this;

        return;

    }

    ASSERT(m_caches.contains(m_newestCache.get()));

    // Release our reference to the newest cache. This could cause us to be deleted.

    // Any ongoing updates will be stopped from destructor.

    m_newestCache.release();

}

void ApplicationCacheGroup::cacheDestroyed(ApplicationCache* cache)

{

    if (!m_caches.contains(cache))

        return;

    m_caches.remove(cache);

    if (m_caches.isEmpty()) {

        ASSERT(m_associatedDocumentLoaders.isEmpty());

        ASSERT(m_pendingMasterResourceLoaders.isEmpty());

        delete this;

    }

}

#if ENABLE(INSPECTOR)

static void inspectorUpdateApplicationCacheStatus(Frame* frame)

{

    if (!frame)

        return;

    if (Page *page = frame->page()) {

        if (InspectorApplicationCacheAgent* applicationCacheAgent = page->inspectorController()->applicationCacheAgent()) {

            ApplicationCacheHost::Status status = frame->loader()->documentLoader()->applicationCacheHost()->status();

            applicationCacheAgent->updateApplicationCacheStatus(status);

        }

    }

}

#endif

void ApplicationCacheGroup::setNewestCache(PassRefPtr<ApplicationCache> newestCache)

{

    m_newestCache = newestCache;

    m_caches.add(m_newestCache.get());

    m_newestCache->setGroup(this);

#if ENABLE(INSPECTOR)

    inspectorUpdateApplicationCacheStatus(m_frame);

#endif

}

void ApplicationCacheGroup::makeObsolete()

{

    if (isObsolete())

        return;

    m_isObsolete = true;

    cacheStorage().cacheGroupMadeObsolete(this);

    ASSERT(!m_storageID);

#if ENABLE(INSPECTOR)

    inspectorUpdateApplicationCacheStatus(m_frame);

#endif

}

void ApplicationCacheGroup::update(Frame* frame, ApplicationCacheUpdateOption updateOption)

{

    if (m_updateStatus == Checking || m_updateStatus == Downloading) {

        if (updateOption == ApplicationCacheUpdateWithBrowsingContext) {

            postListenerTask(ApplicationCacheHost::CHECKING_EVENT, frame->loader()->documentLoader());

            if (m_updateStatus == Downloading)

                postListenerTask(ApplicationCacheHost::DOWNLOADING_EVENT, frame->loader()->documentLoader());

        }

        return;

    }

    // Don't change anything on disk if private browsing is enabled.

    if (!frame->settings() || frame->settings()->privateBrowsingEnabled()) {

        ASSERT(m_pendingMasterResourceLoaders.isEmpty());

        ASSERT(m_pendingEntries.isEmpty());

        ASSERT(!m_cacheBeingUpdated);

        postListenerTask(ApplicationCacheHost::CHECKING_EVENT, frame->loader()->documentLoader());

        postListenerTask(ApplicationCacheHost::NOUPDATE_EVENT, frame->loader()->documentLoader());

        return;

    }

    ASSERT(!m_frame);

    m_frame = frame;

    setUpdateStatus(Checking);

    postListenerTask(ApplicationCacheHost::CHECKING_EVENT, m_associatedDocumentLoaders);

    if (!m_newestCache) {

        ASSERT(updateOption == ApplicationCacheUpdateWithBrowsingContext);

        postListenerTask(ApplicationCacheHost::CHECKING_EVENT, frame->loader()->documentLoader());

    }

    ASSERT(!m_manifestHandle);

    ASSERT(!m_manifestResource);

    ASSERT(m_completionType == None);

    // FIXME: Handle defer loading

    m_manifestHandle = createResourceHandle(m_manifestURL, m_newestCache ? m_newestCache->manifestResource() : 0);

}

PassRefPtr<ResourceHandle> ApplicationCacheGroup::createResourceHandle(const KURL& url, ApplicationCacheResource* newestCachedResource)

{

    ResourceRequest request(url);

    m_frame->loader()->applyUserAgent(request);

    request.setHTTPHeaderField("Cache-Control", "max-age=0");

    if (newestCachedResource) {

        const String& lastModified = newestCachedResource->response().httpHeaderField("Last-Modified");

        const String& eTag = newestCachedResource->response().httpHeaderField("ETag");

        if (!lastModified.isEmpty() || !eTag.isEmpty()) {

            if (!lastModified.isEmpty())

                request.setHTTPHeaderField("If-Modified-Since", lastModified);

            if (!eTag.isEmpty())

                request.setHTTPHeaderField("If-None-Match", eTag);

        }

    }

    RefPtr<ResourceHandle> handle = ResourceHandle::create(request, this, m_frame, false, true);

#if ENABLE(INSPECTOR)

    // Because willSendRequest only gets called during redirects, we initialize

    // the identifier and the first willSendRequest here.

    m_currentResourceIdentifier = m_frame->page()->progress()->createUniqueIdentifier();

    if (Page* page = m_frame->page()) {

        InspectorController* inspectorController = page->inspectorController();

        inspectorController->identifierForInitialRequest(m_currentResourceIdentifier, m_frame->loader()->documentLoader(), handle->firstRequest());

        ResourceResponse redirectResponse = ResourceResponse();

        inspectorController->willSendRequest(m_currentResourceIdentifier, request, redirectResponse);

    }

#endif

    return handle;

}

#if ENABLE(INSPECTOR)

void ApplicationCacheGroup::willSendRequest(ResourceHandle*, ResourceRequest& request, const ResourceResponse& redirectResponse)

{

    // This only gets called by ResourceHandleMac if there is a redirect.

    if (Page* page = m_frame->page())

        page->inspectorController()->willSendRequest(m_currentResourceIdentifier, request, redirectResponse);

}

#endif

void ApplicationCacheGroup::didReceiveResponse(ResourceHandle* handle, const ResourceResponse& response)

{

#if ENABLE(INSPECTOR)

    if (Page* page = m_frame->page()) {

        if (handle == m_manifestHandle) {

            if (InspectorApplicationCacheAgent* applicationCacheAgent = page->inspectorController()->applicationCacheAgent())

                applicationCacheAgent->didReceiveManifestResponse(m_currentResourceIdentifier, response);

        } else

            page->inspectorController()->didReceiveResponse(m_currentResourceIdentifier, response);

    }

#endif

    if (handle == m_manifestHandle) {

        didReceiveManifestResponse(response);

        return;

    }

    ASSERT(handle == m_currentHandle);

    KURL url(handle->firstRequest().url());

    if (url.hasFragmentIdentifier())

        url.removeFragmentIdentifier();

    ASSERT(!m_currentResource);

    ASSERT(m_pendingEntries.contains(url));

    unsigned type = m_pendingEntries.get(url);