зеркало из https://github.com/mozilla/gecko-dev.git
1161 строка
33 KiB
C++
1161 строка
33 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 "nsBindingManager.h"
|
|
|
|
#include "nsAutoPtr.h"
|
|
#include "nsCOMPtr.h"
|
|
#include "nsXBLService.h"
|
|
#include "nsIInputStream.h"
|
|
#include "nsIURI.h"
|
|
#include "nsIURL.h"
|
|
#include "nsIChannel.h"
|
|
#include "nsXPIDLString.h"
|
|
#include "plstr.h"
|
|
#include "nsIContent.h"
|
|
#include "nsIDOMElement.h"
|
|
#include "nsIDocument.h"
|
|
#include "nsContentUtils.h"
|
|
#include "nsIPresShell.h"
|
|
#include "nsIXMLContentSink.h"
|
|
#include "nsContentCID.h"
|
|
#include "mozilla/dom/XMLDocument.h"
|
|
#include "nsIStreamListener.h"
|
|
#include "ChildIterator.h"
|
|
#include "nsITimer.h"
|
|
|
|
#include "nsXBLBinding.h"
|
|
#include "nsXBLPrototypeBinding.h"
|
|
#include "nsXBLDocumentInfo.h"
|
|
#include "mozilla/dom/XBLChildrenElement.h"
|
|
|
|
#include "nsIStyleRuleProcessor.h"
|
|
#include "nsRuleProcessorData.h"
|
|
#include "nsIWeakReference.h"
|
|
|
|
#include "nsWrapperCacheInlines.h"
|
|
#include "nsIXPConnect.h"
|
|
#include "nsDOMCID.h"
|
|
#include "nsIScriptGlobalObject.h"
|
|
#include "nsTHashtable.h"
|
|
|
|
#include "nsIScriptContext.h"
|
|
#include "xpcpublic.h"
|
|
#include "jswrapper.h"
|
|
|
|
#include "nsThreadUtils.h"
|
|
#include "mozilla/dom/NodeListBinding.h"
|
|
#include "mozilla/dom/ScriptSettings.h"
|
|
#include "mozilla/Unused.h"
|
|
|
|
using namespace mozilla;
|
|
using namespace mozilla::dom;
|
|
|
|
// Implement our nsISupports methods
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_CLASS(nsBindingManager)
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsBindingManager)
|
|
tmp->mDestroyed = true;
|
|
|
|
if (tmp->mBoundContentSet)
|
|
tmp->mBoundContentSet->Clear();
|
|
|
|
if (tmp->mDocumentTable)
|
|
tmp->mDocumentTable->Clear();
|
|
|
|
if (tmp->mLoadingDocTable)
|
|
tmp->mLoadingDocTable->Clear();
|
|
|
|
if (tmp->mWrapperTable) {
|
|
tmp->mWrapperTable->Clear();
|
|
tmp->mWrapperTable = nullptr;
|
|
}
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mAttachedStack)
|
|
|
|
if (tmp->mProcessAttachedQueueEvent) {
|
|
tmp->mProcessAttachedQueueEvent->Revoke();
|
|
}
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_END
|
|
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsBindingManager)
|
|
// The hashes keyed on nsIContent are traversed from the nsIContent itself.
|
|
if (tmp->mDocumentTable) {
|
|
for (auto iter = tmp->mDocumentTable->Iter(); !iter.Done(); iter.Next()) {
|
|
NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb, "mDocumentTable value");
|
|
cb.NoteXPCOMChild(iter.UserData());
|
|
}
|
|
}
|
|
if (tmp->mLoadingDocTable) {
|
|
for (auto iter = tmp->mLoadingDocTable->Iter(); !iter.Done(); iter.Next()) {
|
|
NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb, "mLoadingDocTable value");
|
|
cb.NoteXPCOMChild(iter.UserData());
|
|
}
|
|
}
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mAttachedStack)
|
|
// No need to traverse mProcessAttachedQueueEvent, since it'll just
|
|
// fire at some point or become revoke and drop its ref to us.
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
|
|
|
|
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsBindingManager)
|
|
NS_INTERFACE_MAP_ENTRY(nsIMutationObserver)
|
|
NS_INTERFACE_MAP_ENTRY(nsISupports)
|
|
NS_INTERFACE_MAP_END
|
|
|
|
NS_IMPL_CYCLE_COLLECTING_ADDREF(nsBindingManager)
|
|
NS_IMPL_CYCLE_COLLECTING_RELEASE(nsBindingManager)
|
|
|
|
// Constructors/Destructors
|
|
nsBindingManager::nsBindingManager(nsIDocument* aDocument)
|
|
: mProcessingAttachedStack(false),
|
|
mDestroyed(false),
|
|
mAttachedStackSizeOnOutermost(0),
|
|
mDocument(aDocument)
|
|
{
|
|
}
|
|
|
|
nsBindingManager::~nsBindingManager(void)
|
|
{
|
|
mDestroyed = true;
|
|
}
|
|
|
|
nsXBLBinding*
|
|
nsBindingManager::GetBindingWithContent(const nsIContent* aContent)
|
|
{
|
|
nsXBLBinding* binding = aContent ? aContent->GetXBLBinding() : nullptr;
|
|
return binding ? binding->GetBindingWithContent() : nullptr;
|
|
}
|
|
|
|
void
|
|
nsBindingManager::AddBoundContent(nsIContent* aContent)
|
|
{
|
|
if (!mBoundContentSet) {
|
|
mBoundContentSet = new nsTHashtable<nsRefPtrHashKey<nsIContent> >;
|
|
}
|
|
mBoundContentSet->PutEntry(aContent);
|
|
}
|
|
|
|
void
|
|
nsBindingManager::RemoveBoundContent(nsIContent* aContent)
|
|
{
|
|
if (mBoundContentSet) {
|
|
mBoundContentSet->RemoveEntry(aContent);
|
|
}
|
|
|
|
// The death of the bindings means the death of the JS wrapper.
|
|
SetWrappedJS(aContent, nullptr);
|
|
}
|
|
|
|
nsIXPConnectWrappedJS*
|
|
nsBindingManager::GetWrappedJS(nsIContent* aContent)
|
|
{
|
|
if (!mWrapperTable) {
|
|
return nullptr;
|
|
}
|
|
|
|
if (!aContent || !aContent->HasFlag(NODE_MAY_BE_IN_BINDING_MNGR)) {
|
|
return nullptr;
|
|
}
|
|
|
|
return mWrapperTable->GetWeak(aContent);
|
|
}
|
|
|
|
nsresult
|
|
nsBindingManager::SetWrappedJS(nsIContent* aContent, nsIXPConnectWrappedJS* aWrappedJS)
|
|
{
|
|
if (mDestroyed) {
|
|
return NS_OK;
|
|
}
|
|
|
|
if (aWrappedJS) {
|
|
// lazily create the table, but only when adding elements
|
|
if (!mWrapperTable) {
|
|
mWrapperTable = new WrapperHashtable();
|
|
}
|
|
aContent->SetFlags(NODE_MAY_BE_IN_BINDING_MNGR);
|
|
|
|
NS_ASSERTION(aContent, "key must be non-null");
|
|
if (!aContent) return NS_ERROR_INVALID_ARG;
|
|
|
|
mWrapperTable->Put(aContent, aWrappedJS);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
// no value, so remove the key from the table
|
|
if (mWrapperTable) {
|
|
mWrapperTable->Remove(aContent);
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
void
|
|
nsBindingManager::RemovedFromDocumentInternal(nsIContent* aContent,
|
|
nsIDocument* aOldDocument,
|
|
DestructorHandling aDestructorHandling)
|
|
{
|
|
NS_PRECONDITION(aOldDocument != nullptr, "no old document");
|
|
|
|
RefPtr<nsXBLBinding> binding = aContent->GetXBLBinding();
|
|
if (binding) {
|
|
// The binding manager may have been destroyed before a runnable
|
|
// has had a chance to reach this point. If so, we bail out on calling
|
|
// BindingDetached (which may invoke a XBL destructor) and
|
|
// ChangeDocument, but we still want to clear out the binding
|
|
// and insertion parent that may hold references.
|
|
if (!mDestroyed && aDestructorHandling == eRunDtor) {
|
|
binding->PrototypeBinding()->BindingDetached(binding->GetBoundElement());
|
|
binding->ChangeDocument(aOldDocument, nullptr);
|
|
}
|
|
|
|
aContent->SetXBLBinding(nullptr, this);
|
|
}
|
|
|
|
// Clear out insertion parent and content lists.
|
|
aContent->SetXBLInsertionParent(nullptr);
|
|
}
|
|
|
|
nsIAtom*
|
|
nsBindingManager::ResolveTag(nsIContent* aContent, int32_t* aNameSpaceID)
|
|
{
|
|
nsXBLBinding *binding = aContent->GetXBLBinding();
|
|
|
|
if (binding) {
|
|
nsIAtom* base = binding->GetBaseTag(aNameSpaceID);
|
|
|
|
if (base) {
|
|
return base;
|
|
}
|
|
}
|
|
|
|
*aNameSpaceID = aContent->GetNameSpaceID();
|
|
return aContent->NodeInfo()->NameAtom();
|
|
}
|
|
|
|
nsresult
|
|
nsBindingManager::GetAnonymousNodesFor(nsIContent* aContent,
|
|
nsIDOMNodeList** aResult)
|
|
{
|
|
NS_IF_ADDREF(*aResult = GetAnonymousNodesFor(aContent));
|
|
return NS_OK;
|
|
}
|
|
|
|
nsINodeList*
|
|
nsBindingManager::GetAnonymousNodesFor(nsIContent* aContent)
|
|
{
|
|
nsXBLBinding* binding = GetBindingWithContent(aContent);
|
|
return binding ? binding->GetAnonymousNodeList() : nullptr;
|
|
}
|
|
|
|
nsresult
|
|
nsBindingManager::ClearBinding(nsIContent* aContent)
|
|
{
|
|
// Hold a ref to the binding so it won't die when we remove it from our table
|
|
RefPtr<nsXBLBinding> binding =
|
|
aContent ? aContent->GetXBLBinding() : nullptr;
|
|
|
|
if (!binding) {
|
|
return NS_OK;
|
|
}
|
|
|
|
// For now we can only handle removing a binding if it's the only one
|
|
NS_ENSURE_FALSE(binding->GetBaseBinding(), NS_ERROR_FAILURE);
|
|
|
|
// Hold strong ref in case removing the binding tries to close the
|
|
// window or something.
|
|
// XXXbz should that be ownerdoc? Wouldn't we need a ref to the
|
|
// currentdoc too? What's the one that should be passed to
|
|
// ChangeDocument?
|
|
nsCOMPtr<nsIDocument> doc = aContent->OwnerDoc();
|
|
|
|
// Finally remove the binding...
|
|
// XXXbz this doesn't remove the implementation! Should fix! Until
|
|
// then we need the explicit UnhookEventHandlers here.
|
|
binding->UnhookEventHandlers();
|
|
binding->ChangeDocument(doc, nullptr);
|
|
aContent->SetXBLBinding(nullptr, this);
|
|
binding->MarkForDeath();
|
|
|
|
// ...and recreate its frames. We need to do this since the frames may have
|
|
// been removed and style may have changed due to the removal of the
|
|
// anonymous children.
|
|
// XXXbz this should be using the current doc (if any), not the owner doc.
|
|
nsIPresShell *presShell = doc->GetShell();
|
|
NS_ENSURE_TRUE(presShell, NS_ERROR_FAILURE);
|
|
|
|
return presShell->RecreateFramesFor(aContent);;
|
|
}
|
|
|
|
nsresult
|
|
nsBindingManager::LoadBindingDocument(nsIDocument* aBoundDoc,
|
|
nsIURI* aURL,
|
|
nsIPrincipal* aOriginPrincipal)
|
|
{
|
|
NS_PRECONDITION(aURL, "Must have a URI to load!");
|
|
|
|
// First we need to load our binding.
|
|
nsXBLService* xblService = nsXBLService::GetInstance();
|
|
if (!xblService)
|
|
return NS_ERROR_FAILURE;
|
|
|
|
// Load the binding doc.
|
|
RefPtr<nsXBLDocumentInfo> info;
|
|
xblService->LoadBindingDocumentInfo(nullptr, aBoundDoc, aURL,
|
|
aOriginPrincipal, true,
|
|
getter_AddRefs(info));
|
|
if (!info)
|
|
return NS_ERROR_FAILURE;
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
void
|
|
nsBindingManager::RemoveFromAttachedQueue(nsXBLBinding* aBinding)
|
|
{
|
|
// Don't remove items here as that could mess up an executing
|
|
// ProcessAttachedQueue. Instead, null the entry in the queue.
|
|
size_t index = mAttachedStack.IndexOf(aBinding);
|
|
if (index != mAttachedStack.NoIndex) {
|
|
mAttachedStack[index] = nullptr;
|
|
}
|
|
}
|
|
|
|
nsresult
|
|
nsBindingManager::AddToAttachedQueue(nsXBLBinding* aBinding)
|
|
{
|
|
mAttachedStack.AppendElement(aBinding);
|
|
|
|
// If we're in the middle of processing our queue already, don't
|
|
// bother posting the event.
|
|
if (!mProcessingAttachedStack && !mProcessAttachedQueueEvent) {
|
|
PostProcessAttachedQueueEvent();
|
|
}
|
|
|
|
// Make sure that flushes will flush out the new items as needed.
|
|
mDocument->SetNeedStyleFlush();
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
void
|
|
nsBindingManager::PostProcessAttachedQueueEvent()
|
|
{
|
|
mProcessAttachedQueueEvent =
|
|
NewRunnableMethod(this, &nsBindingManager::DoProcessAttachedQueue);
|
|
nsresult rv = NS_DispatchToCurrentThread(mProcessAttachedQueueEvent);
|
|
if (NS_SUCCEEDED(rv) && mDocument) {
|
|
mDocument->BlockOnload();
|
|
}
|
|
}
|
|
|
|
// static
|
|
void
|
|
nsBindingManager::PostPAQEventCallback(nsITimer* aTimer, void* aClosure)
|
|
{
|
|
RefPtr<nsBindingManager> mgr =
|
|
already_AddRefed<nsBindingManager>(static_cast<nsBindingManager*>(aClosure));
|
|
mgr->PostProcessAttachedQueueEvent();
|
|
NS_RELEASE(aTimer);
|
|
}
|
|
|
|
void
|
|
nsBindingManager::DoProcessAttachedQueue()
|
|
{
|
|
if (!mProcessingAttachedStack) {
|
|
ProcessAttachedQueue();
|
|
|
|
NS_ASSERTION(mAttachedStack.Length() == 0,
|
|
"Shouldn't have pending bindings!");
|
|
|
|
mProcessAttachedQueueEvent = nullptr;
|
|
} else {
|
|
// Someone's doing event processing from inside a constructor.
|
|
// They're evil, but we'll fight back! Just poll on them being
|
|
// done and repost the attached queue event.
|
|
//
|
|
// But don't poll in a tight loop -- otherwise we keep the Gecko
|
|
// event loop non-empty and trigger bug 1021240 on OS X.
|
|
nsresult rv = NS_ERROR_FAILURE;
|
|
nsCOMPtr<nsITimer> timer = do_CreateInstance(NS_TIMER_CONTRACTID);
|
|
if (timer) {
|
|
rv = timer->InitWithFuncCallback(PostPAQEventCallback, this,
|
|
100, nsITimer::TYPE_ONE_SHOT);
|
|
}
|
|
if (NS_SUCCEEDED(rv)) {
|
|
NS_ADDREF_THIS();
|
|
// We drop our reference to the timer here, since the timer callback is
|
|
// responsible for releasing the object.
|
|
Unused << timer.forget().take();
|
|
}
|
|
}
|
|
|
|
// No matter what, unblock onload for the event that's fired.
|
|
if (mDocument) {
|
|
// Hold a strong reference while calling UnblockOnload since that might
|
|
// run script.
|
|
nsCOMPtr<nsIDocument> doc = mDocument;
|
|
doc->UnblockOnload(true);
|
|
}
|
|
}
|
|
|
|
void
|
|
nsBindingManager::ProcessAttachedQueueInternal(uint32_t aSkipSize)
|
|
{
|
|
mProcessingAttachedStack = true;
|
|
|
|
// Excute constructors. Do this from high index to low
|
|
while (mAttachedStack.Length() > aSkipSize) {
|
|
uint32_t lastItem = mAttachedStack.Length() - 1;
|
|
RefPtr<nsXBLBinding> binding = mAttachedStack.ElementAt(lastItem);
|
|
mAttachedStack.RemoveElementAt(lastItem);
|
|
if (binding) {
|
|
binding->ExecuteAttachedHandler();
|
|
}
|
|
}
|
|
|
|
// If NodeWillBeDestroyed has run we don't want to clobber
|
|
// mProcessingAttachedStack set there.
|
|
if (mDocument) {
|
|
mProcessingAttachedStack = false;
|
|
}
|
|
|
|
NS_ASSERTION(mAttachedStack.Length() == aSkipSize, "How did we get here?");
|
|
|
|
mAttachedStack.Compact();
|
|
}
|
|
|
|
// Keep bindings and bound elements alive while executing detached handlers.
|
|
void
|
|
nsBindingManager::ExecuteDetachedHandlers()
|
|
{
|
|
// Walk our hashtable of bindings.
|
|
if (!mBoundContentSet) {
|
|
return;
|
|
}
|
|
|
|
nsCOMArray<nsIContent> boundElements;
|
|
nsBindingList bindings;
|
|
|
|
for (auto iter = mBoundContentSet->Iter(); !iter.Done(); iter.Next()) {
|
|
nsXBLBinding* binding = iter.Get()->GetKey()->GetXBLBinding();
|
|
if (binding && bindings.AppendElement(binding)) {
|
|
if (!boundElements.AppendObject(binding->GetBoundElement())) {
|
|
bindings.RemoveElementAt(bindings.Length() - 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
uint32_t i, count = bindings.Length();
|
|
for (i = 0; i < count; ++i) {
|
|
bindings[i]->ExecuteDetachedHandler();
|
|
}
|
|
}
|
|
|
|
nsresult
|
|
nsBindingManager::PutXBLDocumentInfo(nsXBLDocumentInfo* aDocumentInfo)
|
|
{
|
|
NS_PRECONDITION(aDocumentInfo, "Must have a non-null documentinfo!");
|
|
|
|
if (!mDocumentTable) {
|
|
mDocumentTable = new nsRefPtrHashtable<nsURIHashKey,nsXBLDocumentInfo>();
|
|
}
|
|
|
|
mDocumentTable->Put(aDocumentInfo->DocumentURI(), aDocumentInfo);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
void
|
|
nsBindingManager::RemoveXBLDocumentInfo(nsXBLDocumentInfo* aDocumentInfo)
|
|
{
|
|
if (mDocumentTable) {
|
|
mDocumentTable->Remove(aDocumentInfo->DocumentURI());
|
|
}
|
|
}
|
|
|
|
nsXBLDocumentInfo*
|
|
nsBindingManager::GetXBLDocumentInfo(nsIURI* aURL)
|
|
{
|
|
if (!mDocumentTable)
|
|
return nullptr;
|
|
|
|
return mDocumentTable->GetWeak(aURL);
|
|
}
|
|
|
|
nsresult
|
|
nsBindingManager::PutLoadingDocListener(nsIURI* aURL, nsIStreamListener* aListener)
|
|
{
|
|
NS_PRECONDITION(aListener, "Must have a non-null listener!");
|
|
|
|
if (!mLoadingDocTable) {
|
|
mLoadingDocTable =
|
|
new nsInterfaceHashtable<nsURIHashKey,nsIStreamListener>();
|
|
}
|
|
mLoadingDocTable->Put(aURL, aListener);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
nsIStreamListener*
|
|
nsBindingManager::GetLoadingDocListener(nsIURI* aURL)
|
|
{
|
|
if (!mLoadingDocTable)
|
|
return nullptr;
|
|
|
|
return mLoadingDocTable->GetWeak(aURL);
|
|
}
|
|
|
|
void
|
|
nsBindingManager::RemoveLoadingDocListener(nsIURI* aURL)
|
|
{
|
|
if (mLoadingDocTable) {
|
|
mLoadingDocTable->Remove(aURL);
|
|
}
|
|
}
|
|
|
|
void
|
|
nsBindingManager::FlushSkinBindings()
|
|
{
|
|
if (!mBoundContentSet) {
|
|
return;
|
|
}
|
|
|
|
for (auto iter = mBoundContentSet->Iter(); !iter.Done(); iter.Next()) {
|
|
nsXBLBinding* binding = iter.Get()->GetKey()->GetXBLBinding();
|
|
|
|
if (binding->MarkedForDeath()) {
|
|
continue;
|
|
}
|
|
|
|
nsAutoCString path;
|
|
binding->PrototypeBinding()->DocURI()->GetPath(path);
|
|
|
|
if (!strncmp(path.get(), "/skin", 5)) {
|
|
binding->MarkForDeath();
|
|
}
|
|
}
|
|
}
|
|
|
|
// Used below to protect from recurring in QI calls through XPConnect.
|
|
struct AntiRecursionData {
|
|
nsIContent* element;
|
|
REFNSIID iid;
|
|
AntiRecursionData* next;
|
|
|
|
AntiRecursionData(nsIContent* aElement,
|
|
REFNSIID aIID,
|
|
AntiRecursionData* aNext)
|
|
: element(aElement), iid(aIID), next(aNext) {}
|
|
};
|
|
|
|
nsresult
|
|
nsBindingManager::GetBindingImplementation(nsIContent* aContent, REFNSIID aIID,
|
|
void** aResult)
|
|
{
|
|
*aResult = nullptr;
|
|
nsXBLBinding *binding = aContent ? aContent->GetXBLBinding() : nullptr;
|
|
if (binding) {
|
|
// The binding should not be asked for nsISupports
|
|
NS_ASSERTION(!aIID.Equals(NS_GET_IID(nsISupports)), "Asking a binding for nsISupports");
|
|
if (binding->ImplementsInterface(aIID)) {
|
|
nsCOMPtr<nsIXPConnectWrappedJS> wrappedJS = GetWrappedJS(aContent);
|
|
|
|
if (wrappedJS) {
|
|
// Protect from recurring in QI calls through XPConnect.
|
|
// This can happen when a second binding is being resolved.
|
|
// At that point a wrappedJS exists, but it doesn't yet know about
|
|
// the iid we are asking for. So, without this protection,
|
|
// AggregatedQueryInterface would end up recurring back into itself
|
|
// through this code.
|
|
//
|
|
// With this protection, when we detect the recursion we return
|
|
// NS_NOINTERFACE in the inner call. The outer call will then fall
|
|
// through (see below) and build a new chained wrappedJS for the iid.
|
|
//
|
|
// We're careful to not assume that only one direct nesting can occur
|
|
// because there is a call into JS in the middle and we can't assume
|
|
// that this code won't be reached by some more complex nesting path.
|
|
//
|
|
// NOTE: We *assume* this is single threaded, so we can use a
|
|
// static linked list to do the check.
|
|
|
|
static AntiRecursionData* list = nullptr;
|
|
|
|
for (AntiRecursionData* p = list; p; p = p->next) {
|
|
if (p->element == aContent && p->iid.Equals(aIID)) {
|
|
*aResult = nullptr;
|
|
return NS_NOINTERFACE;
|
|
}
|
|
}
|
|
|
|
AntiRecursionData item(aContent, aIID, list);
|
|
list = &item;
|
|
|
|
nsresult rv = wrappedJS->AggregatedQueryInterface(aIID, aResult);
|
|
|
|
list = item.next;
|
|
|
|
if (*aResult)
|
|
return rv;
|
|
|
|
// No result was found, so this must be another XBL interface.
|
|
// Fall through to create a new wrapper.
|
|
}
|
|
|
|
// We have never made a wrapper for this implementation.
|
|
// Create an XPC wrapper for the script object and hand it back.
|
|
AutoJSAPI jsapi;
|
|
jsapi.Init();
|
|
JSContext* cx = jsapi.cx();
|
|
|
|
nsIXPConnect *xpConnect = nsContentUtils::XPConnect();
|
|
|
|
JS::Rooted<JSObject*> jsobj(cx, aContent->GetWrapper());
|
|
NS_ENSURE_TRUE(jsobj, NS_NOINTERFACE);
|
|
|
|
// If we're using an XBL scope, we need to use the Xray view to the bound
|
|
// content in order to view the full array of methods defined in the
|
|
// binding, some of which may not be exposed on the prototype of
|
|
// untrusted content. We don't need to consider add-on scopes here
|
|
// because they're chrome-only and no Xrays are involved.
|
|
//
|
|
// If there's no separate XBL scope, or if the reflector itself lives in
|
|
// the XBL scope, we'll end up with the global of the reflector.
|
|
JS::Rooted<JSObject*> xblScope(cx, xpc::GetXBLScopeOrGlobal(cx, jsobj));
|
|
NS_ENSURE_TRUE(xblScope, NS_ERROR_UNEXPECTED);
|
|
JSAutoCompartment ac(cx, xblScope);
|
|
bool ok = JS_WrapObject(cx, &jsobj);
|
|
NS_ENSURE_TRUE(ok, NS_ERROR_OUT_OF_MEMORY);
|
|
MOZ_ASSERT_IF(js::IsWrapper(jsobj), xpc::IsXrayWrapper(jsobj));
|
|
|
|
nsresult rv = xpConnect->WrapJSAggregatedToNative(aContent, cx,
|
|
jsobj, aIID, aResult);
|
|
if (NS_FAILED(rv))
|
|
return rv;
|
|
|
|
// We successfully created a wrapper. We will own this wrapper for as long as the binding remains
|
|
// alive. At the time the binding is cleared out of the bindingManager, we will remove the wrapper
|
|
// from the bindingManager as well.
|
|
nsISupports* supp = static_cast<nsISupports*>(*aResult);
|
|
wrappedJS = do_QueryInterface(supp);
|
|
SetWrappedJS(aContent, wrappedJS);
|
|
|
|
return rv;
|
|
}
|
|
}
|
|
|
|
*aResult = nullptr;
|
|
return NS_NOINTERFACE;
|
|
}
|
|
|
|
nsresult
|
|
nsBindingManager::WalkRules(nsIStyleRuleProcessor::EnumFunc aFunc,
|
|
ElementDependentRuleProcessorData* aData,
|
|
bool* aCutOffInheritance)
|
|
{
|
|
*aCutOffInheritance = false;
|
|
|
|
NS_ASSERTION(aData->mElement, "How did that happen?");
|
|
|
|
// Walk the binding scope chain, starting with the binding attached to our
|
|
// content, up till we run out of scopes or we get cut off.
|
|
nsIContent *content = aData->mElement;
|
|
|
|
do {
|
|
nsXBLBinding *binding = content->GetXBLBinding();
|
|
if (binding) {
|
|
aData->mTreeMatchContext.mScopedRoot = content;
|
|
binding->WalkRules(aFunc, aData);
|
|
// If we're not looking at our original content, allow the binding to cut
|
|
// off style inheritance
|
|
if (content != aData->mElement) {
|
|
if (!binding->InheritsStyle()) {
|
|
// Go no further; we're not inheriting style from anything above here
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (content->IsRootOfNativeAnonymousSubtree()) {
|
|
break; // Deliberately cut off style inheritance here.
|
|
}
|
|
|
|
content = content->GetBindingParent();
|
|
} while (content);
|
|
|
|
// If "content" is non-null that means we cut off inheritance at some point
|
|
// in the loop.
|
|
*aCutOffInheritance = (content != nullptr);
|
|
|
|
// Null out the scoped root that we set repeatedly
|
|
aData->mTreeMatchContext.mScopedRoot = nullptr;
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
typedef nsTHashtable<nsPtrHashKey<nsIStyleRuleProcessor> > RuleProcessorSet;
|
|
|
|
static RuleProcessorSet*
|
|
GetContentSetRuleProcessors(nsTHashtable<nsRefPtrHashKey<nsIContent>>* aContentSet)
|
|
{
|
|
RuleProcessorSet* set = nullptr;
|
|
|
|
for (auto iter = aContentSet->Iter(); !iter.Done(); iter.Next()) {
|
|
nsIContent* boundContent = iter.Get()->GetKey();
|
|
for (nsXBLBinding* binding = boundContent->GetXBLBinding(); binding;
|
|
binding = binding->GetBaseBinding()) {
|
|
nsIStyleRuleProcessor* ruleProc =
|
|
binding->PrototypeBinding()->GetRuleProcessor();
|
|
if (ruleProc) {
|
|
if (!set) {
|
|
set = new RuleProcessorSet;
|
|
}
|
|
set->PutEntry(ruleProc);
|
|
}
|
|
}
|
|
}
|
|
|
|
return set;
|
|
}
|
|
|
|
void
|
|
nsBindingManager::WalkAllRules(nsIStyleRuleProcessor::EnumFunc aFunc,
|
|
ElementDependentRuleProcessorData* aData)
|
|
{
|
|
if (!mBoundContentSet) {
|
|
return;
|
|
}
|
|
|
|
nsAutoPtr<RuleProcessorSet> set;
|
|
set = GetContentSetRuleProcessors(mBoundContentSet);
|
|
if (!set) {
|
|
return;
|
|
}
|
|
|
|
for (auto iter = set->Iter(); !iter.Done(); iter.Next()) {
|
|
nsIStyleRuleProcessor* ruleProcessor = iter.Get()->GetKey();
|
|
(*(aFunc))(ruleProcessor, aData);
|
|
}
|
|
}
|
|
|
|
nsresult
|
|
nsBindingManager::MediumFeaturesChanged(nsPresContext* aPresContext,
|
|
bool* aRulesChanged)
|
|
{
|
|
*aRulesChanged = false;
|
|
if (!mBoundContentSet) {
|
|
return NS_OK;
|
|
}
|
|
|
|
nsAutoPtr<RuleProcessorSet> set;
|
|
set = GetContentSetRuleProcessors(mBoundContentSet);
|
|
if (!set) {
|
|
return NS_OK;
|
|
}
|
|
|
|
for (auto iter = set->Iter(); !iter.Done(); iter.Next()) {
|
|
nsIStyleRuleProcessor* ruleProcessor = iter.Get()->GetKey();
|
|
bool thisChanged = ruleProcessor->MediumFeaturesChanged(aPresContext);
|
|
*aRulesChanged = *aRulesChanged || thisChanged;
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
void
|
|
nsBindingManager::AppendAllSheets(nsTArray<StyleSheet*>& aArray)
|
|
{
|
|
if (!mBoundContentSet) {
|
|
return;
|
|
}
|
|
|
|
for (auto iter = mBoundContentSet->Iter(); !iter.Done(); iter.Next()) {
|
|
nsIContent* boundContent = iter.Get()->GetKey();
|
|
for (nsXBLBinding* binding = boundContent->GetXBLBinding(); binding;
|
|
binding = binding->GetBaseBinding()) {
|
|
binding->PrototypeBinding()->AppendStyleSheetsTo(aArray);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
InsertAppendedContent(XBLChildrenElement* aPoint,
|
|
nsIContent* aFirstNewContent)
|
|
{
|
|
int32_t insertionIndex;
|
|
if (nsIContent* prevSibling = aFirstNewContent->GetPreviousSibling()) {
|
|
// If we have a previous sibling, then it must already be in aPoint. Find
|
|
// it and insert after it.
|
|
insertionIndex = aPoint->IndexOfInsertedChild(prevSibling);
|
|
MOZ_ASSERT(insertionIndex != -1);
|
|
|
|
// Our insertion index is one after our previous sibling's index.
|
|
++insertionIndex;
|
|
} else {
|
|
// Otherwise, we append.
|
|
// TODO This is wrong for nested insertion points. In that case, we need to
|
|
// keep track of the right index to insert into.
|
|
insertionIndex = aPoint->InsertedChildrenLength();
|
|
}
|
|
|
|
// Do the inserting.
|
|
for (nsIContent* currentChild = aFirstNewContent;
|
|
currentChild;
|
|
currentChild = currentChild->GetNextSibling()) {
|
|
aPoint->InsertInsertedChildAt(currentChild, insertionIndex++);
|
|
}
|
|
}
|
|
|
|
void
|
|
nsBindingManager::ContentAppended(nsIDocument* aDocument,
|
|
nsIContent* aContainer,
|
|
nsIContent* aFirstNewContent,
|
|
int32_t aNewIndexInContainer)
|
|
{
|
|
if (aNewIndexInContainer == -1) {
|
|
return;
|
|
}
|
|
|
|
// Try to find insertion points for all the new kids.
|
|
XBLChildrenElement* point = nullptr;
|
|
nsIContent* parent = aContainer;
|
|
|
|
// Handle appending of default content.
|
|
if (parent && parent->IsActiveChildrenElement()) {
|
|
XBLChildrenElement* childrenEl = static_cast<XBLChildrenElement*>(parent);
|
|
if (childrenEl->HasInsertedChildren()) {
|
|
// Appending default content that isn't being used. Ignore.
|
|
return;
|
|
}
|
|
|
|
childrenEl->MaybeSetupDefaultContent();
|
|
parent = childrenEl->GetParent();
|
|
}
|
|
|
|
bool first = true;
|
|
do {
|
|
nsXBLBinding* binding = GetBindingWithContent(parent);
|
|
if (!binding) {
|
|
break;
|
|
}
|
|
|
|
if (binding->HasFilteredInsertionPoints()) {
|
|
// There are filtered insertion points involved, handle each child
|
|
// separately.
|
|
// We could optimize this in the case when we've nested a few levels
|
|
// deep already, without hitting bindings that have filtered insertion
|
|
// points.
|
|
int32_t currentIndex = aNewIndexInContainer;
|
|
for (nsIContent* currentChild = aFirstNewContent; currentChild;
|
|
currentChild = currentChild->GetNextSibling()) {
|
|
HandleChildInsertion(aContainer, currentChild,
|
|
currentIndex++, true);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
point = binding->GetDefaultInsertionPoint();
|
|
if (!point) {
|
|
break;
|
|
}
|
|
|
|
// Even though we're in ContentAppended, nested insertion points force us
|
|
// to deal with this append as an insertion except in the outermost
|
|
// binding.
|
|
if (first) {
|
|
first = false;
|
|
for (nsIContent* child = aFirstNewContent; child;
|
|
child = child->GetNextSibling()) {
|
|
point->AppendInsertedChild(child);
|
|
}
|
|
} else {
|
|
InsertAppendedContent(point, aFirstNewContent);
|
|
}
|
|
|
|
nsIContent* newParent = point->GetParent();
|
|
if (newParent == parent) {
|
|
break;
|
|
}
|
|
parent = newParent;
|
|
} while (parent);
|
|
}
|
|
|
|
void
|
|
nsBindingManager::ContentInserted(nsIDocument* aDocument,
|
|
nsIContent* aContainer,
|
|
nsIContent* aChild,
|
|
int32_t aIndexInContainer)
|
|
{
|
|
if (aIndexInContainer == -1) {
|
|
return;
|
|
}
|
|
|
|
HandleChildInsertion(aContainer, aChild, aIndexInContainer, false);
|
|
}
|
|
|
|
void
|
|
nsBindingManager::ContentRemoved(nsIDocument* aDocument,
|
|
nsIContent* aContainer,
|
|
nsIContent* aChild,
|
|
int32_t aIndexInContainer,
|
|
nsIContent* aPreviousSibling)
|
|
{
|
|
aChild->SetXBLInsertionParent(nullptr);
|
|
|
|
XBLChildrenElement* point = nullptr;
|
|
nsIContent* parent = aContainer;
|
|
|
|
// Handle appending of default content.
|
|
if (parent && parent->IsActiveChildrenElement()) {
|
|
XBLChildrenElement* childrenEl = static_cast<XBLChildrenElement*>(parent);
|
|
if (childrenEl->HasInsertedChildren()) {
|
|
// Removing default content that isn't being used. Ignore.
|
|
return;
|
|
}
|
|
|
|
parent = childrenEl->GetParent();
|
|
}
|
|
|
|
do {
|
|
nsXBLBinding* binding = GetBindingWithContent(parent);
|
|
if (!binding) {
|
|
// If aChild is XBL content, it might have <xbl:children> elements
|
|
// somewhere under it. We need to inform those elements that they're no
|
|
// longer in the tree so they can tell their distributed children that
|
|
// they're no longer distributed under them.
|
|
// XXX This is wrong. We need to do far more work to update the parent
|
|
// binding's list of insertion points and to get the new insertion parent
|
|
// for the newly-distributed children correct.
|
|
if (aChild->GetBindingParent()) {
|
|
ClearInsertionPointsRecursively(aChild);
|
|
}
|
|
return;
|
|
}
|
|
|
|
point = binding->FindInsertionPointFor(aChild);
|
|
if (!point) {
|
|
break;
|
|
}
|
|
|
|
point->RemoveInsertedChild(aChild);
|
|
|
|
nsIContent* newParent = point->GetParent();
|
|
if (newParent == parent) {
|
|
break;
|
|
}
|
|
parent = newParent;
|
|
} while (parent);
|
|
}
|
|
|
|
void
|
|
nsBindingManager::ClearInsertionPointsRecursively(nsIContent* aContent)
|
|
{
|
|
if (aContent->NodeInfo()->Equals(nsGkAtoms::children, kNameSpaceID_XBL)) {
|
|
static_cast<XBLChildrenElement*>(aContent)->ClearInsertedChildren();
|
|
}
|
|
|
|
for (nsIContent* child = aContent->GetFirstChild(); child;
|
|
child = child->GetNextSibling()) {
|
|
ClearInsertionPointsRecursively(child);
|
|
}
|
|
}
|
|
|
|
void
|
|
nsBindingManager::DropDocumentReference()
|
|
{
|
|
mDestroyed = true;
|
|
|
|
// Make sure to not run any more XBL constructors
|
|
mProcessingAttachedStack = true;
|
|
if (mProcessAttachedQueueEvent) {
|
|
mProcessAttachedQueueEvent->Revoke();
|
|
}
|
|
|
|
if (mBoundContentSet) {
|
|
mBoundContentSet->Clear();
|
|
}
|
|
|
|
mDocument = nullptr;
|
|
}
|
|
|
|
void
|
|
nsBindingManager::Traverse(nsIContent *aContent,
|
|
nsCycleCollectionTraversalCallback &cb)
|
|
{
|
|
if (!aContent->HasFlag(NODE_MAY_BE_IN_BINDING_MNGR) ||
|
|
!aContent->IsElement()) {
|
|
// Don't traverse if content is not in this binding manager.
|
|
// We also don't traverse non-elements because there should not
|
|
// be bindings (checking the flag alone is not sufficient because
|
|
// the flag is also set on children of insertion points that may be
|
|
// non-elements).
|
|
return;
|
|
}
|
|
|
|
if (mBoundContentSet && mBoundContentSet->Contains(aContent)) {
|
|
NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb, "[via binding manager] mBoundContentSet entry");
|
|
cb.NoteXPCOMChild(aContent);
|
|
}
|
|
|
|
nsIXPConnectWrappedJS *value = GetWrappedJS(aContent);
|
|
if (value) {
|
|
NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb, "[via binding manager] mWrapperTable key");
|
|
cb.NoteXPCOMChild(aContent);
|
|
NS_CYCLE_COLLECTION_NOTE_EDGE_NAME(cb, "[via binding manager] mWrapperTable value");
|
|
cb.NoteXPCOMChild(value);
|
|
}
|
|
}
|
|
|
|
void
|
|
nsBindingManager::HandleChildInsertion(nsIContent* aContainer,
|
|
nsIContent* aChild,
|
|
uint32_t aIndexInContainer,
|
|
bool aAppend)
|
|
{
|
|
NS_PRECONDITION(aChild, "Must have child");
|
|
NS_PRECONDITION(!aContainer ||
|
|
uint32_t(aContainer->IndexOf(aChild)) == aIndexInContainer,
|
|
"Child not at the right index?");
|
|
|
|
XBLChildrenElement* point = nullptr;
|
|
nsIContent* parent = aContainer;
|
|
|
|
// Handle insertion of default content.
|
|
if (parent && parent->IsActiveChildrenElement()) {
|
|
XBLChildrenElement* childrenEl = static_cast<XBLChildrenElement*>(parent);
|
|
if (childrenEl->HasInsertedChildren()) {
|
|
// Inserting default content that isn't being used. Ignore.
|
|
return;
|
|
}
|
|
|
|
childrenEl->MaybeSetupDefaultContent();
|
|
parent = childrenEl->GetParent();
|
|
}
|
|
|
|
while (parent) {
|
|
nsXBLBinding* binding = GetBindingWithContent(parent);
|
|
if (!binding) {
|
|
break;
|
|
}
|
|
|
|
point = binding->FindInsertionPointFor(aChild);
|
|
if (!point) {
|
|
break;
|
|
}
|
|
|
|
// Insert the child into the proper insertion point.
|
|
// TODO If there were multiple insertion points, this approximation can be
|
|
// wrong. We need to re-run the distribution algorithm. In the meantime,
|
|
// this should work well enough.
|
|
uint32_t index = aAppend ? point->InsertedChildrenLength() : 0;
|
|
for (nsIContent* currentSibling = aChild->GetPreviousSibling();
|
|
currentSibling;
|
|
currentSibling = currentSibling->GetPreviousSibling()) {
|
|
// If we find one of our previous siblings in the insertion point, the
|
|
// index following it is the correct insertion point. Otherwise, we guess
|
|
// based on whether we're appending or inserting.
|
|
int32_t pointIndex = point->IndexOfInsertedChild(currentSibling);
|
|
if (pointIndex != -1) {
|
|
index = pointIndex + 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
point->InsertInsertedChildAt(aChild, index);
|
|
|
|
nsIContent* newParent = point->GetParent();
|
|
if (newParent == parent) {
|
|
break;
|
|
}
|
|
|
|
parent = newParent;
|
|
}
|
|
}
|
|
|
|
|
|
nsIContent*
|
|
nsBindingManager::FindNestedInsertionPoint(nsIContent* aContainer,
|
|
nsIContent* aChild)
|
|
{
|
|
NS_PRECONDITION(aChild->GetParent() == aContainer,
|
|
"Wrong container");
|
|
|
|
nsIContent* parent = aContainer;
|
|
if (aContainer->IsActiveChildrenElement()) {
|
|
if (static_cast<XBLChildrenElement*>(aContainer)->
|
|
HasInsertedChildren()) {
|
|
return nullptr;
|
|
}
|
|
parent = aContainer->GetParent();
|
|
}
|
|
|
|
while (parent) {
|
|
nsXBLBinding* binding = GetBindingWithContent(parent);
|
|
if (!binding) {
|
|
break;
|
|
}
|
|
|
|
XBLChildrenElement* point = binding->FindInsertionPointFor(aChild);
|
|
if (!point) {
|
|
return nullptr;
|
|
}
|
|
|
|
nsIContent* newParent = point->GetParent();
|
|
if (newParent == parent) {
|
|
break;
|
|
}
|
|
parent = newParent;
|
|
}
|
|
|
|
return parent;
|
|
}
|
|
|
|
nsIContent*
|
|
nsBindingManager::FindNestedSingleInsertionPoint(nsIContent* aContainer,
|
|
bool* aMulti)
|
|
{
|
|
*aMulti = false;
|
|
|
|
nsIContent* parent = aContainer;
|
|
if (aContainer->IsActiveChildrenElement()) {
|
|
if (static_cast<XBLChildrenElement*>(aContainer)->
|
|
HasInsertedChildren()) {
|
|
return nullptr;
|
|
}
|
|
parent = aContainer->GetParent();
|
|
}
|
|
|
|
while(parent) {
|
|
nsXBLBinding* binding = GetBindingWithContent(parent);
|
|
if (!binding) {
|
|
break;
|
|
}
|
|
|
|
if (binding->HasFilteredInsertionPoints()) {
|
|
*aMulti = true;
|
|
return nullptr;
|
|
}
|
|
|
|
XBLChildrenElement* point = binding->GetDefaultInsertionPoint();
|
|
if (!point) {
|
|
return nullptr;
|
|
}
|
|
|
|
nsIContent* newParent = point->GetParent();
|
|
if (newParent == parent) {
|
|
break;
|
|
}
|
|
parent = newParent;
|
|
}
|
|
|
|
return parent;
|
|
}
|