/*

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

 */

#ifndef ApplicationCacheGroup_h

#define ApplicationCacheGroup_h

#if ENABLE(OFFLINE_WEB_APPLICATIONS)

#include <wtf/Noncopyable.h>

#include <wtf/HashMap.h>

#include <wtf/HashSet.h>

#include "DOMApplicationCache.h"

#include "KURL.h"

#include "PlatformString.h"

#include "ResourceHandle.h"

#include "ResourceHandleClient.h"

#include "SharedBuffer.h"

namespace WebCore {

class ApplicationCache;

class ApplicationCacheResource;

class Document;

class DocumentLoader;

class Frame;

enum ApplicationCacheUpdateOption {

    ApplicationCacheUpdateWithBrowsingContext,

    ApplicationCacheUpdateWithoutBrowsingContext

};

class ApplicationCacheGroup : public Noncopyable, ResourceHandleClient {

public:

    ApplicationCacheGroup(const KURL& manifestURL, bool isCopy = false);    

    ~ApplicationCacheGroup();

    enum UpdateStatus { Idle, Checking, Downloading };

    static ApplicationCache* cacheForMainRequest(const ResourceRequest&, DocumentLoader*);

    static ApplicationCache* fallbackCacheForMainRequest(const ResourceRequest&, DocumentLoader*);

    static void selectCache(Frame*, const KURL& manifestURL);

    static void selectCacheWithoutManifestURL(Frame*);

    const KURL& manifestURL() const { return m_manifestURL; }

    UpdateStatus updateStatus() const { return m_updateStatus; }

    void setUpdateStatus(UpdateStatus status);

    void setStorageID(unsigned storageID) { m_storageID = storageID; }

    unsigned storageID() const { return m_storageID; }

    void clearStorageID();

    void update(Frame*, ApplicationCacheUpdateOption); // FIXME: Frame should not be needed when updating without browsing context.

    void cacheDestroyed(ApplicationCache*);

    bool cacheIsBeingUpdated(const ApplicationCache* cache) const { return cache == m_cacheBeingUpdated; }

    ApplicationCache* newestCache() const { return m_newestCache.get(); }

    void setNewestCache(PassRefPtr<ApplicationCache>);

    void makeObsolete();

    bool isObsolete() const { return m_isObsolete; }

    void finishedLoadingMainResource(DocumentLoader*);

    void failedLoadingMainResource(DocumentLoader*);

    void disassociateDocumentLoader(DocumentLoader*);

    bool isCopy() const { return m_isCopy; }

private:

    static void postListenerTask(ApplicationCacheHost::EventID id, const HashSet<DocumentLoader*>& set) { postListenerTask(id, 0, 0, set); }

    static void postListenerTask(ApplicationCacheHost::EventID id, DocumentLoader* loader)  { postListenerTask(id, 0, 0, loader); }

    static void postListenerTask(ApplicationCacheHost::EventID, int progressTotal, int progressDone, const HashSet<DocumentLoader*>&);

    static void postListenerTask(ApplicationCacheHost::EventID, int progressTotal, int progressDone, DocumentLoader*);

    void scheduleReachedMaxAppCacheSizeCallback();

    PassRefPtr<ResourceHandle> createResourceHandle(const KURL&, ApplicationCacheResource* newestCachedResource);

    // For normal resource loading, WebKit client is asked about each resource individually. Since application cache does not belong to any particular document,

    // the existing client callback cannot be used, so assume that any client that enables application cache also wants it to use credential storage.

    virtual bool shouldUseCredentialStorage(ResourceHandle*) { return true; }

#if ENABLE(INSPECTOR)

    virtual void willSendRequest(ResourceHandle*, ResourceRequest&, const ResourceResponse&);

#endif

    virtual void didReceiveResponse(ResourceHandle*, const ResourceResponse&);

    virtual void didReceiveData(ResourceHandle*, const char*, int length, int lengthReceived);

    virtual void didFinishLoading(ResourceHandle*);

    virtual void didFail(ResourceHandle*, const ResourceError&);

    void didReceiveManifestResponse(const ResourceResponse&);

    void didReceiveManifestData(const char*, int);

    void didFinishLoadingManifest();

    void didReachMaxAppCacheSize();

    void startLoadingEntry();

    void deliverDelayedMainResources();

    void checkIfLoadIsComplete();

    void cacheUpdateFailed();

    void manifestNotFound();

    void addEntry(const String&, unsigned type);

    void associateDocumentLoaderWithCache(DocumentLoader*, ApplicationCache*);

    void stopLoading();

    KURL m_manifestURL;

    UpdateStatus m_updateStatus;

    // This is the newest complete cache in the group.

    RefPtr<ApplicationCache> m_newestCache;

    // All complete caches in this cache group.

    HashSet<ApplicationCache*> m_caches;

    // The cache being updated (if any). Note that cache updating does not immediately create a new

    // ApplicationCache object, so this may be null even when update status is not Idle.

    RefPtr<ApplicationCache> m_cacheBeingUpdated;

    // List of pending master entries, used during the update process to ensure that new master entries are cached.

    HashSet<DocumentLoader*> m_pendingMasterResourceLoaders;

    // How many of the above pending master entries have not yet finished downloading.

    int m_downloadingPendingMasterResourceLoadersCount;

    // These are all the document loaders that are associated with a cache in this group.

    HashSet<DocumentLoader*> m_associatedDocumentLoaders;

    // The URLs and types of pending cache entries.

    typedef HashMap<String, unsigned> EntryMap;

    EntryMap m_pendingEntries;

    // The total number of items to be processed to update the cache group and the number that have been done.

    int m_progressTotal;

    int m_progressDone;

    // Frame used for fetching resources when updating.

    // FIXME: An update started by a particular frame should not stop if it is destroyed, but there are other frames associated with the same cache group.

    Frame* m_frame;

    // An obsolete cache group is never stored, but the opposite is not true - storing may fail for multiple reasons, such as exceeding disk quota.

    unsigned m_storageID;

    bool m_isObsolete;

    // During update, this is used to handle asynchronously arriving results.

    enum CompletionType {

        None,

        NoUpdate,

        Failure,

        Completed

    };

    CompletionType m_completionType;

    // Whether this cache group is a copy that's only used for transferring the cache to another file.

    bool m_isCopy;

    // This flag is set immediately after the ChromeClient::reachedMaxAppCacheSize() callback is invoked as a result of the storage layer failing to save a cache

    // due to reaching the maximum size of the application cache database file. This flag is used by ApplicationCacheGroup::checkIfLoadIsComplete() to decide

    // the course of action in case of this failure (i.e. call the ChromeClient callback or run the failure steps).

    bool m_calledReachedMaxAppCacheSize;

    RefPtr<ResourceHandle> m_currentHandle;

    RefPtr<ApplicationCacheResource> m_currentResource;

#if ENABLE(INSPECTOR)

    unsigned long m_currentResourceIdentifier;

#endif

    RefPtr<ApplicationCacheResource> m_manifestResource;

    RefPtr<ResourceHandle> m_manifestHandle;

    friend class ChromeClientCallbackTimer;

};

} // namespace WebCore

#endif // ENABLE(OFFLINE_WEB_APPLICATIONS)

#endif // ApplicationCacheGroup_h