gecko-dev/dom/xbl/nsXBLResourceLoader.cpp
2015-05-03 15:32:37 -04:00

302 lines
8.4 KiB
C++

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "nsTArray.h"
#include "nsString.h"
#include "nsIStyleRuleProcessor.h"
#include "nsIDocument.h"
#include "nsIContent.h"
#include "nsIPresShell.h"
#include "nsXBLService.h"
#include "nsIServiceManager.h"
#include "nsXBLResourceLoader.h"
#include "nsXBLPrototypeResources.h"
#include "nsIDocumentObserver.h"
#include "imgILoader.h"
#include "imgRequestProxy.h"
#include "mozilla/CSSStyleSheet.h"
#include "mozilla/css/Loader.h"
#include "nsIURI.h"
#include "nsNetUtil.h"
#include "nsGkAtoms.h"
#include "nsFrameManager.h"
#include "nsStyleContext.h"
#include "nsXBLPrototypeBinding.h"
#include "nsCSSRuleProcessor.h"
#include "nsContentUtils.h"
#include "nsStyleSet.h"
#include "nsIScriptSecurityManager.h"
using namespace mozilla;
NS_IMPL_CYCLE_COLLECTION(nsXBLResourceLoader, mBoundElements)
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsXBLResourceLoader)
NS_INTERFACE_MAP_ENTRY(nsICSSLoaderObserver)
NS_INTERFACE_MAP_ENTRY(nsISupports)
NS_INTERFACE_MAP_END
NS_IMPL_CYCLE_COLLECTING_ADDREF(nsXBLResourceLoader)
NS_IMPL_CYCLE_COLLECTING_RELEASE(nsXBLResourceLoader)
struct nsXBLResource
{
nsXBLResource* mNext;
nsIAtom* mType;
nsString mSrc;
nsXBLResource(nsIAtom* aType, const nsAString& aSrc)
{
MOZ_COUNT_CTOR(nsXBLResource);
mNext = nullptr;
mType = aType;
mSrc = aSrc;
}
~nsXBLResource()
{
MOZ_COUNT_DTOR(nsXBLResource);
NS_CONTENT_DELETE_LIST_MEMBER(nsXBLResource, this, mNext);
}
};
nsXBLResourceLoader::nsXBLResourceLoader(nsXBLPrototypeBinding* aBinding,
nsXBLPrototypeResources* aResources)
:mBinding(aBinding),
mResources(aResources),
mResourceList(nullptr),
mLastResource(nullptr),
mLoadingResources(false),
mInLoadResourcesFunc(false),
mPendingSheets(0)
{
}
nsXBLResourceLoader::~nsXBLResourceLoader()
{
delete mResourceList;
}
void
nsXBLResourceLoader::LoadResources(bool* aResult)
{
mInLoadResourcesFunc = true;
if (mLoadingResources) {
*aResult = (mPendingSheets == 0);
mInLoadResourcesFunc = false;
return;
}
mLoadingResources = true;
*aResult = true;
// Declare our loaders.
nsCOMPtr<nsIDocument> doc = mBinding->XBLDocumentInfo()->GetDocument();
mozilla::css::Loader* cssLoader = doc->CSSLoader();
nsIURI *docURL = doc->GetDocumentURI();
nsIPrincipal* docPrincipal = doc->NodePrincipal();
nsCOMPtr<nsIURI> url;
for (nsXBLResource* curr = mResourceList; curr; curr = curr->mNext) {
if (curr->mSrc.IsEmpty())
continue;
if (NS_FAILED(NS_NewURI(getter_AddRefs(url), curr->mSrc,
doc->GetDocumentCharacterSet().get(), docURL)))
continue;
if (curr->mType == nsGkAtoms::image) {
if (!nsContentUtils::CanLoadImage(url, doc, doc, docPrincipal)) {
// We're not permitted to load this image, move on...
continue;
}
// Now kick off the image load...
// Passing nullptr for pretty much everything -- cause we don't care!
// XXX: initialDocumentURI is nullptr!
nsRefPtr<imgRequestProxy> req;
nsContentUtils::LoadImage(url, doc, docPrincipal, docURL,
doc->GetReferrerPolicy(), nullptr,
nsIRequest::LOAD_BACKGROUND, EmptyString(),
getter_AddRefs(req));
}
else if (curr->mType == nsGkAtoms::stylesheet) {
// Kick off the load of the stylesheet.
// Always load chrome synchronously
// XXXbz should that still do a content policy check?
bool chrome;
nsresult rv;
if (NS_SUCCEEDED(url->SchemeIs("chrome", &chrome)) && chrome)
{
rv = nsContentUtils::GetSecurityManager()->
CheckLoadURIWithPrincipal(docPrincipal, url,
nsIScriptSecurityManager::ALLOW_CHROME);
if (NS_SUCCEEDED(rv)) {
nsRefPtr<CSSStyleSheet> sheet;
rv = cssLoader->LoadSheetSync(url, getter_AddRefs(sheet));
NS_ASSERTION(NS_SUCCEEDED(rv), "Load failed!!!");
if (NS_SUCCEEDED(rv))
{
rv = StyleSheetLoaded(sheet, false, NS_OK);
NS_ASSERTION(NS_SUCCEEDED(rv), "Processing the style sheet failed!!!");
}
}
}
else
{
rv = cssLoader->LoadSheet(url, docPrincipal, EmptyCString(), this);
if (NS_SUCCEEDED(rv))
++mPendingSheets;
}
}
}
*aResult = (mPendingSheets == 0);
mInLoadResourcesFunc = false;
// Destroy our resource list.
delete mResourceList;
mResourceList = nullptr;
}
// nsICSSLoaderObserver
NS_IMETHODIMP
nsXBLResourceLoader::StyleSheetLoaded(CSSStyleSheet* aSheet,
bool aWasAlternate,
nsresult aStatus)
{
if (!mResources) {
// Our resources got destroyed -- just bail out
return NS_OK;
}
mResources->AppendStyleSheet(aSheet);
if (!mInLoadResourcesFunc)
mPendingSheets--;
if (mPendingSheets == 0) {
// All stylesheets are loaded.
mResources->GatherRuleProcessor();
// XXX Check for mPendingScripts when scripts also come online.
if (!mInLoadResourcesFunc)
NotifyBoundElements();
}
return NS_OK;
}
void
nsXBLResourceLoader::AddResource(nsIAtom* aResourceType, const nsAString& aSrc)
{
nsXBLResource* res = new nsXBLResource(aResourceType, aSrc);
if (!res)
return;
if (!mResourceList)
mResourceList = res;
else
mLastResource->mNext = res;
mLastResource = res;
}
void
nsXBLResourceLoader::AddResourceListener(nsIContent* aBoundElement)
{
if (aBoundElement) {
mBoundElements.AppendObject(aBoundElement);
}
}
void
nsXBLResourceLoader::NotifyBoundElements()
{
nsXBLService* xblService = nsXBLService::GetInstance();
if (!xblService)
return;
nsIURI* bindingURI = mBinding->BindingURI();
uint32_t eltCount = mBoundElements.Count();
for (uint32_t j = 0; j < eltCount; j++) {
nsCOMPtr<nsIContent> content = mBoundElements.ObjectAt(j);
bool ready = false;
xblService->BindingReady(content, bindingURI, &ready);
if (ready) {
// We need the document to flush out frame construction and
// such, so we want to use the current document.
nsIDocument* doc = content->GetCurrentDoc();
if (doc) {
// Flush first to make sure we can get the frame for content
doc->FlushPendingNotifications(Flush_Frames);
// If |content| is (in addition to having binding |mBinding|)
// also a descendant of another element with binding |mBinding|,
// then we might have just constructed it due to the
// notification of its parent. (We can know about both if the
// binding loads were triggered from the DOM rather than frame
// construction.) So we have to check both whether the element
// has a primary frame and whether it's in the undisplayed map
// before sending a ContentInserted notification, or bad things
// will happen.
nsIPresShell *shell = doc->GetShell();
if (shell) {
nsIFrame* childFrame = content->GetPrimaryFrame();
if (!childFrame) {
// Check to see if it's in the undisplayed content map.
nsStyleContext* sc =
shell->FrameManager()->GetUndisplayedContent(content);
if (!sc) {
shell->RecreateFramesFor(content);
}
}
}
// Flush again
// XXXbz why is this needed?
doc->FlushPendingNotifications(Flush_ContentAndNotify);
}
}
}
// Clear out the whole array.
mBoundElements.Clear();
// Delete ourselves.
mResources->ClearLoader();
}
nsresult
nsXBLResourceLoader::Write(nsIObjectOutputStream* aStream)
{
nsresult rv;
for (nsXBLResource* curr = mResourceList; curr; curr = curr->mNext) {
if (curr->mType == nsGkAtoms::image)
rv = aStream->Write8(XBLBinding_Serialize_Image);
else if (curr->mType == nsGkAtoms::stylesheet)
rv = aStream->Write8(XBLBinding_Serialize_Stylesheet);
else
continue;
NS_ENSURE_SUCCESS(rv, rv);
rv = aStream->WriteWStringZ(curr->mSrc.get());
NS_ENSURE_SUCCESS(rv, rv);
}
return NS_OK;
}