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

#include "nsDiskCache.h"

#include "nsDiskCacheDeviceSQL.h"

#include "nsCacheService.h"

#include "nsApplicationCacheService.h"

#include "nsCRT.h"

#include "nsNetCID.h"

#include "nsNetUtil.h"

#include "nsIObserverService.h"

#include "nsIPrincipal.h"

#include "mozilla/LoadContextInfo.h"

using namespace mozilla;

static NS_DEFINE_CID(kCacheServiceCID, NS_CACHESERVICE_CID);

//-----------------------------------------------------------------------------

// nsApplicationCacheService

//-----------------------------------------------------------------------------

NS_IMPL_ISUPPORTS(nsApplicationCacheService, nsIApplicationCacheService)

nsApplicationCacheService::nsApplicationCacheService()

{

    nsCOMPtr<nsICacheService> serv = do_GetService(kCacheServiceCID);

    mCacheService = nsCacheService::GlobalInstance();

}

NS_IMETHODIMP

nsApplicationCacheService::BuildGroupIDForInfo(

    nsIURI *aManifestURL,

    nsILoadContextInfo *aLoadContextInfo,

    nsACString &_result)

{

    nsresult rv;

    nsAutoCString originSuffix;

    if (aLoadContextInfo) {

        aLoadContextInfo->OriginAttributesPtr()->CreateSuffix(originSuffix);

    }

    rv = nsOfflineCacheDevice::BuildApplicationCacheGroupID(

        aManifestURL, originSuffix, _result);

    NS_ENSURE_SUCCESS(rv, rv);

    return NS_OK;

}

NS_IMETHODIMP

nsApplicationCacheService::BuildGroupIDForSuffix(

    nsIURI *aManifestURL,

    nsACString const &aOriginSuffix,

    nsACString &_result)

{

    nsresult rv;

    rv = nsOfflineCacheDevice::BuildApplicationCacheGroupID(

        aManifestURL, aOriginSuffix, _result);

    NS_ENSURE_SUCCESS(rv, rv);

    return NS_OK;

}

NS_IMETHODIMP

nsApplicationCacheService::CreateApplicationCache(const nsACString &group,

                                                  nsIApplicationCache **out)

{

    if (!mCacheService)

        return NS_ERROR_UNEXPECTED;

    RefPtr<nsOfflineCacheDevice> device;

    nsresult rv = mCacheService->GetOfflineDevice(getter_AddRefs(device));

    NS_ENSURE_SUCCESS(rv, rv);

    return device->CreateApplicationCache(group, out);

}

NS_IMETHODIMP

nsApplicationCacheService::CreateCustomApplicationCache(const nsACString & group,

                                                        nsIFile *profileDir,

                                                        int32_t quota,

                                                        nsIApplicationCache **out)

{

    if (!mCacheService)

        return NS_ERROR_UNEXPECTED;

    RefPtr<nsOfflineCacheDevice> device;

    nsresult rv = mCacheService->GetCustomOfflineDevice(profileDir,

                                                        quota,

                                                        getter_AddRefs(device));

    NS_ENSURE_SUCCESS(rv, rv);

    return device->CreateApplicationCache(group, out);

}

NS_IMETHODIMP

nsApplicationCacheService::GetApplicationCache(const nsACString &clientID,

                                               nsIApplicationCache **out)

{

    if (!mCacheService)

        return NS_ERROR_UNEXPECTED;

    RefPtr<nsOfflineCacheDevice> device;

    nsresult rv = mCacheService->GetOfflineDevice(getter_AddRefs(device));

    NS_ENSURE_SUCCESS(rv, rv);

    return device->GetApplicationCache(clientID, out);

}

NS_IMETHODIMP

nsApplicationCacheService::GetActiveCache(const nsACString &group,

                                          nsIApplicationCache **out)

{

    if (!mCacheService)

        return NS_ERROR_UNEXPECTED;

    RefPtr<nsOfflineCacheDevice> device;

    nsresult rv = mCacheService->GetOfflineDevice(getter_AddRefs(device));

    NS_ENSURE_SUCCESS(rv, rv);

    return device->GetActiveCache(group, out);

}

NS_IMETHODIMP

nsApplicationCacheService::DeactivateGroup(const nsACString &group)

{

    if (!mCacheService)

        return NS_ERROR_UNEXPECTED;

    RefPtr<nsOfflineCacheDevice> device;

    nsresult rv = mCacheService->GetOfflineDevice(getter_AddRefs(device));

    NS_ENSURE_SUCCESS(rv, rv);

    return device->DeactivateGroup(group);

}

NS_IMETHODIMP

nsApplicationCacheService::ChooseApplicationCache(const nsACString &key,

                                                  nsILoadContextInfo *aLoadContextInfo,

                                                  nsIApplicationCache **out)

{

    if (!mCacheService)

        return NS_ERROR_UNEXPECTED;

    RefPtr<nsOfflineCacheDevice> device;

    nsresult rv = mCacheService->GetOfflineDevice(getter_AddRefs(device));

    NS_ENSURE_SUCCESS(rv, rv);

    return device->ChooseApplicationCache(key, aLoadContextInfo, out);

}

NS_IMETHODIMP

nsApplicationCacheService::CacheOpportunistically(nsIApplicationCache* cache,

                                                  const nsACString &key)

{

    if (!mCacheService)

        return NS_ERROR_UNEXPECTED;

    RefPtr<nsOfflineCacheDevice> device;

    nsresult rv = mCacheService->GetOfflineDevice(getter_AddRefs(device));

    NS_ENSURE_SUCCESS(rv, rv);

    return device->CacheOpportunistically(cache, key);

}

NS_IMETHODIMP

nsApplicationCacheService::Evict(nsILoadContextInfo *aInfo)

{

    if (!mCacheService)

        return NS_ERROR_UNEXPECTED;

    RefPtr<nsOfflineCacheDevice> device;

    nsresult rv = mCacheService->GetOfflineDevice(getter_AddRefs(device));

    NS_ENSURE_SUCCESS(rv, rv);

    return device->Evict(aInfo);

}

NS_IMETHODIMP

nsApplicationCacheService::EvictMatchingOriginAttributes(nsAString const &aPattern)

{

    if (!mCacheService)

        return NS_ERROR_UNEXPECTED;

    RefPtr<nsOfflineCacheDevice> device;

    nsresult rv = mCacheService->GetOfflineDevice(getter_AddRefs(device));

    NS_ENSURE_SUCCESS(rv, rv);

    mozilla::OriginAttributesPattern pattern;

    if (!pattern.Init(aPattern)) {

        NS_ERROR("Could not parse OriginAttributesPattern JSON in clear-origin-attributes-data notification");

        return NS_ERROR_FAILURE;

    }

    return device->Evict(pattern);

}

NS_IMETHODIMP

nsApplicationCacheService::GetGroups(uint32_t *count,

                                     char ***keys)

{

    if (!mCacheService)

        return NS_ERROR_UNEXPECTED;

    RefPtr<nsOfflineCacheDevice> device;

    nsresult rv = mCacheService->GetOfflineDevice(getter_AddRefs(device));

    NS_ENSURE_SUCCESS(rv, rv);

    return device->GetGroups(count, keys);

}

NS_IMETHODIMP

nsApplicationCacheService::GetGroupsTimeOrdered(uint32_t *count,

                                                char ***keys)

{

    if (!mCacheService)

        return NS_ERROR_UNEXPECTED;

    RefPtr<nsOfflineCacheDevice> device;

    nsresult rv = mCacheService->GetOfflineDevice(getter_AddRefs(device));

    NS_ENSURE_SUCCESS(rv, rv);

    return device->GetGroupsTimeOrdered(count, keys);

}

//-----------------------------------------------------------------------------

// AppCacheClearDataObserver: handles clearing appcache data for app uninstall

// and clearing user data events.

//-----------------------------------------------------------------------------

namespace {

class AppCacheClearDataObserver final : public nsIObserver {

public:

    NS_DECL_ISUPPORTS

    // nsIObserver implementation.

    NS_IMETHOD

    Observe(nsISupports *aSubject, const char *aTopic, const char16_t *aData) override

    {

        MOZ_ASSERT(!nsCRT::strcmp(aTopic, "clear-origin-attributes-data"));

        nsresult rv;

        nsCOMPtr<nsIApplicationCacheService> cacheService =

            do_GetService(NS_APPLICATIONCACHESERVICE_CONTRACTID, &rv);

        NS_ENSURE_SUCCESS(rv, rv);

        return cacheService->EvictMatchingOriginAttributes(nsDependentString(aData));

    }

private:

    ~AppCacheClearDataObserver() = default;

};

NS_IMPL_ISUPPORTS(AppCacheClearDataObserver, nsIObserver)

} // namespace

// Instantiates and registers AppCacheClearDataObserver for notifications

void

nsApplicationCacheService::AppClearDataObserverInit()

{

  nsCOMPtr<nsIObserverService> observerService = services::GetObserverService();

  if (observerService) {

    RefPtr<AppCacheClearDataObserver> obs = new AppCacheClearDataObserver();

    observerService->AddObserver(obs, "clear-origin-attributes-data", /*ownsWeak=*/ false);

  }

}