зеркало из https://github.com/mozilla/gecko-dev.git
524 строки
16 KiB
C++
524 строки
16 KiB
C++
/* -*- 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/OfflineResourceListBinding.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 "nsPIDOMWindow.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"
|
|
#include "nsApplicationCache.h"
|
|
|
|
using namespace mozilla::ipc;
|
|
using namespace mozilla::net;
|
|
using mozilla::dom::TabChild;
|
|
using mozilla::dom::ContentChild;
|
|
|
|
//
|
|
// To enable logging (see mozilla/Logging.h for full details):
|
|
//
|
|
// set MOZ_LOG=nsOfflineCacheUpdate:5
|
|
// set MOZ_LOG_FILE=offlineupdate.log
|
|
//
|
|
// this enables LogLevel::Debug level information and places all output in
|
|
// the file offlineupdate.log
|
|
//
|
|
extern mozilla::LazyLogModule 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(nsPIDOMWindowInner* aWindow)
|
|
: mState(STATE_UNINITIALIZED)
|
|
, mIsUpgrade(false)
|
|
, mSucceeded(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(nsIDocument *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).
|
|
if (!aDocument)
|
|
return;
|
|
|
|
nsIChannel* channel = aDocument->GetChannel();
|
|
nsCOMPtr<nsIApplicationCacheChannel> appCacheChannel =
|
|
do_QueryInterface(channel);
|
|
if (!appCacheChannel)
|
|
return;
|
|
|
|
bool loadedFromAppCache;
|
|
appCacheChannel->GetLoadedFromApplicationCache(&loadedFromAppCache);
|
|
if (loadedFromAppCache)
|
|
return;
|
|
|
|
mDocument = aDocument;
|
|
}
|
|
|
|
nsresult
|
|
OfflineCacheUpdateChild::AssociateDocument(nsIDocument *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,
|
|
nsIDocument *aDocument,
|
|
nsIFile *aCustomProfileDir)
|
|
{
|
|
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);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
OfflineCacheUpdateChild::InitPartial(nsIURI *aManifestURI,
|
|
const nsACString& clientID,
|
|
nsIURI *aDocumentURI,
|
|
nsIPrincipal *aLoadingPrincipal)
|
|
{
|
|
MOZ_ASSERT_UNREACHABLE("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,
|
|
nsIObserver *aObserver)
|
|
{
|
|
MOZ_ASSERT_UNREACHABLE("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 = mozilla::dom::OfflineResourceList_Binding::CHECKING;
|
|
return NS_OK;
|
|
case STATE_DOWNLOADING :
|
|
*aStatus = mozilla::dom::OfflineResourceList_Binding::DOWNLOADING;
|
|
return NS_OK;
|
|
default :
|
|
*aStatus = mozilla::dom::OfflineResourceList_Binding::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<nsPIDOMWindowInner> window = mWindow.forget();
|
|
nsCOMPtr<nsIDocShell >docshell = window->GetDocShell();
|
|
if (!docshell) {
|
|
NS_WARNING("doc shell tree item is null");
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
nsCOMPtr<nsITabChild> tabchild = docshell->GetTabChild();
|
|
// 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);
|
|
|
|
// ContentChild::DeallocPOfflineCacheUpdate will release this.
|
|
NS_ADDREF_THIS();
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
mozilla::ipc::IPCResult
|
|
OfflineCacheUpdateChild::RecvAssociateDocuments(const nsCString &cacheGroupId,
|
|
const nsCString &cacheClientId)
|
|
{
|
|
LOG(("OfflineCacheUpdateChild::RecvAssociateDocuments [%p, cache=%s]", this, cacheClientId.get()));
|
|
|
|
nsCOMPtr<nsIApplicationCache> cache = new nsApplicationCache();
|
|
|
|
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 IPC_OK();
|
|
}
|
|
|
|
mozilla::ipc::IPCResult
|
|
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 IPC_OK();
|
|
}
|
|
|
|
mozilla::ipc::IPCResult
|
|
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 IPC_OK();
|
|
}
|
|
|
|
} // namespace docshell
|
|
} // namespace mozilla
|