/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */

/* vim: set ts=8 sts=4 et sw=4 tw=80: */

/* This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef _nsCacheService_h_

#define _nsCacheService_h_

#include "nsICacheService.h"

#include "nsCacheSession.h"

#include "nsCacheDevice.h"

#include "nsCacheEntry.h"

#include "nsThreadUtils.h"

#include "nsICacheListener.h"

#include "nsIMemoryReporter.h"

#include "prthread.h"

#include "nsIObserver.h"

#include "nsString.h"

#include "nsTArray.h"

#include "nsRefPtrHashtable.h"

#include "mozilla/CondVar.h"

#include "mozilla/Mutex.h"

#include "mozilla/Telemetry.h"

class nsCacheRequest;

class nsCacheProfilePrefObserver;

class nsDiskCacheDevice;

class nsMemoryCacheDevice;

class nsOfflineCacheDevice;

class nsCacheServiceAutoLock;

class nsITimer;

class mozIStorageService;

/******************************************************************************

 * nsNotifyDoomListener

 *****************************************************************************/

class nsNotifyDoomListener : public mozilla::Runnable {

public:

  nsNotifyDoomListener(nsICacheListener* listener, nsresult status)

    : mozilla::Runnable("nsNotifyDoomListener")

    , mListener(listener) // transfers reference

    , mStatus(status)

  {

  }

  NS_IMETHOD Run() override

  {

    mListener->OnCacheEntryDoomed(mStatus);

    NS_RELEASE(mListener);

    return NS_OK;

    }

private:

    nsICacheListener *mListener;

    nsresult          mStatus;

};

/******************************************************************************

 *  nsCacheService

 ******************************************************************************/

class nsCacheService final : public nsICacheServiceInternal,

                             public nsIMemoryReporter

{

    virtual ~nsCacheService();

public:

    NS_DECL_THREADSAFE_ISUPPORTS

    NS_DECL_NSICACHESERVICE

    NS_DECL_NSICACHESERVICEINTERNAL

    NS_DECL_NSIMEMORYREPORTER

    nsCacheService();

    // Define a Create method to be used with a factory:

    static nsresult

    Create(nsISupports* outer, const nsIID& iid, void* *result);

    /**

     * Methods called by nsCacheSession

     */

    static nsresult  OpenCacheEntry(nsCacheSession *           session,

                                    const nsACString &         key,

                                    nsCacheAccessMode          accessRequested,

                                    bool                       blockingMode,

                                    nsICacheListener *         listener,

                                    nsICacheEntryDescriptor ** result);

    static nsresult  EvictEntriesForSession(nsCacheSession *   session);

    static nsresult  IsStorageEnabledForPolicy(nsCacheStoragePolicy  storagePolicy,

                                               bool *              result);

    static nsresult  DoomEntry(nsCacheSession   *session,

                               const nsACString &key,

                               nsICacheListener *listener);

    /**

     * Methods called by nsCacheEntryDescriptor

     */

    static void      CloseDescriptor(nsCacheEntryDescriptor * descriptor);

    static nsresult  GetFileForEntry(nsCacheEntry *         entry,

                                     nsIFile **             result);

    static nsresult  OpenInputStreamForEntry(nsCacheEntry *     entry,

                                             nsCacheAccessMode  mode,

                                             uint32_t           offset,

                                             nsIInputStream **  result);

    static nsresult  OpenOutputStreamForEntry(nsCacheEntry *     entry,

                                              nsCacheAccessMode  mode,

                                              uint32_t           offset,

                                              nsIOutputStream ** result);

    static nsresult  OnDataSizeChange(nsCacheEntry * entry, int32_t deltaSize);

    static nsresult  SetCacheElement(nsCacheEntry * entry, nsISupports * element);

    static nsresult  ValidateEntry(nsCacheEntry * entry);

    static int32_t   CacheCompressionLevel();

    static bool      GetClearingEntries();

    static void      GetCacheBaseDirectoty(nsIFile ** result);

    static void      GetDiskCacheDirectory(nsIFile ** result);

    static void      GetAppCacheDirectory(nsIFile ** result);

    /**

     * Methods called by any cache classes

     */

    static

    nsCacheService * GlobalInstance()   { return gService; }

    static nsresult  DoomEntry(nsCacheEntry * entry);

    static bool      IsStorageEnabledForPolicy_Locked(nsCacheStoragePolicy policy);

    /**

     * Called by disk cache to notify us to use the new max smart size

     */

    static void      MarkStartingFresh();

    /**

     * Methods called by nsApplicationCacheService

     */

    nsresult GetOfflineDevice(nsOfflineCacheDevice ** aDevice);

    /**

     * Creates an offline cache device that works over a specific profile directory.

     * A tool to preload offline cache for profiles different from the current

     * application's profile directory.

     */

    nsresult GetCustomOfflineDevice(nsIFile *aProfileDir,

                                    int32_t aQuota,

                                    nsOfflineCacheDevice **aDevice);

    // This method may be called to release an object while the cache service

    // lock is being held.  If a non-null target is specified and the target

    // does not correspond to the current thread, then the release will be

    // proxied to the specified target.  Otherwise, the object will be added to

    // the list of objects to be released when the cache service is unlocked.

    static void      ReleaseObject_Locked(nsISupports *    object,

                                          nsIEventTarget * target = nullptr);

    static nsresult DispatchToCacheIOThread(nsIRunnable* event);

    // Calling this method will block the calling thread until all pending

    // events on the cache-io thread has finished. The calling thread must

    // hold the cache-lock

    static nsresult SyncWithCacheIOThread();

    /**

     * Methods called by nsCacheProfilePrefObserver

     */

    static void      OnProfileShutdown();

    static void      OnProfileChanged();

    static void      SetDiskCacheEnabled(bool    enabled);

    // Sets the disk cache capacity (in kilobytes)

    static void      SetDiskCacheCapacity(int32_t  capacity);

    // Set max size for a disk-cache entry (in KB). -1 disables limit up to

    // 1/8th of disk cache size

    static void      SetDiskCacheMaxEntrySize(int32_t  maxSize);

    // Set max size for a memory-cache entry (in kilobytes). -1 disables

    // limit up to 90% of memory cache size

    static void      SetMemoryCacheMaxEntrySize(int32_t  maxSize);

    static void      SetOfflineCacheEnabled(bool    enabled);

    // Sets the offline cache capacity (in kilobytes)

    static void      SetOfflineCacheCapacity(int32_t  capacity);

    static void      SetMemoryCache();

    static void      SetCacheCompressionLevel(int32_t level);

    // Starts smart cache size computation if disk device is available

    static nsresult  SetDiskSmartSize();

    static void      MoveOrRemoveDiskCache(nsIFile *aOldCacheDir,

                                           nsIFile *aNewCacheDir,

                                           const char *aCacheSubdir);

    nsresult         Init();

    void             Shutdown();

    static bool      IsInitialized()

    {

      if (!gService) {

          return false;

      }

      return gService->mInitialized;

    }

    static void      AssertOwnsLock()

    { gService->mLock.AssertCurrentThreadOwns(); }

    static void      LeavePrivateBrowsing();

    bool             IsDoomListEmpty();

    typedef bool (*DoomCheckFn)(nsCacheEntry* entry);

    // Accessors to the disabled functionality

    nsresult CreateSessionInternal(const char *          clientID,

                                   nsCacheStoragePolicy  storagePolicy,

                                   bool                  streamBased,

                                   nsICacheSession     **result);

    nsresult VisitEntriesInternal(nsICacheVisitor *visitor);

    nsresult EvictEntriesInternal(nsCacheStoragePolicy storagePolicy);

private:

    friend class nsCacheServiceAutoLock;

    friend class nsOfflineCacheDevice;

    friend class nsProcessRequestEvent;

    friend class nsSetSmartSizeEvent;

    friend class nsBlockOnCacheThreadEvent;

    friend class nsSetDiskSmartSizeCallback;

    friend class nsDoomEvent;

    friend class nsDisableOldMaxSmartSizePrefEvent;

    friend class nsDiskCacheMap;

    friend class nsAsyncDoomEvent;

    friend class nsCacheEntryDescriptor;

    /**

     * Internal Methods

     */

    static void      Lock();

    static void      Lock(::mozilla::Telemetry::HistogramID mainThreadLockerID);

    static void      Unlock();

    void             LockAcquired();

    void             LockReleased();

    nsresult         CreateDiskDevice();

    nsresult         CreateOfflineDevice();

    nsresult         CreateCustomOfflineDevice(nsIFile *aProfileDir,

                                               int32_t aQuota,

                                               nsOfflineCacheDevice **aDevice);

    nsresult         CreateMemoryDevice();

    nsresult         RemoveCustomOfflineDevice(nsOfflineCacheDevice *aDevice);

    nsresult         CreateRequest(nsCacheSession *   session,

                                   const nsACString & clientKey,

                                   nsCacheAccessMode  accessRequested,

                                   bool               blockingMode,

                                   nsICacheListener * listener,

                                   nsCacheRequest **  request);

    nsresult         DoomEntry_Internal(nsCacheEntry * entry,

                                        bool doProcessPendingRequests);

    nsresult         EvictEntriesForClient(const char *          clientID,

                                           nsCacheStoragePolicy  storagePolicy);

    // Notifies request listener asynchronously on the request's thread, and

    // releases the descriptor on the request's thread.  If this method fails,

    // the descriptor is not released.

    nsresult         NotifyListener(nsCacheRequest *          request,

                                    nsICacheEntryDescriptor * descriptor,

                                    nsCacheAccessMode         accessGranted,

                                    nsresult                  error);

    nsresult         ActivateEntry(nsCacheRequest * request,

                                   nsCacheEntry ** entry,

                                   nsCacheEntry ** doomedEntry);

    nsCacheDevice *  EnsureEntryHasDevice(nsCacheEntry * entry);

    nsCacheEntry *   SearchCacheDevices(nsCString * key, nsCacheStoragePolicy policy, bool *collision);

    void             DeactivateEntry(nsCacheEntry * entry);

    nsresult         ProcessRequest(nsCacheRequest *           request,

                                    bool                       calledFromOpenCacheEntry,

                                    nsICacheEntryDescriptor ** result);

    nsresult         ProcessPendingRequests(nsCacheEntry * entry);

    void             ClearDoomList(void);

    void             DoomActiveEntries(DoomCheckFn check);

    void             CloseAllStreams();

    void             FireClearNetworkCacheStoredAnywhereNotification();

    void LogCacheStatistics();

    nsresult         SetDiskSmartSize_Locked();

    /**

     *  Data Members

     */

    static nsCacheService *         gService;  // there can be only one...

    nsCOMPtr<mozIStorageService>    mStorageService;

    nsCacheProfilePrefObserver *    mObserver;

    mozilla::Mutex                  mLock;

    mozilla::CondVar                mCondVar;

    bool                            mNotified;

    mozilla::Mutex                  mTimeStampLock;

    mozilla::TimeStamp              mLockAcquiredTimeStamp;

    nsCOMPtr<nsIThread>             mCacheIOThread;

    nsTArray<nsISupports*>          mDoomedObjects;

    nsCOMPtr<nsITimer>              mSmartSizeTimer;

    bool                            mInitialized;

    bool                            mClearingEntries;

    bool                            mEnableMemoryDevice;

    bool                            mEnableDiskDevice;

    bool                            mEnableOfflineDevice;

    nsMemoryCacheDevice *           mMemoryDevice;

    nsDiskCacheDevice *             mDiskDevice;

    nsOfflineCacheDevice *          mOfflineDevice;

    nsRefPtrHashtable<nsStringHashKey, nsOfflineCacheDevice> mCustomOfflineDevices;

    nsCacheEntryHashTable           mActiveEntries;

    PRCList                         mDoomedEntries;

    // stats

    uint32_t                        mTotalEntries;

    uint32_t                        mCacheHits;

    uint32_t                        mCacheMisses;

    uint32_t                        mMaxKeyLength;

    uint32_t                        mMaxDataSize;

    uint32_t                        mMaxMetaSize;

    // Unexpected error totals

    uint32_t                        mDeactivateFailures;

    uint32_t                        mDeactivatedUnboundEntries;

};

/******************************************************************************

 *  nsCacheServiceAutoLock

 ******************************************************************************/

#define LOCK_TELEM(x) \

  (::mozilla::Telemetry::CACHE_SERVICE_LOCK_WAIT_MAINTHREAD_##x)

// Instantiate this class to acquire the cache service lock for a particular

// execution scope.

class nsCacheServiceAutoLock {

public:

    nsCacheServiceAutoLock() {

        nsCacheService::Lock();

    }

    explicit nsCacheServiceAutoLock(mozilla::Telemetry::HistogramID mainThreadLockerID) {

        nsCacheService::Lock(mainThreadLockerID);

    }

    ~nsCacheServiceAutoLock() {

        nsCacheService::Unlock();

    }

};

#endif // _nsCacheService_h_