wine/gecko
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/wine-gecko.git synced 2024-09-13 09:24:08 -07:00
Code Issues Packages Projects Releases Wiki Activity
968ab88a55
gecko/uriloader/prefetch/nsOfflineCacheUpdate.cpp

2464 lines
74 KiB
C++
Raw Blame History

/* -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* 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 "nsOfflineCacheUpdate.h"
#include "nsCPrefetchService.h"
#include "nsCURILoader.h"
#include "nsIApplicationCacheContainer.h"
#include "nsIApplicationCacheChannel.h"
#include "nsIApplicationCacheService.h"
#include "nsICachingChannel.h"
#include "nsIContent.h"
#include "mozilla/dom/Element.h"
#include "nsIDocumentLoader.h"
#include "nsIDOMElement.h"
#include "nsIDOMWindow.h"
#include "nsIDOMOfflineResourceList.h"
#include "nsIDocument.h"
#include "nsIObserverService.h"
#include "nsIURL.h"
#include "nsIWebProgress.h"
#include "nsICryptoHash.h"
#include "nsICacheEntry.h"
#include "nsIPermissionManager.h"
#include "nsIPrincipal.h"
#include "nsNetCID.h"
#include "nsNetUtil.h"
#include "nsServiceManagerUtils.h"
#include "nsStreamUtils.h"
#include "nsThreadUtils.h"
#include "nsProxyRelease.h"
#include "nsIConsoleService.h"
#include "mozilla/Logging.h"
#include "nsIAsyncVerifyRedirectCallback.h"
#include "mozilla/Preferences.h"
#include "mozilla/Attributes.h"
#include "nsContentUtils.h"
#include "nsIPrincipal.h"
#include "nsXULAppAPI.h"
using namespace mozilla;
static const uint32_t kRescheduleLimit = 3;
// Max number of retries for every entry of pinned app.
static const uint32_t kPinnedEntryRetriesLimit = 3;
// Maximum number of parallel items loads
static const uint32_t kParallelLoadLimit = 15;
// Quota for offline apps when preloading
static const int32_t kCustomProfileQuota = 512000;
//
// To enable logging (see prlog.h for full details):
//
// set NSPR_LOG_MODULES=nsOfflineCacheUpdate:5
// set NSPR_LOG_FILE=offlineupdate.log
//
// this enables LogLevel::Debug level information and places all output in
// the file offlineupdate.log
//
extern PRLogModuleInfo *gOfflineCacheUpdateLog;
#undef LOG
#define LOG(args) MOZ_LOG(gOfflineCacheUpdateLog, mozilla::LogLevel::Debug, args)
#undef LOG_ENABLED
#define LOG_ENABLED() MOZ_LOG_TEST(gOfflineCacheUpdateLog, mozilla::LogLevel::Debug)
class AutoFreeArray {
public:
AutoFreeArray(uint32_t count, char **values)
: mCount(count), mValues(values) {};
~AutoFreeArray() { NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(mCount, mValues); }
private:
uint32_t mCount;
char **mValues;
};
namespace {
nsresult
DropReferenceFromURL(nsIURI * aURI)
{
// XXXdholbert If this SetRef fails, callers of this method probably
// want to call aURI->CloneIgnoringRef() and use the result of that.
return aURI->SetRef(EmptyCString());
}
void
LogToConsole(const char * message, nsOfflineCacheUpdateItem * item = nullptr)
{
nsCOMPtr<nsIConsoleService> consoleService =
do_GetService(NS_CONSOLESERVICE_CONTRACTID);
if (consoleService)
{
nsAutoString messageUTF16 = NS_ConvertUTF8toUTF16(message);
if (item && item->mURI) {
nsAutoCString uriSpec;
item->mURI->GetSpec(uriSpec);
messageUTF16.AppendLiteral(", URL=");
messageUTF16.Append(NS_ConvertUTF8toUTF16(uriSpec));
}
consoleService->LogStringMessage(messageUTF16.get());
}
}
} // namespace
//-----------------------------------------------------------------------------
// nsManifestCheck
//-----------------------------------------------------------------------------
class nsManifestCheck final : public nsIStreamListener
, public nsIChannelEventSink
, public nsIInterfaceRequestor
{
public:
nsManifestCheck(nsOfflineCacheUpdate *aUpdate,
nsIURI *aURI,
nsIURI *aReferrerURI,
nsIPrincipal* aLoadingPrincipal)
: mUpdate(aUpdate)
, mURI(aURI)
, mReferrerURI(aReferrerURI)
, mLoadingPrincipal(aLoadingPrincipal)
{}
NS_DECL_ISUPPORTS
NS_DECL_NSIREQUESTOBSERVER
NS_DECL_NSISTREAMLISTENER
NS_DECL_NSICHANNELEVENTSINK
NS_DECL_NSIINTERFACEREQUESTOR
nsresult Begin();
private:
~nsManifestCheck() {}
static NS_METHOD ReadManifest(nsIInputStream *aInputStream,
void *aClosure,
const char *aFromSegment,
uint32_t aOffset,
uint32_t aCount,
uint32_t *aBytesConsumed);
RefPtr<nsOfflineCacheUpdate> mUpdate;
nsCOMPtr<nsIURI> mURI;
nsCOMPtr<nsIURI> mReferrerURI;
nsCOMPtr<nsIPrincipal> mLoadingPrincipal;
nsCOMPtr<nsICryptoHash> mManifestHash;
nsCOMPtr<nsIChannel> mChannel;
};
//-----------------------------------------------------------------------------
// nsManifestCheck::nsISupports
//-----------------------------------------------------------------------------
NS_IMPL_ISUPPORTS(nsManifestCheck,
nsIRequestObserver,
nsIStreamListener,
nsIChannelEventSink,
nsIInterfaceRequestor)
//-----------------------------------------------------------------------------
// nsManifestCheck <public>
//-----------------------------------------------------------------------------
nsresult
nsManifestCheck::Begin()
{
nsresult rv;
mManifestHash = do_CreateInstance("@mozilla.org/security/hash;1", &rv);
NS_ENSURE_SUCCESS(rv, rv);
rv = mManifestHash->Init(nsICryptoHash::MD5);
NS_ENSURE_SUCCESS(rv, rv);
rv = NS_NewChannel(getter_AddRefs(mChannel),
mURI,
mLoadingPrincipal,
nsILoadInfo::SEC_REQUIRE_SAME_ORIGIN_DATA_IS_BLOCKED,
nsIContentPolicy::TYPE_OTHER,
nullptr, // loadGroup
nullptr, // aCallbacks
nsIRequest::LOAD_BYPASS_CACHE);
NS_ENSURE_SUCCESS(rv, rv);
// configure HTTP specific stuff
nsCOMPtr<nsIHttpChannel> httpChannel =
do_QueryInterface(mChannel);
if (httpChannel) {
httpChannel->SetReferrer(mReferrerURI);
httpChannel->SetRequestHeader(NS_LITERAL_CSTRING("X-Moz"),
NS_LITERAL_CSTRING("offline-resource"),
false);
}
return mChannel->AsyncOpen2(this);
}
//-----------------------------------------------------------------------------
// nsManifestCheck <public>
//-----------------------------------------------------------------------------
/* static */
NS_METHOD
nsManifestCheck::ReadManifest(nsIInputStream *aInputStream,
void *aClosure,
const char *aFromSegment,
uint32_t aOffset,
uint32_t aCount,
uint32_t *aBytesConsumed)
{
nsManifestCheck *manifestCheck =
static_cast<nsManifestCheck*>(aClosure);
nsresult rv;
*aBytesConsumed = aCount;
rv = manifestCheck->mManifestHash->Update(
reinterpret_cast<const uint8_t *>(aFromSegment), aCount);
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
//-----------------------------------------------------------------------------
// nsManifestCheck::nsIStreamListener
//-----------------------------------------------------------------------------
NS_IMETHODIMP
nsManifestCheck::OnStartRequest(nsIRequest *aRequest,
nsISupports *aContext)
{
return NS_OK;
}
NS_IMETHODIMP
nsManifestCheck::OnDataAvailable(nsIRequest *aRequest,
nsISupports *aContext,
nsIInputStream *aStream,
uint64_t aOffset,
uint32_t aCount)
{
uint32_t bytesRead;
aStream->ReadSegments(ReadManifest, this, aCount, &bytesRead);
return NS_OK;
}
NS_IMETHODIMP
nsManifestCheck::OnStopRequest(nsIRequest *aRequest,
nsISupports *aContext,
nsresult aStatus)
{
nsAutoCString manifestHash;
if (NS_SUCCEEDED(aStatus)) {
mManifestHash->Finish(true, manifestHash);
}
mUpdate->ManifestCheckCompleted(aStatus, manifestHash);
return NS_OK;
}
//-----------------------------------------------------------------------------
// nsManifestCheck::nsIInterfaceRequestor
//-----------------------------------------------------------------------------
NS_IMETHODIMP
nsManifestCheck::GetInterface(const nsIID &aIID, void **aResult)
{
if (aIID.Equals(NS_GET_IID(nsIChannelEventSink))) {
NS_ADDREF_THIS();
*aResult = static_cast<nsIChannelEventSink *>(this);
return NS_OK;
}
return NS_ERROR_NO_INTERFACE;
}
//-----------------------------------------------------------------------------
// nsManifestCheck::nsIChannelEventSink
//-----------------------------------------------------------------------------
NS_IMETHODIMP
nsManifestCheck::AsyncOnChannelRedirect(nsIChannel *aOldChannel,
nsIChannel *aNewChannel,
uint32_t aFlags,
nsIAsyncVerifyRedirectCallback *callback)
{
// Redirects should cause the load (and therefore the update) to fail.
if (aFlags & nsIChannelEventSink::REDIRECT_INTERNAL) {
callback->OnRedirectVerifyCallback(NS_OK);
return NS_OK;
}
LogToConsole("Manifest check failed because its response is a redirect");
aOldChannel->Cancel(NS_ERROR_ABORT);
return NS_ERROR_ABORT;
}
//-----------------------------------------------------------------------------
// nsOfflineCacheUpdateItem::nsISupports
//-----------------------------------------------------------------------------
NS_IMPL_ISUPPORTS(nsOfflineCacheUpdateItem,
nsIRequestObserver,
nsIStreamListener,
nsIRunnable,
nsIInterfaceRequestor,
nsIChannelEventSink)
//-----------------------------------------------------------------------------
// nsOfflineCacheUpdateItem <public>
//-----------------------------------------------------------------------------
nsOfflineCacheUpdateItem::nsOfflineCacheUpdateItem(nsIURI *aURI,
nsIURI *aReferrerURI,
nsIPrincipal* aLoadingPrincipal,
nsIApplicationCache *aApplicationCache,
nsIApplicationCache *aPreviousApplicationCache,
uint32_t type)
: mURI(aURI)
, mReferrerURI(aReferrerURI)
, mLoadingPrincipal(aLoadingPrincipal)
, mApplicationCache(aApplicationCache)
, mPreviousApplicationCache(aPreviousApplicationCache)
, mItemType(type)
, mChannel(nullptr)
, mState(LoadStatus::UNINITIALIZED)
, mBytesRead(0)
{
}
nsOfflineCacheUpdateItem::~nsOfflineCacheUpdateItem()
{
}
nsresult
nsOfflineCacheUpdateItem::OpenChannel(nsOfflineCacheUpdate *aUpdate)
{
if (LOG_ENABLED()) {
nsAutoCString spec;
mURI->GetSpec(spec);
LOG(("%p: Opening channel for %s", this, spec.get()));
}
if (mUpdate) {
// Holding a reference to the update means this item is already
// in progress (has a channel, or is just in between OnStopRequest()
// and its Run() call. We must never open channel on this item again.
LOG((" %p is already running! ignoring", this));
return NS_ERROR_ALREADY_OPENED;
}
nsresult rv = nsOfflineCacheUpdate::GetCacheKey(mURI, mCacheKey);
NS_ENSURE_SUCCESS(rv, rv);
uint32_t flags = nsIRequest::LOAD_BACKGROUND |
nsICachingChannel::LOAD_ONLY_IF_MODIFIED;
if (mApplicationCache == mPreviousApplicationCache) {
// Same app cache to read from and to write to is used during
// an only-update-check procedure. Here we protect the existing
// cache from being modified.
flags |= nsIRequest::INHIBIT_CACHING;
}
rv = NS_NewChannel(getter_AddRefs(mChannel),
mURI,
mLoadingPrincipal,
nsILoadInfo::SEC_ALLOW_CROSS_ORIGIN_DATA_IS_NULL,
nsIContentPolicy::TYPE_OTHER,
nullptr, // aLoadGroup
this, // aCallbacks
flags);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIApplicationCacheChannel> appCacheChannel =
do_QueryInterface(mChannel, &rv);
// Support for nsIApplicationCacheChannel is required.
NS_ENSURE_SUCCESS(rv, rv);
// Use the existing application cache as the cache to check.
rv = appCacheChannel->SetApplicationCache(mPreviousApplicationCache);
NS_ENSURE_SUCCESS(rv, rv);
// Set the new application cache as the target for write.
rv = appCacheChannel->SetApplicationCacheForWrite(mApplicationCache);
NS_ENSURE_SUCCESS(rv, rv);
// configure HTTP specific stuff
nsCOMPtr<nsIHttpChannel> httpChannel =
do_QueryInterface(mChannel);
if (httpChannel) {
httpChannel->SetReferrer(mReferrerURI);
httpChannel->SetRequestHeader(NS_LITERAL_CSTRING("X-Moz"),
NS_LITERAL_CSTRING("offline-resource"),
false);
}
rv = mChannel->AsyncOpen2(this);
NS_ENSURE_SUCCESS(rv, rv);
mUpdate = aUpdate;
mState = LoadStatus::REQUESTED;
return NS_OK;
}
nsresult
nsOfflineCacheUpdateItem::Cancel()
{
if (mChannel) {
mChannel->Cancel(NS_ERROR_ABORT);
mChannel = nullptr;
}
mState = LoadStatus::UNINITIALIZED;
return NS_OK;
}
//-----------------------------------------------------------------------------
// nsOfflineCacheUpdateItem::nsIStreamListener
//-----------------------------------------------------------------------------
NS_IMETHODIMP
nsOfflineCacheUpdateItem::OnStartRequest(nsIRequest *aRequest,
nsISupports *aContext)
{
mState = LoadStatus::RECEIVING;
return NS_OK;
}
NS_IMETHODIMP
nsOfflineCacheUpdateItem::OnDataAvailable(nsIRequest *aRequest,
nsISupports *aContext,
nsIInputStream *aStream,
uint64_t aOffset,
uint32_t aCount)
{
uint32_t bytesRead = 0;
aStream->ReadSegments(NS_DiscardSegment, nullptr, aCount, &bytesRead);
mBytesRead += bytesRead;
LOG(("loaded %u bytes into offline cache [offset=%llu]\n",
bytesRead, aOffset));
mUpdate->OnByteProgress(bytesRead);
return NS_OK;
}
NS_IMETHODIMP
nsOfflineCacheUpdateItem::OnStopRequest(nsIRequest *aRequest,
nsISupports *aContext,
nsresult aStatus)
{
if (LOG_ENABLED()) {
nsAutoCString spec;
mURI->GetSpec(spec);
LOG(("%p: Done fetching offline item %s [status=%x]\n",
this, spec.get(), aStatus));
}
if (mBytesRead == 0 && aStatus == NS_OK) {
// we didn't need to read (because LOAD_ONLY_IF_MODIFIED was
// specified), but the object should report loadedSize as if it
// did.
mChannel->GetContentLength(&mBytesRead);
mUpdate->OnByteProgress(mBytesRead);
}
if (NS_FAILED(aStatus)) {
nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(mChannel);
if (httpChannel) {
bool isNoStore;
if (NS_SUCCEEDED(httpChannel->IsNoStoreResponse(&isNoStore))
&& isNoStore) {
LogToConsole("Offline cache manifest item has Cache-control: no-store header",
this);
}
}
}
// We need to notify the update that the load is complete, but we
// want to give the channel a chance to close the cache entries.
NS_DispatchToCurrentThread(this);
return NS_OK;
}
//-----------------------------------------------------------------------------
// nsOfflineCacheUpdateItem::nsIRunnable
//-----------------------------------------------------------------------------
NS_IMETHODIMP
nsOfflineCacheUpdateItem::Run()
{
// Set mState to LOADED here rather than in OnStopRequest to prevent
// race condition when checking state of all mItems in ProcessNextURI().
// If state would have been set in OnStopRequest we could mistakenly
// take this item as already finished and finish the update process too
// early when ProcessNextURI() would get called between OnStopRequest()
// and Run() of this item. Finish() would then have been called twice.
mState = LoadStatus::LOADED;
RefPtr<nsOfflineCacheUpdate> update;
update.swap(mUpdate);
update->LoadCompleted(this);
return NS_OK;
}
//-----------------------------------------------------------------------------
// nsOfflineCacheUpdateItem::nsIInterfaceRequestor
//-----------------------------------------------------------------------------
NS_IMETHODIMP
nsOfflineCacheUpdateItem::GetInterface(const nsIID &aIID, void **aResult)
{
if (aIID.Equals(NS_GET_IID(nsIChannelEventSink))) {
NS_ADDREF_THIS();
*aResult = static_cast<nsIChannelEventSink *>(this);
return NS_OK;
}
return NS_ERROR_NO_INTERFACE;
}
//-----------------------------------------------------------------------------
// nsOfflineCacheUpdateItem::nsIChannelEventSink
//-----------------------------------------------------------------------------
NS_IMETHODIMP
nsOfflineCacheUpdateItem::AsyncOnChannelRedirect(nsIChannel *aOldChannel,
nsIChannel *aNewChannel,
uint32_t aFlags,
nsIAsyncVerifyRedirectCallback *cb)
{
if (!(aFlags & nsIChannelEventSink::REDIRECT_INTERNAL)) {
// Don't allow redirect in case of non-internal redirect and cancel
// the channel to clean the cache entry.
LogToConsole("Offline cache manifest failed because an item redirects", this);
aOldChannel->Cancel(NS_ERROR_ABORT);
return NS_ERROR_ABORT;
}
nsCOMPtr<nsIURI> newURI;
nsresult rv = aNewChannel->GetURI(getter_AddRefs(newURI));
if (NS_FAILED(rv))
return rv;
nsCOMPtr<nsIApplicationCacheChannel> appCacheChannel =
do_QueryInterface(aNewChannel);
if (appCacheChannel) {
rv = appCacheChannel->SetApplicationCacheForWrite(mApplicationCache);
NS_ENSURE_SUCCESS(rv, rv);
}
nsAutoCString oldScheme;
mURI->GetScheme(oldScheme);
bool match;
if (NS_FAILED(newURI->SchemeIs(oldScheme.get(), &match)) || !match) {
LOG(("rejected: redirected to a different scheme\n"));
return NS_ERROR_ABORT;
}
// HTTP request headers are not automatically forwarded to the new channel.
nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(aNewChannel);
NS_ENSURE_STATE(httpChannel);
httpChannel->SetRequestHeader(NS_LITERAL_CSTRING("X-Moz"),
NS_LITERAL_CSTRING("offline-resource"),
false);
mChannel = aNewChannel;
cb->OnRedirectVerifyCallback(NS_OK);
return NS_OK;
}
nsresult
nsOfflineCacheUpdateItem::GetRequestSucceeded(bool * succeeded)
{
*succeeded = false;
if (!mChannel)
return NS_OK;
nsresult rv;
nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(mChannel, &rv);
NS_ENSURE_SUCCESS(rv, rv);
bool reqSucceeded;
rv = httpChannel->GetRequestSucceeded(&reqSucceeded);
if (NS_ERROR_NOT_AVAILABLE == rv)
return NS_OK;
NS_ENSURE_SUCCESS(rv, rv);
if (!reqSucceeded) {
LOG(("Request failed"));
return NS_OK;
}
nsresult channelStatus;
rv = httpChannel->GetStatus(&channelStatus);
NS_ENSURE_SUCCESS(rv, rv);
if (NS_FAILED(channelStatus)) {
LOG(("Channel status=0x%08x", channelStatus));
return NS_OK;
}
*succeeded = true;
return NS_OK;
}
bool
nsOfflineCacheUpdateItem::IsScheduled()
{
return mState == LoadStatus::UNINITIALIZED;
}
bool
nsOfflineCacheUpdateItem::IsInProgress()
{
return mState == LoadStatus::REQUESTED ||
mState == LoadStatus::RECEIVING;
}
bool
nsOfflineCacheUpdateItem::IsCompleted()
{
return mState == LoadStatus::LOADED;
}
nsresult
nsOfflineCacheUpdateItem::GetStatus(uint16_t *aStatus)
{
if (!mChannel) {
*aStatus = 0;
return NS_OK;
}
nsresult rv;
nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(mChannel, &rv);
NS_ENSURE_SUCCESS(rv, rv);
uint32_t httpStatus;
rv = httpChannel->GetResponseStatus(&httpStatus);
if (rv == NS_ERROR_NOT_AVAILABLE) {
*aStatus = 0;
return NS_OK;
}
NS_ENSURE_SUCCESS(rv, rv);
*aStatus = uint16_t(httpStatus);
return NS_OK;
}
//-----------------------------------------------------------------------------
// nsOfflineManifestItem
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// nsOfflineManifestItem <public>
//-----------------------------------------------------------------------------
nsOfflineManifestItem::nsOfflineManifestItem(nsIURI *aURI,
nsIURI *aReferrerURI,
nsIPrincipal* aLoadingPrincipal,
nsIApplicationCache *aApplicationCache,
nsIApplicationCache *aPreviousApplicationCache)
: nsOfflineCacheUpdateItem(aURI, aReferrerURI, aLoadingPrincipal,
aApplicationCache, aPreviousApplicationCache,
nsIApplicationCache::ITEM_MANIFEST)
, mParserState(PARSE_INIT)
, mNeedsUpdate(true)
, mStrictFileOriginPolicy(false)
, mManifestHashInitialized(false)
{
ReadStrictFileOriginPolicyPref();
}
nsOfflineManifestItem::~nsOfflineManifestItem()
{
}
//-----------------------------------------------------------------------------
// nsOfflineManifestItem <private>
//-----------------------------------------------------------------------------
/* static */
NS_METHOD
nsOfflineManifestItem::ReadManifest(nsIInputStream *aInputStream,
void *aClosure,
const char *aFromSegment,
uint32_t aOffset,
uint32_t aCount,
uint32_t *aBytesConsumed)
{
nsOfflineManifestItem *manifest =
static_cast<nsOfflineManifestItem*>(aClosure);
nsresult rv;
*aBytesConsumed = aCount;
if (manifest->mParserState == PARSE_ERROR) {
// parse already failed, ignore this
return NS_OK;
}
if (!manifest->mManifestHashInitialized) {
// Avoid re-creation of crypto hash when it fails from some reason the first time
manifest->mManifestHashInitialized = true;
manifest->mManifestHash = do_CreateInstance("@mozilla.org/security/hash;1", &rv);
if (NS_SUCCEEDED(rv)) {
rv = manifest->mManifestHash->Init(nsICryptoHash::MD5);
if (NS_FAILED(rv)) {
manifest->mManifestHash = nullptr;
LOG(("Could not initialize manifest hash for byte-to-byte check, rv=%08x", rv));
}
}
}
if (manifest->mManifestHash) {
rv = manifest->mManifestHash->Update(reinterpret_cast<const uint8_t *>(aFromSegment), aCount);
if (NS_FAILED(rv)) {
manifest->mManifestHash = nullptr;
LOG(("Could not update manifest hash, rv=%08x", rv));
}
}
manifest->mReadBuf.Append(aFromSegment, aCount);
nsCString::const_iterator begin, iter, end;
manifest->mReadBuf.BeginReading(begin);
manifest->mReadBuf.EndReading(end);
for (iter = begin; iter != end; iter++) {
if (*iter == '\r' || *iter == '\n') {
rv = manifest->HandleManifestLine(begin, iter);
if (NS_FAILED(rv)) {
LOG(("HandleManifestLine failed with 0x%08x", rv));
*aBytesConsumed = 0; // Avoid assertion failure in stream tee
return NS_ERROR_ABORT;
}
begin = iter;
begin++;
}
}
// any leftovers are saved for next time
manifest->mReadBuf = Substring(begin, end);
return NS_OK;
}
nsresult
nsOfflineManifestItem::AddNamespace(uint32_t namespaceType,
const nsCString &namespaceSpec,
const nsCString &data)
{
nsresult rv;
if (!mNamespaces) {
mNamespaces = do_CreateInstance(NS_ARRAY_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
}
nsCOMPtr<nsIApplicationCacheNamespace> ns =
do_CreateInstance(NS_APPLICATIONCACHENAMESPACE_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
rv = ns->Init(namespaceType, namespaceSpec, data);
NS_ENSURE_SUCCESS(rv, rv);
rv = mNamespaces->AppendElement(ns, false);
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
nsresult
nsOfflineManifestItem::HandleManifestLine(const nsCString::const_iterator &aBegin,
const nsCString::const_iterator &aEnd)
{
nsCString::const_iterator begin = aBegin;
nsCString::const_iterator end = aEnd;
// all lines ignore trailing spaces and tabs
nsCString::const_iterator last = end;
--last;
while (end != begin && (*last == ' ' || *last == '\t')) {
--end;
--last;
}
if (mParserState == PARSE_INIT) {
// Allow a UTF-8 BOM
if (begin != end && static_cast<unsigned char>(*begin) == 0xef) {
if (++begin == end || static_cast<unsigned char>(*begin) != 0xbb ||
++begin == end || static_cast<unsigned char>(*begin) != 0xbf) {
mParserState = PARSE_ERROR;
LogToConsole("Offline cache manifest BOM error", this);
return NS_OK;
}
++begin;
}
const nsCSubstring &magic = Substring(begin, end);
if (!magic.EqualsLiteral("CACHE MANIFEST")) {
mParserState = PARSE_ERROR;
LogToConsole("Offline cache manifest magic incorrect", this);
return NS_OK;
}
mParserState = PARSE_CACHE_ENTRIES;
return NS_OK;
}
// lines other than the first ignore leading spaces and tabs
while (begin != end && (*begin == ' ' || *begin == '\t'))
begin++;
// ignore blank lines and comments
if (begin == end || *begin == '#')
return NS_OK;
const nsCSubstring &line = Substring(begin, end);
if (line.EqualsLiteral("CACHE:")) {
mParserState = PARSE_CACHE_ENTRIES;
return NS_OK;
}
if (line.EqualsLiteral("FALLBACK:")) {
mParserState = PARSE_FALLBACK_ENTRIES;
return NS_OK;
}
if (line.EqualsLiteral("NETWORK:")) {
mParserState = PARSE_BYPASS_ENTRIES;
return NS_OK;
}
// Every other section type we don't know must be silently ignored.
nsCString::const_iterator lastChar = end;
if (*(--lastChar) == ':') {
mParserState = PARSE_UNKNOWN_SECTION;
return NS_OK;
}
nsresult rv;
switch(mParserState) {
case PARSE_INIT:
case PARSE_ERROR: {
// this should have been dealt with earlier
return NS_ERROR_FAILURE;
}
case PARSE_UNKNOWN_SECTION: {
// just jump over
return NS_OK;
}
case PARSE_CACHE_ENTRIES: {
nsCOMPtr<nsIURI> uri;
rv = NS_NewURI(getter_AddRefs(uri), line, nullptr, mURI);
if (NS_FAILED(rv))
break;
if (NS_FAILED(DropReferenceFromURL(uri)))
break;
nsAutoCString scheme;
uri->GetScheme(scheme);
// Manifest URIs must have the same scheme as the manifest.
bool match;
if (NS_FAILED(mURI->SchemeIs(scheme.get(), &match)) || !match)
break;
mExplicitURIs.AppendObject(uri);
break;
}
case PARSE_FALLBACK_ENTRIES: {
int32_t separator = line.FindChar(' ');
if (separator == kNotFound) {
separator = line.FindChar('\t');
if (separator == kNotFound)
break;
}
nsCString namespaceSpec(Substring(line, 0, separator));
nsCString fallbackSpec(Substring(line, separator + 1));
namespaceSpec.CompressWhitespace();
fallbackSpec.CompressWhitespace();
nsCOMPtr<nsIURI> namespaceURI;
rv = NS_NewURI(getter_AddRefs(namespaceURI), namespaceSpec, nullptr, mURI);
if (NS_FAILED(rv))
break;
if (NS_FAILED(DropReferenceFromURL(namespaceURI)))
break;
rv = namespaceURI->GetAsciiSpec(namespaceSpec);
if (NS_FAILED(rv))
break;
nsCOMPtr<nsIURI> fallbackURI;
rv = NS_NewURI(getter_AddRefs(fallbackURI), fallbackSpec, nullptr, mURI);
if (NS_FAILED(rv))
break;
if (NS_FAILED(DropReferenceFromURL(fallbackURI)))
break;
rv = fallbackURI->GetAsciiSpec(fallbackSpec);
if (NS_FAILED(rv))
break;
// Manifest and namespace must be same origin
if (!NS_SecurityCompareURIs(mURI, namespaceURI,
mStrictFileOriginPolicy))
break;
// Fallback and namespace must be same origin
if (!NS_SecurityCompareURIs(namespaceURI, fallbackURI,
mStrictFileOriginPolicy))
break;
mFallbackURIs.AppendObject(fallbackURI);
AddNamespace(nsIApplicationCacheNamespace::NAMESPACE_FALLBACK,
namespaceSpec, fallbackSpec);
break;
}
case PARSE_BYPASS_ENTRIES: {
if (line[0] == '*' && (line.Length() == 1 || line[1] == ' ' || line[1] == '\t'))
{
// '*' indicates to make the online whitelist wildcard flag open,
// i.e. do allow load of resources not present in the offline cache
// or not conforming any namespace.
// We achive that simply by adding an 'empty' - i.e. universal
// namespace of BYPASS type into the cache.
AddNamespace(nsIApplicationCacheNamespace::NAMESPACE_BYPASS,
EmptyCString(), EmptyCString());
break;
}
nsCOMPtr<nsIURI> bypassURI;
rv = NS_NewURI(getter_AddRefs(bypassURI), line, nullptr, mURI);
if (NS_FAILED(rv))
break;
nsAutoCString scheme;
bypassURI->GetScheme(scheme);
bool equals;
if (NS_FAILED(mURI->SchemeIs(scheme.get(), &equals)) || !equals)
break;
if (NS_FAILED(DropReferenceFromURL(bypassURI)))
break;
nsCString spec;
if (NS_FAILED(bypassURI->GetAsciiSpec(spec)))
break;
AddNamespace(nsIApplicationCacheNamespace::NAMESPACE_BYPASS,
spec, EmptyCString());
break;
}
}
return NS_OK;
}
nsresult
nsOfflineManifestItem::GetOldManifestContentHash(nsIRequest *aRequest)
{
nsresult rv;
nsCOMPtr<nsICachingChannel> cachingChannel = do_QueryInterface(aRequest, &rv);
NS_ENSURE_SUCCESS(rv, rv);
// load the main cache token that is actually the old offline cache token and
// read previous manifest content hash value
nsCOMPtr<nsISupports> cacheToken;
cachingChannel->GetCacheToken(getter_AddRefs(cacheToken));
if (cacheToken) {
nsCOMPtr<nsICacheEntry> cacheDescriptor(do_QueryInterface(cacheToken, &rv));
NS_ENSURE_SUCCESS(rv, rv);
rv = cacheDescriptor->GetMetaDataElement("offline-manifest-hash", getter_Copies(mOldManifestHashValue));
if (NS_FAILED(rv))
mOldManifestHashValue.Truncate();
}
return NS_OK;
}
nsresult
nsOfflineManifestItem::CheckNewManifestContentHash(nsIRequest *aRequest)
{
nsresult rv;
if (!mManifestHash) {
// Nothing to compare against...
return NS_OK;
}
nsCString newManifestHashValue;
rv = mManifestHash->Finish(true, mManifestHashValue);
mManifestHash = nullptr;
if (NS_FAILED(rv)) {
LOG(("Could not finish manifest hash, rv=%08x", rv));
// This is not critical error
return NS_OK;
}
if (!ParseSucceeded()) {
// Parsing failed, the hash is not valid
return NS_OK;
}
if (mOldManifestHashValue == mManifestHashValue) {
LOG(("Update not needed, downloaded manifest content is byte-for-byte identical"));
mNeedsUpdate = false;
}
// Store the manifest content hash value to the new
// offline cache token
nsCOMPtr<nsICachingChannel> cachingChannel = do_QueryInterface(aRequest, &rv);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsISupports> cacheToken;
cachingChannel->GetOfflineCacheToken(getter_AddRefs(cacheToken));
if (cacheToken) {
nsCOMPtr<nsICacheEntry> cacheDescriptor(do_QueryInterface(cacheToken, &rv));
NS_ENSURE_SUCCESS(rv, rv);
rv = cacheDescriptor->SetMetaDataElement("offline-manifest-hash", mManifestHashValue.get());
NS_ENSURE_SUCCESS(rv, rv);
}
return NS_OK;
}
void
nsOfflineManifestItem::ReadStrictFileOriginPolicyPref()
{
mStrictFileOriginPolicy =
Preferences::GetBool("security.fileuri.strict_origin_policy", true);
}
NS_IMETHODIMP
nsOfflineManifestItem::OnStartRequest(nsIRequest *aRequest,
nsISupports *aContext)
{
nsresult rv;
nsCOMPtr<nsIHttpChannel> channel = do_QueryInterface(aRequest, &rv);
NS_ENSURE_SUCCESS(rv, rv);
bool succeeded;
rv = channel->GetRequestSucceeded(&succeeded);
NS_ENSURE_SUCCESS(rv, rv);
if (!succeeded) {
LOG(("HTTP request failed"));
LogToConsole("Offline cache manifest HTTP request failed", this);
mParserState = PARSE_ERROR;
return NS_ERROR_ABORT;
}
rv = GetOldManifestContentHash(aRequest);
NS_ENSURE_SUCCESS(rv, rv);
return nsOfflineCacheUpdateItem::OnStartRequest(aRequest, aContext);
}
NS_IMETHODIMP
nsOfflineManifestItem::OnDataAvailable(nsIRequest *aRequest,
nsISupports *aContext,
nsIInputStream *aStream,
uint64_t aOffset,
uint32_t aCount)
{
uint32_t bytesRead = 0;
aStream->ReadSegments(ReadManifest, this, aCount, &bytesRead);
mBytesRead += bytesRead;
if (mParserState == PARSE_ERROR) {
LOG(("OnDataAvailable is canceling the request due a parse error\n"));
return NS_ERROR_ABORT;
}
LOG(("loaded %u bytes into offline cache [offset=%u]\n",
bytesRead, aOffset));
// All the parent method does is read and discard, don't bother
// chaining up.
return NS_OK;
}
NS_IMETHODIMP
nsOfflineManifestItem::OnStopRequest(nsIRequest *aRequest,
nsISupports *aContext,
nsresult aStatus)
{
if (mBytesRead == 0) {
// We didn't need to read (because LOAD_ONLY_IF_MODIFIED was
// specified).
mNeedsUpdate = false;
} else {
// Handle any leftover manifest data.
nsCString::const_iterator begin, end;
mReadBuf.BeginReading(begin);
mReadBuf.EndReading(end);
nsresult rv = HandleManifestLine(begin, end);
NS_ENSURE_SUCCESS(rv, rv);
rv = CheckNewManifestContentHash(aRequest);
NS_ENSURE_SUCCESS(rv, rv);
}
return nsOfflineCacheUpdateItem::OnStopRequest(aRequest, aContext, aStatus);
}
//-----------------------------------------------------------------------------
// nsOfflineCacheUpdate::nsISupports
//-----------------------------------------------------------------------------
NS_IMPL_ISUPPORTS(nsOfflineCacheUpdate,
nsIOfflineCacheUpdateObserver,
nsIOfflineCacheUpdate,
nsIRunnable)
//-----------------------------------------------------------------------------
// nsOfflineCacheUpdate <public>
//-----------------------------------------------------------------------------
nsOfflineCacheUpdate::nsOfflineCacheUpdate()
: mState(STATE_UNINITIALIZED)
, mAddedItems(false)
, mPartialUpdate(false)
, mOnlyCheckUpdate(false)
, mSucceeded(true)
, mObsolete(false)
, mItemsInProgress(0)
, mRescheduleCount(0)
, mPinnedEntryRetriesCount(0)
, mPinned(false)
, mByteProgress(0)
{
}
nsOfflineCacheUpdate::~nsOfflineCacheUpdate()
{
LOG(("nsOfflineCacheUpdate::~nsOfflineCacheUpdate [%p]", this));
}
/* static */
nsresult
nsOfflineCacheUpdate::GetCacheKey(nsIURI *aURI, nsACString &aKey)
{
aKey.Truncate();
nsCOMPtr<nsIURI> newURI;
nsresult rv = aURI->CloneIgnoringRef(getter_AddRefs(newURI));
NS_ENSURE_SUCCESS(rv, rv);
rv = newURI->GetAsciiSpec(aKey);
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
nsresult
nsOfflineCacheUpdate::InitInternal(nsIURI *aManifestURI,
nsIPrincipal* aLoadingPrincipal)
{
nsresult rv;
// Only http and https applications are supported.
bool match;
rv = aManifestURI->SchemeIs("http", &match);
NS_ENSURE_SUCCESS(rv, rv);
if (!match) {
rv = aManifestURI->SchemeIs("https", &match);
NS_ENSURE_SUCCESS(rv, rv);
if (!match)
return NS_ERROR_ABORT;
}
mManifestURI = aManifestURI;
mLoadingPrincipal = aLoadingPrincipal;
rv = mManifestURI->GetAsciiHost(mUpdateDomain);
NS_ENSURE_SUCCESS(rv, rv);
mPartialUpdate = false;
return NS_OK;
}
nsresult
nsOfflineCacheUpdate::Init(nsIURI *aManifestURI,
nsIURI *aDocumentURI,
nsIPrincipal* aLoadingPrincipal,
nsIDOMDocument *aDocument,
nsIFile *aCustomProfileDir)
{
nsresult rv;
// Make sure the service has been initialized
nsOfflineCacheUpdateService* service =
nsOfflineCacheUpdateService::EnsureService();
if (!service)
return NS_ERROR_FAILURE;
LOG(("nsOfflineCacheUpdate::Init [%p]", this));
rv = InitInternal(aManifestURI, aLoadingPrincipal);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIApplicationCacheService> cacheService =
do_GetService(NS_APPLICATIONCACHESERVICE_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
nsAutoCString originSuffix;
rv = aLoadingPrincipal->GetOriginSuffix(originSuffix);
NS_ENSURE_SUCCESS(rv, rv);
mDocumentURI = aDocumentURI;
if (aCustomProfileDir) {
rv = cacheService->BuildGroupIDForSuffix(aManifestURI, originSuffix, mGroupID);
NS_ENSURE_SUCCESS(rv, rv);
// Create only a new offline application cache in the custom profile
// This is a preload of a new cache.
// XXX Custom updates don't support "updating" of an existing cache
// in the custom profile at the moment. This support can be, though,
// simply added as well when needed.
mPreviousApplicationCache = nullptr;
rv = cacheService->CreateCustomApplicationCache(mGroupID,
aCustomProfileDir,
kCustomProfileQuota,
getter_AddRefs(mApplicationCache));
NS_ENSURE_SUCCESS(rv, rv);
mCustomProfileDir = aCustomProfileDir;
}
else {
rv = cacheService->BuildGroupIDForSuffix(aManifestURI, originSuffix, mGroupID);
NS_ENSURE_SUCCESS(rv, rv);
rv = cacheService->GetActiveCache(mGroupID,
getter_AddRefs(mPreviousApplicationCache));
NS_ENSURE_SUCCESS(rv, rv);
rv = cacheService->CreateApplicationCache(mGroupID,
getter_AddRefs(mApplicationCache));
NS_ENSURE_SUCCESS(rv, rv);
}
rv = nsOfflineCacheUpdateService::OfflineAppPinnedForURI(aDocumentURI,
nullptr,
&mPinned);
NS_ENSURE_SUCCESS(rv, rv);
mState = STATE_INITIALIZED;
return NS_OK;
}
nsresult
nsOfflineCacheUpdate::InitForUpdateCheck(nsIURI *aManifestURI,
nsIPrincipal* aLoadingPrincipal,
nsIObserver *aObserver)
{
nsresult rv;
// Make sure the service has been initialized
nsOfflineCacheUpdateService* service =
nsOfflineCacheUpdateService::EnsureService();
if (!service)
return NS_ERROR_FAILURE;
LOG(("nsOfflineCacheUpdate::InitForUpdateCheck [%p]", this));
rv = InitInternal(aManifestURI, aLoadingPrincipal);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIApplicationCacheService> cacheService =
do_GetService(NS_APPLICATIONCACHESERVICE_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
nsAutoCString originSuffix;
rv = aLoadingPrincipal->GetOriginSuffix(originSuffix);
NS_ENSURE_SUCCESS(rv, rv);
rv = cacheService->BuildGroupIDForSuffix(aManifestURI, originSuffix, mGroupID);
NS_ENSURE_SUCCESS(rv, rv);
rv = cacheService->GetActiveCache(mGroupID,
getter_AddRefs(mPreviousApplicationCache));
NS_ENSURE_SUCCESS(rv, rv);
// To load the manifest properly using current app cache to satisfy and
// also to compare the cached content hash value we have to set 'some'
// app cache to write to on the channel. Otherwise the cached version will
// be used and no actual network request will be made. We use the same
// app cache here. OpenChannel prevents caching in this case using
// INHIBIT_CACHING load flag.
mApplicationCache = mPreviousApplicationCache;
rv = nsOfflineCacheUpdateService::OfflineAppPinnedForURI(aManifestURI,
nullptr,
&mPinned);
NS_ENSURE_SUCCESS(rv, rv);
mUpdateAvailableObserver = aObserver;
mOnlyCheckUpdate = true;
mState = STATE_INITIALIZED;
return NS_OK;
}
nsresult
nsOfflineCacheUpdate::InitPartial(nsIURI *aManifestURI,
const nsACString& clientID,
nsIURI *aDocumentURI,
nsIPrincipal *aLoadingPrincipal)
{
nsresult rv;
// Make sure the service has been initialized
nsOfflineCacheUpdateService* service =
nsOfflineCacheUpdateService::EnsureService();
if (!service)
return NS_ERROR_FAILURE;
LOG(("nsOfflineCacheUpdate::InitPartial [%p]", this));
mPartialUpdate = true;
mDocumentURI = aDocumentURI;
mLoadingPrincipal = aLoadingPrincipal;
mManifestURI = aManifestURI;
rv = mManifestURI->GetAsciiHost(mUpdateDomain);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIApplicationCacheService> cacheService =
do_GetService(NS_APPLICATIONCACHESERVICE_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
rv = cacheService->GetApplicationCache(clientID,
getter_AddRefs(mApplicationCache));
NS_ENSURE_SUCCESS(rv, rv);
if (!mApplicationCache) {
nsAutoCString manifestSpec;
rv = GetCacheKey(mManifestURI, manifestSpec);
NS_ENSURE_SUCCESS(rv, rv);
rv = cacheService->CreateApplicationCache
(manifestSpec, getter_AddRefs(mApplicationCache));
NS_ENSURE_SUCCESS(rv, rv);
}
rv = mApplicationCache->GetManifestURI(getter_AddRefs(mManifestURI));
NS_ENSURE_SUCCESS(rv, rv);
nsAutoCString groupID;
rv = mApplicationCache->GetGroupID(groupID);
NS_ENSURE_SUCCESS(rv, rv);
rv = nsOfflineCacheUpdateService::OfflineAppPinnedForURI(aDocumentURI,
nullptr,
&mPinned);
NS_ENSURE_SUCCESS(rv, rv);
mState = STATE_INITIALIZED;
return NS_OK;
}
nsresult
nsOfflineCacheUpdate::HandleManifest(bool *aDoUpdate)
{
// Be pessimistic
*aDoUpdate = false;
bool succeeded;
nsresult rv = mManifestItem->GetRequestSucceeded(&succeeded);
NS_ENSURE_SUCCESS(rv, rv);
if (!succeeded || !mManifestItem->ParseSucceeded()) {
return NS_ERROR_FAILURE;
}
if (!mManifestItem->NeedsUpdate()) {
return NS_OK;
}
// Add items requested by the manifest.
const nsCOMArray<nsIURI> &manifestURIs = mManifestItem->GetExplicitURIs();
for (int32_t i = 0; i < manifestURIs.Count(); i++) {
rv = AddURI(manifestURIs[i], nsIApplicationCache::ITEM_EXPLICIT);
NS_ENSURE_SUCCESS(rv, rv);
}
const nsCOMArray<nsIURI> &fallbackURIs = mManifestItem->GetFallbackURIs();
for (int32_t i = 0; i < fallbackURIs.Count(); i++) {
rv = AddURI(fallbackURIs[i], nsIApplicationCache::ITEM_FALLBACK);
NS_ENSURE_SUCCESS(rv, rv);
}
// The document that requested the manifest is implicitly included
// as part of that manifest update.
rv = AddURI(mDocumentURI, nsIApplicationCache::ITEM_IMPLICIT);
NS_ENSURE_SUCCESS(rv, rv);
// Add items previously cached implicitly
rv = AddExistingItems(nsIApplicationCache::ITEM_IMPLICIT);
NS_ENSURE_SUCCESS(rv, rv);
// Add items requested by the script API
rv = AddExistingItems(nsIApplicationCache::ITEM_DYNAMIC);
NS_ENSURE_SUCCESS(rv, rv);
// Add opportunistically cached items conforming current opportunistic
// namespace list
rv = AddExistingItems(nsIApplicationCache::ITEM_OPPORTUNISTIC,
&mManifestItem->GetOpportunisticNamespaces());
NS_ENSURE_SUCCESS(rv, rv);
*aDoUpdate = true;
return NS_OK;
}
bool
nsOfflineCacheUpdate::CheckUpdateAvailability()
{
nsresult rv;
bool succeeded;
rv = mManifestItem->GetRequestSucceeded(&succeeded);
NS_ENSURE_SUCCESS(rv, false);
if (!succeeded || !mManifestItem->ParseSucceeded()) {
return false;
}
if (!mPinned) {
uint16_t status;
rv = mManifestItem->GetStatus(&status);
NS_ENSURE_SUCCESS(rv, false);
// Treat these as there would be an update available,
// since this is indication of demand to remove this
// offline cache.
if (status == 404 || status == 410) {
return true;
}
}
return mManifestItem->NeedsUpdate();
}
void
nsOfflineCacheUpdate::LoadCompleted(nsOfflineCacheUpdateItem *aItem)
{
nsresult rv;
LOG(("nsOfflineCacheUpdate::LoadCompleted [%p]", this));
if (mState == STATE_FINISHED) {
LOG((" after completion, ignoring"));
return;
}
// Keep the object alive through a Finish() call.
nsCOMPtr<nsIOfflineCacheUpdate> kungFuDeathGrip(this);
if (mState == STATE_CANCELLED) {
NotifyState(nsIOfflineCacheUpdateObserver::STATE_ERROR);
Finish();
return;
}
if (mState == STATE_CHECKING) {
// Manifest load finished.
if (mOnlyCheckUpdate) {
Finish();
NotifyUpdateAvailability(CheckUpdateAvailability());
return;
}
NS_ASSERTION(mManifestItem,
"Must have a manifest item in STATE_CHECKING.");
NS_ASSERTION(mManifestItem == aItem,
"Unexpected aItem in nsOfflineCacheUpdate::LoadCompleted");
// A 404 or 410 is interpreted as an intentional removal of
// the manifest file, rather than a transient server error.
// Obsolete this cache group if one of these is returned.
uint16_t status;
rv = mManifestItem->GetStatus(&status);
if (status == 404 || status == 410) {
LogToConsole("Offline cache manifest removed, cache cleared", mManifestItem);
mSucceeded = false;
if (mPreviousApplicationCache) {
if (mPinned) {
// Do not obsolete a pinned application.
NotifyState(nsIOfflineCacheUpdateObserver::STATE_NOUPDATE);
} else {
NotifyState(nsIOfflineCacheUpdateObserver::STATE_OBSOLETE);
mObsolete = true;
}
} else {
NotifyState(nsIOfflineCacheUpdateObserver::STATE_ERROR);
mObsolete = true;
}
Finish();
return;
}
bool doUpdate;
if (NS_FAILED(HandleManifest(&doUpdate))) {
mSucceeded = false;
NotifyState(nsIOfflineCacheUpdateObserver::STATE_ERROR);
Finish();
return;
}
if (!doUpdate) {
LogToConsole("Offline cache doesn't need to update", mManifestItem);
mSucceeded = false;
AssociateDocuments(mPreviousApplicationCache);
ScheduleImplicit();
// If we didn't need an implicit update, we can
// send noupdate and end the update now.
if (!mImplicitUpdate) {
NotifyState(nsIOfflineCacheUpdateObserver::STATE_NOUPDATE);
Finish();
}
return;
}
rv = mApplicationCache->MarkEntry(mManifestItem->mCacheKey,
mManifestItem->mItemType);
if (NS_FAILED(rv)) {
mSucceeded = false;
NotifyState(nsIOfflineCacheUpdateObserver::STATE_ERROR);
Finish();
return;
}
mState = STATE_DOWNLOADING;
NotifyState(nsIOfflineCacheUpdateObserver::STATE_DOWNLOADING);
// Start fetching resources.
ProcessNextURI();
return;
}
// Normal load finished.
if (mItemsInProgress) // Just to be safe here!
--mItemsInProgress;
bool succeeded;
rv = aItem->GetRequestSucceeded(&succeeded);
if (mPinned && NS_SUCCEEDED(rv) && succeeded) {
uint32_t dummy_cache_type;
rv = mApplicationCache->GetTypes(aItem->mCacheKey, &dummy_cache_type);
bool item_doomed = NS_FAILED(rv); // can not find it? -> doomed
if (item_doomed &&
mPinnedEntryRetriesCount < kPinnedEntryRetriesLimit &&
(aItem->mItemType & (nsIApplicationCache::ITEM_EXPLICIT |
nsIApplicationCache::ITEM_FALLBACK))) {
rv = EvictOneNonPinned();
if (NS_FAILED(rv)) {
mSucceeded = false;
NotifyState(nsIOfflineCacheUpdateObserver::STATE_ERROR);
Finish();
return;
}
// This reverts the item state to UNINITIALIZED that makes it to
// be scheduled for download again.
rv = aItem->Cancel();
if (NS_FAILED(rv)) {
mSucceeded = false;
NotifyState(nsIOfflineCacheUpdateObserver::STATE_ERROR);
Finish();
return;
}
mPinnedEntryRetriesCount++;
LogToConsole("An unpinned offline cache deleted");
// Retry this item.
ProcessNextURI();
return;
}
}
// According to parallelism this may imply more pinned retries count,
// but that is not critical, since at one moment the algoritm will
// stop anyway. Also, this code may soon be completely removed
// after we have a separate storage for pinned apps.
mPinnedEntryRetriesCount = 0;
// Check for failures. 3XX, 4XX and 5XX errors on items explicitly
// listed in the manifest will cause the update to fail.
if (NS_FAILED(rv) || !succeeded) {
if (aItem->mItemType &
(nsIApplicationCache::ITEM_EXPLICIT |
nsIApplicationCache::ITEM_FALLBACK)) {
LogToConsole("Offline cache manifest item failed to load", aItem);
mSucceeded = false;
}
} else {
rv = mApplicationCache->MarkEntry(aItem->mCacheKey, aItem->mItemType);
if (NS_FAILED(rv)) {
mSucceeded = false;
}
}
if (!mSucceeded) {
NotifyState(nsIOfflineCacheUpdateObserver::STATE_ERROR);
Finish();
return;
}
NotifyState(nsIOfflineCacheUpdateObserver::STATE_ITEMCOMPLETED);
ProcessNextURI();
}
void
nsOfflineCacheUpdate::ManifestCheckCompleted(nsresult aStatus,
const nsCString &aManifestHash)
{
// Keep the object alive through a Finish() call.
nsCOMPtr<nsIOfflineCacheUpdate> kungFuDeathGrip(this);
if (NS_SUCCEEDED(aStatus)) {
nsAutoCString firstManifestHash;
mManifestItem->GetManifestHash(firstManifestHash);
if (aManifestHash != firstManifestHash) {
LOG(("Manifest has changed during cache items download [%p]", this));
LogToConsole("Offline cache manifest changed during update", mManifestItem);
aStatus = NS_ERROR_FAILURE;
}
}
if (NS_FAILED(aStatus)) {
mSucceeded = false;
NotifyState(nsIOfflineCacheUpdateObserver::STATE_ERROR);
}
if (NS_FAILED(aStatus) && mRescheduleCount < kRescheduleLimit) {
// Do the final stuff but prevent notification of STATE_FINISHED.
// That would disconnect listeners that are responsible for document
// association after a successful update. Forwarding notifications
// from a new update through this dead update to them is absolutely
// correct.
FinishNoNotify();
RefPtr<nsOfflineCacheUpdate> newUpdate =
new nsOfflineCacheUpdate();
// Leave aDocument argument null. Only glues and children keep
// document instances.
newUpdate->Init(mManifestURI, mDocumentURI, mLoadingPrincipal, nullptr,
mCustomProfileDir);
// In a rare case the manifest will not be modified on the next refetch
// transfer all master document URIs to the new update to ensure that
// all documents refering it will be properly cached.
for (int32_t i = 0; i < mDocumentURIs.Count(); i++) {
newUpdate->StickDocument(mDocumentURIs[i]);
}
newUpdate->mRescheduleCount = mRescheduleCount + 1;
newUpdate->AddObserver(this, false);
newUpdate->Schedule();
}
else {
LogToConsole("Offline cache update done", mManifestItem);
Finish();
}
}
nsresult
nsOfflineCacheUpdate::Begin()
{
LOG(("nsOfflineCacheUpdate::Begin [%p]", this));
// Keep the object alive through a ProcessNextURI()/Finish() call.
nsCOMPtr<nsIOfflineCacheUpdate> kungFuDeathGrip(this);
mItemsInProgress = 0;
if (mState == STATE_CANCELLED) {
RefPtr<nsRunnableMethod<nsOfflineCacheUpdate> > errorNotification =
NS_NewRunnableMethod(this,
&nsOfflineCacheUpdate::AsyncFinishWithError);
nsresult rv = NS_DispatchToMainThread(errorNotification);
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
if (mPartialUpdate) {
mState = STATE_DOWNLOADING;
NotifyState(nsIOfflineCacheUpdateObserver::STATE_DOWNLOADING);
ProcessNextURI();
return NS_OK;
}
// Start checking the manifest.
nsCOMPtr<nsIURI> uri;
mManifestItem = new nsOfflineManifestItem(mManifestURI,
mDocumentURI,
mLoadingPrincipal,
mApplicationCache,
mPreviousApplicationCache);
if (!mManifestItem) {
return NS_ERROR_OUT_OF_MEMORY;
}
mState = STATE_CHECKING;
mByteProgress = 0;
NotifyState(nsIOfflineCacheUpdateObserver::STATE_CHECKING);
nsresult rv = mManifestItem->OpenChannel(this);
if (NS_FAILED(rv)) {
LoadCompleted(mManifestItem);
}
return NS_OK;
}
//-----------------------------------------------------------------------------
// nsOfflineCacheUpdate <private>
//-----------------------------------------------------------------------------
nsresult
nsOfflineCacheUpdate::AddExistingItems(uint32_t aType,
nsTArray<nsCString>* namespaceFilter)
{
if (!mPreviousApplicationCache) {
return NS_OK;
}
if (namespaceFilter && namespaceFilter->Length() == 0) {
// Don't bother to walk entries when there are no namespaces
// defined.
return NS_OK;
}
uint32_t count = 0;
char **keys = nullptr;
nsresult rv = mPreviousApplicationCache->GatherEntries(aType,
&count, &keys);
NS_ENSURE_SUCCESS(rv, rv);
AutoFreeArray autoFree(count, keys);
for (uint32_t i = 0; i < count; i++) {
if (namespaceFilter) {
bool found = false;
for (uint32_t j = 0; j < namespaceFilter->Length() && !found; j++) {
found = StringBeginsWith(nsDependentCString(keys[i]),
namespaceFilter->ElementAt(j));
}
if (!found)
continue;
}
nsCOMPtr<nsIURI> uri;
if (NS_SUCCEEDED(NS_NewURI(getter_AddRefs(uri), keys[i]))) {
rv = AddURI(uri, aType);
NS_ENSURE_SUCCESS(rv, rv);
}
}
return NS_OK;
}
nsresult
nsOfflineCacheUpdate::ProcessNextURI()
{
// Keep the object alive through a Finish() call.
nsCOMPtr<nsIOfflineCacheUpdate> kungFuDeathGrip(this);
LOG(("nsOfflineCacheUpdate::ProcessNextURI [%p, inprogress=%d, numItems=%d]",
this, mItemsInProgress, mItems.Length()));
if (mState != STATE_DOWNLOADING) {
LOG((" should only be called from the DOWNLOADING state, ignoring"));
return NS_ERROR_UNEXPECTED;
}
nsOfflineCacheUpdateItem * runItem = nullptr;
uint32_t completedItems = 0;
for (uint32_t i = 0; i < mItems.Length(); ++i) {
nsOfflineCacheUpdateItem * item = mItems[i];
if (item->IsScheduled()) {
runItem = item;
break;
}
if (item->IsCompleted())
++completedItems;
}
if (completedItems == mItems.Length()) {
LOG(("nsOfflineCacheUpdate::ProcessNextURI [%p]: all items loaded", this));
if (mPartialUpdate) {
return Finish();
} else {
// Verify that the manifest wasn't changed during the
// update, to prevent capturing a cache while the server
// is being updated. The check will call
// ManifestCheckCompleted() when it's done.
RefPtr<nsManifestCheck> manifestCheck =
new nsManifestCheck(this, mManifestURI, mDocumentURI, mLoadingPrincipal);
if (NS_FAILED(manifestCheck->Begin())) {
mSucceeded = false;
NotifyState(nsIOfflineCacheUpdateObserver::STATE_ERROR);
return Finish();
}
return NS_OK;
}
}
if (!runItem) {
LOG(("nsOfflineCacheUpdate::ProcessNextURI [%p]:"
" No more items to include in parallel load", this));
return NS_OK;
}
if (LOG_ENABLED()) {
nsAutoCString spec;
runItem->mURI->GetSpec(spec);
LOG(("%p: Opening channel for %s", this, spec.get()));
}
++mItemsInProgress;
NotifyState(nsIOfflineCacheUpdateObserver::STATE_ITEMSTARTED);
nsresult rv = runItem->OpenChannel(this);
if (NS_FAILED(rv)) {
LoadCompleted(runItem);
return rv;
}
if (mItemsInProgress >= kParallelLoadLimit) {
LOG(("nsOfflineCacheUpdate::ProcessNextURI [%p]:"
" At parallel load limit", this));
return NS_OK;
}
// This calls this method again via a post triggering
// a parallel item load
return NS_DispatchToCurrentThread(this);
}
void
nsOfflineCacheUpdate::GatherObservers(nsCOMArray<nsIOfflineCacheUpdateObserver> &aObservers)
{
for (int32_t i = 0; i < mWeakObservers.Count(); i++) {
nsCOMPtr<nsIOfflineCacheUpdateObserver> observer =
do_QueryReferent(mWeakObservers[i]);
if (observer)
aObservers.AppendObject(observer);
else
mWeakObservers.RemoveObjectAt(i--);
}
for (int32_t i = 0; i < mObservers.Count(); i++) {
aObservers.AppendObject(mObservers[i]);
}
}
void
nsOfflineCacheUpdate::NotifyState(uint32_t state)
{
LOG(("nsOfflineCacheUpdate::NotifyState [%p, %d]", this, state));
if (state == STATE_ERROR) {
LogToConsole("Offline cache update error", mManifestItem);
}
nsCOMArray<nsIOfflineCacheUpdateObserver> observers;
GatherObservers(observers);
for (int32_t i = 0; i < observers.Count(); i++) {
observers[i]->UpdateStateChanged(this, state);
}
}
void
nsOfflineCacheUpdate::NotifyUpdateAvailability(bool updateAvailable)
{
if (!mUpdateAvailableObserver)
return;
LOG(("nsOfflineCacheUpdate::NotifyUpdateAvailability [this=%p, avail=%d]",
this, updateAvailable));
const char* topic = updateAvailable
? "offline-cache-update-available"
: "offline-cache-update-unavailable";
nsCOMPtr<nsIObserver> observer;
observer.swap(mUpdateAvailableObserver);
observer->Observe(mManifestURI, topic, nullptr);
}
void
nsOfflineCacheUpdate::AssociateDocuments(nsIApplicationCache* cache)
{
if (!cache) {
LOG(("nsOfflineCacheUpdate::AssociateDocuments bypassed"
", no cache provided [this=%p]", this));
return;
}
nsCOMArray<nsIOfflineCacheUpdateObserver> observers;
GatherObservers(observers);
for (int32_t i = 0; i < observers.Count(); i++) {
observers[i]->ApplicationCacheAvailable(cache);
}
}
void
nsOfflineCacheUpdate::StickDocument(nsIURI *aDocumentURI)
{
if (!aDocumentURI)
return;
mDocumentURIs.AppendObject(aDocumentURI);
}
void
nsOfflineCacheUpdate::SetOwner(nsOfflineCacheUpdateOwner *aOwner)
{
NS_ASSERTION(!mOwner, "Tried to set cache update owner twice.");
mOwner = aOwner;
}
bool
nsOfflineCacheUpdate::IsForGroupID(const nsCSubstring &groupID)
{
return mGroupID == groupID;
}
bool
nsOfflineCacheUpdate::IsForProfile(nsIFile* aCustomProfileDir)
{
if (!mCustomProfileDir && !aCustomProfileDir)
return true;
if (!mCustomProfileDir || !aCustomProfileDir)
return false;
bool equals;
nsresult rv = mCustomProfileDir->Equals(aCustomProfileDir, &equals);
return NS_SUCCEEDED(rv) && equals;
}
nsresult
nsOfflineCacheUpdate::UpdateFinished(nsOfflineCacheUpdate *aUpdate)
{
// Keep the object alive through a Finish() call.
nsCOMPtr<nsIOfflineCacheUpdate> kungFuDeathGrip(this);
mImplicitUpdate = nullptr;
NotifyState(nsIOfflineCacheUpdateObserver::STATE_NOUPDATE);
Finish();
return NS_OK;
}
void
nsOfflineCacheUpdate::OnByteProgress(uint64_t byteIncrement)
{
mByteProgress += byteIncrement;
NotifyState(nsIOfflineCacheUpdateObserver::STATE_ITEMPROGRESS);
}
nsresult
nsOfflineCacheUpdate::ScheduleImplicit()
{
if (mDocumentURIs.Count() == 0)
return NS_OK;
nsresult rv;
RefPtr<nsOfflineCacheUpdate> update = new nsOfflineCacheUpdate();
NS_ENSURE_TRUE(update, NS_ERROR_OUT_OF_MEMORY);
nsAutoCString clientID;
if (mPreviousApplicationCache) {
rv = mPreviousApplicationCache->GetClientID(clientID);
NS_ENSURE_SUCCESS(rv, rv);
}
else if (mApplicationCache) {
rv = mApplicationCache->GetClientID(clientID);
NS_ENSURE_SUCCESS(rv, rv);
}
else {
NS_ERROR("Offline cache update not having set mApplicationCache?");
}
rv = update->InitPartial(mManifestURI, clientID, mDocumentURI, mLoadingPrincipal);
NS_ENSURE_SUCCESS(rv, rv);
for (int32_t i = 0; i < mDocumentURIs.Count(); i++) {
rv = update->AddURI(mDocumentURIs[i],
nsIApplicationCache::ITEM_IMPLICIT);
NS_ENSURE_SUCCESS(rv, rv);
}
update->SetOwner(this);
rv = update->Begin();
NS_ENSURE_SUCCESS(rv, rv);
mImplicitUpdate = update;
return NS_OK;
}
nsresult
nsOfflineCacheUpdate::FinishNoNotify()
{
LOG(("nsOfflineCacheUpdate::Finish [%p]", this));
mState = STATE_FINISHED;
if (!mPartialUpdate && !mOnlyCheckUpdate) {
if (mSucceeded) {
nsIArray *namespaces = mManifestItem->GetNamespaces();
nsresult rv = mApplicationCache->AddNamespaces(namespaces);
if (NS_FAILED(rv)) {
NotifyState(nsIOfflineCacheUpdateObserver::STATE_ERROR);
mSucceeded = false;
}
rv = mApplicationCache->Activate();
if (NS_FAILED(rv)) {
NotifyState(nsIOfflineCacheUpdateObserver::STATE_ERROR);
mSucceeded = false;
}
AssociateDocuments(mApplicationCache);
}
if (mObsolete) {
nsCOMPtr<nsIApplicationCacheService> appCacheService =
do_GetService(NS_APPLICATIONCACHESERVICE_CONTRACTID);
if (appCacheService) {
nsAutoCString groupID;
mApplicationCache->GetGroupID(groupID);
appCacheService->DeactivateGroup(groupID);
}
}
if (!mSucceeded) {
// Update was not merged, mark all the loads as failures
for (uint32_t i = 0; i < mItems.Length(); i++) {
mItems[i]->Cancel();
}
mApplicationCache->Discard();
}
}
nsresult rv = NS_OK;
if (mOwner) {
rv = mOwner->UpdateFinished(this);
// mozilla::WeakPtr is missing some key features, like setting it to
// null explicitly.
mOwner = mozilla::WeakPtr<nsOfflineCacheUpdateOwner>();
}
return rv;
}
nsresult
nsOfflineCacheUpdate::Finish()
{
nsresult rv = FinishNoNotify();
NotifyState(nsIOfflineCacheUpdateObserver::STATE_FINISHED);
return rv;
}
void
nsOfflineCacheUpdate::AsyncFinishWithError()
{
NotifyState(nsOfflineCacheUpdate::STATE_ERROR);
Finish();
}
static nsresult
EvictOneOfCacheGroups(nsIApplicationCacheService *cacheService,
uint32_t count, const char * const *groups)
{
nsresult rv;
unsigned int i;
for (i = 0; i < count; i++) {
nsCOMPtr<nsIURI> uri;
rv = NS_NewURI(getter_AddRefs(uri), groups[i]);
NS_ENSURE_SUCCESS(rv, rv);
nsDependentCString group_name(groups[i]);
nsCOMPtr<nsIApplicationCache> cache;
rv = cacheService->GetActiveCache(group_name, getter_AddRefs(cache));
// Maybe someone in another thread or process have deleted it.
if (NS_FAILED(rv) || !cache)
continue;
bool pinned;
rv = nsOfflineCacheUpdateService::OfflineAppPinnedForURI(uri,
nullptr,
&pinned);
NS_ENSURE_SUCCESS(rv, rv);
if (!pinned) {
rv = cache->Discard();
return NS_OK;
}
}
return NS_ERROR_FILE_NOT_FOUND;
}
nsresult
nsOfflineCacheUpdate::EvictOneNonPinned()
{
nsresult rv;
nsCOMPtr<nsIApplicationCacheService> cacheService =
do_GetService(NS_APPLICATIONCACHESERVICE_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
uint32_t count;
char **groups;
rv = cacheService->GetGroupsTimeOrdered(&count, &groups);
NS_ENSURE_SUCCESS(rv, rv);
rv = EvictOneOfCacheGroups(cacheService, count, groups);
NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(count, groups);
return rv;
}
//-----------------------------------------------------------------------------
// nsOfflineCacheUpdate::nsIOfflineCacheUpdate
//-----------------------------------------------------------------------------
NS_IMETHODIMP
nsOfflineCacheUpdate::GetUpdateDomain(nsACString &aUpdateDomain)
{
NS_ENSURE_TRUE(mState >= STATE_INITIALIZED, NS_ERROR_NOT_INITIALIZED);
aUpdateDomain = mUpdateDomain;
return NS_OK;
}
NS_IMETHODIMP
nsOfflineCacheUpdate::GetStatus(uint16_t *aStatus)
{
switch (mState) {
case STATE_CHECKING :
*aStatus = nsIDOMOfflineResourceList::CHECKING;
return NS_OK;
case STATE_DOWNLOADING :
*aStatus = nsIDOMOfflineResourceList::DOWNLOADING;
return NS_OK;
default :
*aStatus = nsIDOMOfflineResourceList::IDLE;
return NS_OK;
}
return NS_ERROR_FAILURE;
}
NS_IMETHODIMP
nsOfflineCacheUpdate::GetPartial(bool *aPartial)
{
*aPartial = mPartialUpdate || mOnlyCheckUpdate;
return NS_OK;
}
NS_IMETHODIMP
nsOfflineCacheUpdate::GetManifestURI(nsIURI **aManifestURI)
{
NS_ENSURE_TRUE(mState >= STATE_INITIALIZED, NS_ERROR_NOT_INITIALIZED);
NS_IF_ADDREF(*aManifestURI = mManifestURI);
return NS_OK;
}
NS_IMETHODIMP
nsOfflineCacheUpdate::GetSucceeded(bool *aSucceeded)
{
NS_ENSURE_TRUE(mState == STATE_FINISHED, NS_ERROR_NOT_AVAILABLE);
*aSucceeded = mSucceeded;
return NS_OK;
}
NS_IMETHODIMP
nsOfflineCacheUpdate::GetIsUpgrade(bool *aIsUpgrade)
{
NS_ENSURE_TRUE(mState >= STATE_INITIALIZED, NS_ERROR_NOT_INITIALIZED);
*aIsUpgrade = (mPreviousApplicationCache != nullptr);
return NS_OK;
}
nsresult
nsOfflineCacheUpdate::AddURI(nsIURI *aURI, uint32_t aType)
{
NS_ENSURE_TRUE(mState >= STATE_INITIALIZED, NS_ERROR_NOT_INITIALIZED);
if (mState >= STATE_DOWNLOADING)
return NS_ERROR_NOT_AVAILABLE;
// Resource URIs must have the same scheme as the manifest.
nsAutoCString scheme;
aURI->GetScheme(scheme);
bool match;
if (NS_FAILED(mManifestURI->SchemeIs(scheme.get(), &match)) || !match)
return NS_ERROR_FAILURE;
// Don't fetch the same URI twice.
for (uint32_t i = 0; i < mItems.Length(); i++) {
bool equals;
if (NS_SUCCEEDED(mItems[i]->mURI->Equals(aURI, &equals)) && equals) {
// retain both types.
mItems[i]->mItemType |= aType;
return NS_OK;
}
}
RefPtr<nsOfflineCacheUpdateItem> item =
new nsOfflineCacheUpdateItem(aURI,
mDocumentURI,
mLoadingPrincipal,
mApplicationCache,
mPreviousApplicationCache,
aType);
if (!item) return NS_ERROR_OUT_OF_MEMORY;
mItems.AppendElement(item);
mAddedItems = true;
return NS_OK;
}
NS_IMETHODIMP
nsOfflineCacheUpdate::AddDynamicURI(nsIURI *aURI)
{
if (GeckoProcessType_Default != XRE_GetProcessType())
return NS_ERROR_NOT_IMPLEMENTED;
// If this is a partial update and the resource is already in the
// cache, we should only mark the entry, not fetch it again.
if (mPartialUpdate) {
nsAutoCString key;
GetCacheKey(aURI, key);
uint32_t types;
nsresult rv = mApplicationCache->GetTypes(key, &types);
if (NS_SUCCEEDED(rv)) {
if (!(types & nsIApplicationCache::ITEM_DYNAMIC)) {
mApplicationCache->MarkEntry
(key, nsIApplicationCache::ITEM_DYNAMIC);
}
return NS_OK;
}
}
return AddURI(aURI, nsIApplicationCache::ITEM_DYNAMIC);
}
NS_IMETHODIMP
nsOfflineCacheUpdate::Cancel()
{
LOG(("nsOfflineCacheUpdate::Cancel [%p]", this));
if ((mState == STATE_FINISHED) || (mState == STATE_CANCELLED)) {
return NS_ERROR_NOT_AVAILABLE;
}
mState = STATE_CANCELLED;
mSucceeded = false;
// Cancel all running downloads
for (uint32_t i = 0; i < mItems.Length(); ++i) {
nsOfflineCacheUpdateItem * item = mItems[i];
if (item->IsInProgress())
item->Cancel();
}
return NS_OK;
}
NS_IMETHODIMP
nsOfflineCacheUpdate::AddObserver(nsIOfflineCacheUpdateObserver *aObserver,
bool aHoldWeak)
{
LOG(("nsOfflineCacheUpdate::AddObserver [%p] to update [%p]", aObserver, this));
NS_ENSURE_TRUE(mState >= STATE_INITIALIZED, NS_ERROR_NOT_INITIALIZED);
if (aHoldWeak) {
nsCOMPtr<nsIWeakReference> weakRef = do_GetWeakReference(aObserver);
mWeakObservers.AppendObject(weakRef);
} else {
mObservers.AppendObject(aObserver);
}
return NS_OK;
}
NS_IMETHODIMP
nsOfflineCacheUpdate::RemoveObserver(nsIOfflineCacheUpdateObserver *aObserver)
{
LOG(("nsOfflineCacheUpdate::RemoveObserver [%p] from update [%p]", aObserver, this));
NS_ENSURE_TRUE(mState >= STATE_INITIALIZED, NS_ERROR_NOT_INITIALIZED);
for (int32_t i = 0; i < mWeakObservers.Count(); i++) {
nsCOMPtr<nsIOfflineCacheUpdateObserver> observer =
do_QueryReferent(mWeakObservers[i]);
if (observer == aObserver) {
mWeakObservers.RemoveObjectAt(i);
return NS_OK;
}
}
for (int32_t i = 0; i < mObservers.Count(); i++) {
if (mObservers[i] == aObserver) {
mObservers.RemoveObjectAt(i);
return NS_OK;
}
}
return NS_OK;
}
NS_IMETHODIMP
nsOfflineCacheUpdate::GetByteProgress(uint64_t * _result)
{
NS_ENSURE_ARG(_result);
*_result = mByteProgress;
return NS_OK;
}
NS_IMETHODIMP
nsOfflineCacheUpdate::Schedule()
{
LOG(("nsOfflineCacheUpdate::Schedule [%p]", this));
nsOfflineCacheUpdateService* service =
nsOfflineCacheUpdateService::EnsureService();
if (!service) {
return NS_ERROR_FAILURE;
}
return service->ScheduleUpdate(this);
}
NS_IMETHODIMP
nsOfflineCacheUpdate::UpdateStateChanged(nsIOfflineCacheUpdate *aUpdate,
uint32_t aState)
{
if (aState == nsIOfflineCacheUpdateObserver::STATE_FINISHED) {
// Take the mSucceeded flag from the underlying update, we will be
// queried for it soon. mSucceeded of this update is false (manifest
// check failed) but the subsequent re-fetch update might succeed
bool succeeded;
aUpdate->GetSucceeded(&succeeded);
mSucceeded = succeeded;
}
NotifyState(aState);
if (aState == nsIOfflineCacheUpdateObserver::STATE_FINISHED)
aUpdate->RemoveObserver(this);
return NS_OK;
}
NS_IMETHODIMP
nsOfflineCacheUpdate::ApplicationCacheAvailable(nsIApplicationCache *applicationCache)
{
AssociateDocuments(applicationCache);
return NS_OK;
}
//-----------------------------------------------------------------------------
// nsOfflineCacheUpdate::nsIRunable
//-----------------------------------------------------------------------------
NS_IMETHODIMP
nsOfflineCacheUpdate::Run()
{
ProcessNextURI();
return NS_OK;
}
Reference in New Issue View Git Blame Copy Permalink