Macintosh-SW
/
tenfourfox
mirror of https://github.com/classilla/tenfourfox.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
tenfourfox/uriloader/prefetch/OfflineCacheUpdateChild.cpp

545 lines
16 KiB
C++
Raw Permalink 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 "BackgroundUtils.h"
#include "OfflineCacheUpdateChild.h"
#include "nsOfflineCacheUpdate.h"
#include "mozilla/dom/ContentChild.h"
#include "mozilla/dom/TabChild.h"
#include "mozilla/ipc/URIUtils.h"
#include "mozilla/net/NeckoCommon.h"
#include "nsIApplicationCacheContainer.h"
#include "nsIApplicationCacheChannel.h"
#include "nsIApplicationCacheService.h"
#include "nsIDocShell.h"
#include "nsIDocShellTreeItem.h"
#include "nsIDocShellTreeOwner.h"
#include "nsIDOMWindow.h"
#include "nsIDOMOfflineResourceList.h"
#include "nsIDocument.h"
#include "nsIObserverService.h"
#include "nsIURL.h"
#include "nsITabChild.h"
#include "nsNetCID.h"
#include "nsNetUtil.h"
#include "nsServiceManagerUtils.h"
#include "nsStreamUtils.h"
#include "nsThreadUtils.h"
#include "nsProxyRelease.h"
#include "mozilla/Logging.h"
#include "nsIAsyncVerifyRedirectCallback.h"
using namespace mozilla::ipc;
using namespace mozilla::net;
using mozilla::dom::TabChild;
using mozilla::dom::ContentChild;
//
// 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)
namespace mozilla {
namespace docshell {
//-----------------------------------------------------------------------------
// OfflineCacheUpdateChild::nsISupports
//-----------------------------------------------------------------------------
NS_INTERFACE_MAP_BEGIN(OfflineCacheUpdateChild)
NS_INTERFACE_MAP_ENTRY(nsISupports)
NS_INTERFACE_MAP_ENTRY(nsIOfflineCacheUpdate)
NS_INTERFACE_MAP_END
NS_IMPL_ADDREF(OfflineCacheUpdateChild)
NS_IMPL_RELEASE(OfflineCacheUpdateChild)
//-----------------------------------------------------------------------------
// OfflineCacheUpdateChild <public>
//-----------------------------------------------------------------------------
OfflineCacheUpdateChild::OfflineCacheUpdateChild(nsIDOMWindow* aWindow)
: mState(STATE_UNINITIALIZED)
, mIsUpgrade(false)
, mAppID(NECKO_NO_APP_ID)
, mInBrowser(false)
, mWindow(aWindow)
, mByteProgress(0)
{
}
OfflineCacheUpdateChild::~OfflineCacheUpdateChild()
{
LOG(("OfflineCacheUpdateChild::~OfflineCacheUpdateChild [%p]", this));
}
void
OfflineCacheUpdateChild::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
OfflineCacheUpdateChild::SetDocument(nsIDOMDocument *aDocument)
{
// The design is one document for one cache update on the content process.
NS_ASSERTION(!mDocument, "Setting more then a single document on a child offline cache update");
LOG(("Document %p added to update child %p", aDocument, this));
// Add document only if it was not loaded from an offline cache.
// If it were loaded from an offline cache then it has already
// been associated with it and must not be again cached as
// implicit (which are the reasons we collect documents here).
nsCOMPtr<nsIDocument> document = do_QueryInterface(aDocument);
if (!document)
return;
nsIChannel* channel = document->GetChannel();
nsCOMPtr<nsIApplicationCacheChannel> appCacheChannel =
do_QueryInterface(channel);
if (!appCacheChannel)
return;
bool loadedFromAppCache;
appCacheChannel->GetLoadedFromApplicationCache(&loadedFromAppCache);
if (loadedFromAppCache)
return;
mDocument = aDocument;
}
nsresult
OfflineCacheUpdateChild::AssociateDocument(nsIDOMDocument *aDocument,
nsIApplicationCache *aApplicationCache)
{
// Check that the document that requested this update was
// previously associated with an application cache. If not, it
// should be associated with the new one.
nsCOMPtr<nsIApplicationCacheContainer> container =
do_QueryInterface(aDocument);
if (!container)
return NS_OK;
nsCOMPtr<nsIApplicationCache> existingCache;
nsresult rv = container->GetApplicationCache(getter_AddRefs(existingCache));
NS_ENSURE_SUCCESS(rv, rv);
if (!existingCache) {
if (LOG_ENABLED()) {
nsAutoCString clientID;
if (aApplicationCache) {
aApplicationCache->GetClientID(clientID);
}
LOG(("Update %p: associating app cache %s to document %p",
this, clientID.get(), aDocument));
}
rv = container->SetApplicationCache(aApplicationCache);
NS_ENSURE_SUCCESS(rv, rv);
}
return NS_OK;
}
//-----------------------------------------------------------------------------
// OfflineCacheUpdateChild::nsIOfflineCacheUpdate
//-----------------------------------------------------------------------------
NS_IMETHODIMP
OfflineCacheUpdateChild::Init(nsIURI *aManifestURI,
nsIURI *aDocumentURI,
nsIPrincipal *aLoadingPrincipal,
nsIDOMDocument *aDocument,
nsIFile *aCustomProfileDir,
uint32_t aAppID,
bool aInBrowser)
{
nsresult rv;
// Make sure the service has been initialized
nsOfflineCacheUpdateService* service =
nsOfflineCacheUpdateService::EnsureService();
if (!service)
return NS_ERROR_FAILURE;
if (aCustomProfileDir) {
NS_ERROR("Custom Offline Cache Update not supported on child process");
return NS_ERROR_NOT_IMPLEMENTED;
}
LOG(("OfflineCacheUpdateChild::Init [%p]", this));
// 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;
rv = mManifestURI->GetAsciiHost(mUpdateDomain);
NS_ENSURE_SUCCESS(rv, rv);
mDocumentURI = aDocumentURI;
mLoadingPrincipal = aLoadingPrincipal;
mState = STATE_INITIALIZED;
if (aDocument)
SetDocument(aDocument);
mAppID = aAppID;
mInBrowser = aInBrowser;
return NS_OK;
}
NS_IMETHODIMP
OfflineCacheUpdateChild::InitPartial(nsIURI *aManifestURI,
const nsACString& clientID,
nsIURI *aDocumentURI,
nsIPrincipal *aLoadingPrincipal)
{
NS_NOTREACHED("Not expected to do partial offline cache updates"
" on the child process");
// For now leaving this method, we may discover we need it.
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
OfflineCacheUpdateChild::InitForUpdateCheck(nsIURI *aManifestURI,
nsIPrincipal* aLoadingPrincipal,
uint32_t aAppID,
bool aInBrowser,
nsIObserver *aObserver)
{
NS_NOTREACHED("Not expected to do only update checks"
" from the child process");
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
OfflineCacheUpdateChild::GetUpdateDomain(nsACString &aUpdateDomain)
{
NS_ENSURE_TRUE(mState >= STATE_INITIALIZED, NS_ERROR_NOT_INITIALIZED);
aUpdateDomain = mUpdateDomain;
return NS_OK;
}
NS_IMETHODIMP
OfflineCacheUpdateChild::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
OfflineCacheUpdateChild::GetPartial(bool *aPartial)
{
*aPartial = false;
return NS_OK;
}
NS_IMETHODIMP
OfflineCacheUpdateChild::GetManifestURI(nsIURI **aManifestURI)
{
NS_ENSURE_TRUE(mState >= STATE_INITIALIZED, NS_ERROR_NOT_INITIALIZED);
NS_IF_ADDREF(*aManifestURI = mManifestURI);
return NS_OK;
}
NS_IMETHODIMP
OfflineCacheUpdateChild::GetSucceeded(bool *aSucceeded)
{
NS_ENSURE_TRUE(mState == STATE_FINISHED, NS_ERROR_NOT_AVAILABLE);
*aSucceeded = mSucceeded;
return NS_OK;
}
NS_IMETHODIMP
OfflineCacheUpdateChild::GetIsUpgrade(bool *aIsUpgrade)
{
NS_ENSURE_TRUE(mState >= STATE_INITIALIZED, NS_ERROR_NOT_INITIALIZED);
*aIsUpgrade = mIsUpgrade;
return NS_OK;
}
NS_IMETHODIMP
OfflineCacheUpdateChild::AddDynamicURI(nsIURI *aURI)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
OfflineCacheUpdateChild::Cancel()
{
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP
OfflineCacheUpdateChild::AddObserver(nsIOfflineCacheUpdateObserver *aObserver,
bool aHoldWeak)
{
LOG(("OfflineCacheUpdateChild::AddObserver [%p]", 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
OfflineCacheUpdateChild::RemoveObserver(nsIOfflineCacheUpdateObserver *aObserver)
{
LOG(("OfflineCacheUpdateChild::RemoveObserver [%p]", 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
OfflineCacheUpdateChild::GetByteProgress(uint64_t * _result)
{
NS_ENSURE_ARG(_result);
*_result = mByteProgress;
return NS_OK;
}
NS_IMETHODIMP
OfflineCacheUpdateChild::Schedule()
{
LOG(("OfflineCacheUpdateChild::Schedule [%p]", this));
NS_ASSERTION(mWindow, "Window must be provided to the offline cache update child");
nsCOMPtr<nsPIDOMWindow> piWindow =
do_QueryInterface(mWindow);
mWindow = nullptr;
nsIDocShell *docshell = piWindow->GetDocShell();
nsCOMPtr<nsIDocShellTreeItem> item = do_QueryInterface(docshell);
if (!item) {
NS_WARNING("doc shell tree item is null");
return NS_ERROR_FAILURE;
}
nsCOMPtr<nsIDocShellTreeOwner> owner;
item->GetTreeOwner(getter_AddRefs(owner));
nsCOMPtr<nsITabChild> tabchild = do_GetInterface(owner);
// because owner implements nsITabChild, we can assume that it is
// the one and only TabChild.
TabChild* child = tabchild ? static_cast<TabChild*>(tabchild.get()) : nullptr;
if (MissingRequiredTabChild(child, "offlinecacheupdate")) {
return NS_ERROR_FAILURE;
}
URIParams manifestURI, documentURI;
SerializeURI(mManifestURI, manifestURI);
SerializeURI(mDocumentURI, documentURI);
nsresult rv = NS_OK;
PrincipalInfo loadingPrincipalInfo;
rv = PrincipalToPrincipalInfo(mLoadingPrincipal,
&loadingPrincipalInfo);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIObserverService> observerService =
mozilla::services::GetObserverService();
if (observerService) {
LOG(("Calling offline-cache-update-added"));
observerService->NotifyObservers(static_cast<nsIOfflineCacheUpdate*>(this),
"offline-cache-update-added",
nullptr);
LOG(("Done offline-cache-update-added"));
}
// mDocument is non-null if both:
// 1. this update was initiated by a document that referred a manifest
// 2. the document has not already been loaded from the application cache
// This tells the update to cache this document even in case the manifest
// has not been changed since the last fetch.
// See also nsOfflineCacheUpdate::ScheduleImplicit.
bool stickDocument = mDocument != nullptr;
// Need to addref ourself here, because the IPC stack doesn't hold
// a reference to us. Will be released in RecvFinish() that identifies
// the work has been done.
ContentChild::GetSingleton()->SendPOfflineCacheUpdateConstructor(
this, manifestURI, documentURI, loadingPrincipalInfo,
stickDocument, child->GetTabId());
// ContentChild::DeallocPOfflineCacheUpdate will release this.
NS_ADDREF_THIS();
return NS_OK;
}
bool
OfflineCacheUpdateChild::RecvAssociateDocuments(const nsCString &cacheGroupId,
const nsCString &cacheClientId)
{
LOG(("OfflineCacheUpdateChild::RecvAssociateDocuments [%p, cache=%s]", this, cacheClientId.get()));
nsresult rv;
nsCOMPtr<nsIApplicationCache> cache =
do_CreateInstance(NS_APPLICATIONCACHE_CONTRACTID, &rv);
if (NS_FAILED(rv))
return true;
cache->InitAsHandle(cacheGroupId, cacheClientId);
if (mDocument) {
AssociateDocument(mDocument, cache);
}
nsCOMArray<nsIOfflineCacheUpdateObserver> observers;
GatherObservers(observers);
for (int32_t i = 0; i < observers.Count(); i++)
observers[i]->ApplicationCacheAvailable(cache);
return true;
}
bool
OfflineCacheUpdateChild::RecvNotifyStateEvent(const uint32_t &event,
const uint64_t &byteProgress)
{
LOG(("OfflineCacheUpdateChild::RecvNotifyStateEvent [%p]", this));
mByteProgress = byteProgress;
// Convert the public observer state to our internal state
switch (event) {
case nsIOfflineCacheUpdateObserver::STATE_CHECKING:
mState = STATE_CHECKING;
break;
case nsIOfflineCacheUpdateObserver::STATE_DOWNLOADING:
mState = STATE_DOWNLOADING;
break;
default:
break;
}
nsCOMArray<nsIOfflineCacheUpdateObserver> observers;
GatherObservers(observers);
for (int32_t i = 0; i < observers.Count(); i++)
observers[i]->UpdateStateChanged(this, event);
return true;
}
bool
OfflineCacheUpdateChild::RecvFinish(const bool &succeeded,
const bool &isUpgrade)
{
LOG(("OfflineCacheUpdateChild::RecvFinish [%p]", this));
RefPtr<OfflineCacheUpdateChild> kungFuDeathGrip(this);
mState = STATE_FINISHED;
mSucceeded = succeeded;
mIsUpgrade = isUpgrade;
nsCOMPtr<nsIObserverService> observerService =
mozilla::services::GetObserverService();
if (observerService) {
LOG(("Calling offline-cache-update-completed"));
observerService->NotifyObservers(static_cast<nsIOfflineCacheUpdate*>(this),
"offline-cache-update-completed",
nullptr);
LOG(("Done offline-cache-update-completed"));
}
// This is by contract the last notification from the parent, release
// us now. This is corresponding to AddRef in Schedule().
// TabChild::DeallocPOfflineCacheUpdate will call Release.
OfflineCacheUpdateChild::Send__delete__(this);
return true;
}
} // namespace docshell
} // namespace mozilla
Reference in New Issue View Git Blame Copy Permalink