--- a/accessible/base/FocusManager.cpp
+++ b/accessible/base/FocusManager.cpp
@@ -288,17 +288,17 @@ FocusManager::ProcessDOMFocus(nsINode* a
DispatchFocusEvent(document, target);
}
}
void
FocusManager::ProcessFocusEvent(AccEvent* aEvent)
{
MOZ_ASSERT(aEvent->GetEventType() == nsIAccessibleEvent::EVENT_FOCUS,
- "Focus event is expected!");
+ "Focus event is expected!");
// Emit focus event if event target is the active item. Otherwise then check
// if it's still focused and then update active item and emit focus event.
Accessible* target = aEvent->GetAccessible();
if (target != mActiveItem) {
// Check if still focused. Otherwise we can end up with storing the active
// item for control that isn't focused anymore.--- a/accessible/base/TextAttrs.cpp
+++ b/accessible/base/TextAttrs.cpp
@@ -33,22 +33,22 @@ TextAttrsMgr::GetAttributes(nsIPersisten
{
// 1. Hyper text accessible must be specified always.
// 2. Offset accessible and result hyper text offsets must be specified in
// the case of text attributes.
// 3. Offset accessible and result hyper text offsets must not be specified
// but include default text attributes flag and attributes list must be
// specified in the case of default text attributes.
MOZ_ASSERT(mHyperTextAcc &&
- ((mOffsetAcc && mOffsetAccIdx != -1 &&
- aStartOffset && aEndOffset) ||
- (!mOffsetAcc && mOffsetAccIdx == -1 &&
- !aStartOffset && !aEndOffset &&
- mIncludeDefAttrs && aAttributes)),
- "Wrong usage of TextAttrsMgr!");
+ ((mOffsetAcc && mOffsetAccIdx != -1 &&
+ aStartOffset && aEndOffset) ||
+ (!mOffsetAcc && mOffsetAccIdx == -1 &&
+ !aStartOffset && !aEndOffset &&
+ mIncludeDefAttrs && aAttributes)),
+ "Wrong usage of TextAttrsMgr!");
// Embedded objects are combined into own range with empty attributes set.
if (mOffsetAcc && !mOffsetAcc->IsText()) {
for (int32_t childIdx = mOffsetAccIdx - 1; childIdx >= 0; childIdx--) {
Accessible* currAcc = mHyperTextAcc->GetChildAt(childIdx);
if (currAcc->IsText())
break;
--- a/docshell/base/nsDocShell.cpp
+++ b/docshell/base/nsDocShell.cpp
@@ -664,17 +664,17 @@ nsDocShell::GetInterface(const nsIID& aI
NS_IMETHODIMP
nsDocShell::LoadURI(nsIURI* aURI,
nsIDocShellLoadInfo* aLoadInfo,
uint32_t aLoadFlags,
bool aFirstParty)
{
MOZ_ASSERT(aLoadInfo || (aLoadFlags & EXTRA_LOAD_FLAGS) == 0,
- "Unexpected flags");
+ "Unexpected flags");
MOZ_ASSERT((aLoadFlags & 0xf) == 0, "Should not have these flags set");
// Note: we allow loads to get through here even if mFiredUnloadEvent is
// true; that case will get handled in LoadInternal or LoadHistoryEntry,
// so we pass false as the second parameter to IsNavigationAllowed.
// However, we don't allow the page to change location *in the middle of*
// firing beforeunload, so we do need to check if *beforeunload* is currently
// firing, so we call IsNavigationAllowed rather than just IsPrintingOrPP.
@@ -9754,17 +9754,17 @@ nsDocShell::InternalLoad(nsIURI* aURI,
rv = CheckLoadingPermissions();
if (NS_FAILED(rv)) {
return rv;
}
if (mFiredUnloadEvent) {
if (IsOKToLoadURI(aURI)) {
MOZ_ASSERT(aWindowTarget.IsEmpty(),
- "Shouldn't have a window target here!");
+ "Shouldn't have a window target here!");
// If this is a replace load, make whatever load triggered
// the unload event also a replace load, so we don't
// create extra history entries.
if (LOAD_TYPE_HAS_FLAGS(aLoadType, LOAD_FLAGS_REPLACE_HISTORY)) {
mLoadType = LOAD_NORMAL_REPLACE;
}
--- a/docshell/shistory/nsSHEntryShared.cpp
+++ b/docshell/shistory/nsSHEntryShared.cpp
@@ -135,17 +135,17 @@ nsSHEntryShared::DropPresentationState()
mRefreshURIList = nullptr;
mEditorData = nullptr;
}
nsresult
nsSHEntryShared::SetContentViewer(nsIContentViewer* aViewer)
{
MOZ_ASSERT(!aViewer || !mContentViewer,
- "SHEntryShared already contains viewer");
+ "SHEntryShared already contains viewer");
if (mContentViewer || !aViewer) {
DropPresentationState();
}
// If we're setting mContentViewer to null, state should already be cleared
// in the DropPresentationState() call above; If we're setting it to a
// non-null content viewer, the entry shouldn't have been tracked either.--- a/dom/base/CharacterData.cpp
+++ b/dom/base/CharacterData.cpp
@@ -62,17 +62,17 @@ CharacterData::CharacterData(already_Add
mNodeInfo->NodeType() == PROCESSING_INSTRUCTION_NODE ||
mNodeInfo->NodeType() == DOCUMENT_TYPE_NODE,
"Bad NodeType in aNodeInfo");
}
CharacterData::~CharacterData()
{
MOZ_ASSERT(!IsInUncomposedDoc(),
- "Please remove this from the document properly");
+ "Please remove this from the document properly");
if (GetParent()) {
NS_RELEASE(mParent);
}
}
NS_IMPL_CYCLE_COLLECTION_CLASS(CharacterData)
NS_IMPL_CYCLE_COLLECTION_TRACE_WRAPPERCACHE(CharacterData)
@@ -242,17 +242,17 @@ CharacterData::ReplaceData(uint32_t aOff
nsresult
CharacterData::SetTextInternal(uint32_t aOffset, uint32_t aCount,
const char16_t* aBuffer,
uint32_t aLength, bool aNotify,
CharacterDataChangeInfo::Details* aDetails)
{
MOZ_ASSERT(aBuffer || !aLength,
- "Null buffer passed to SetTextInternal!");
+ "Null buffer passed to SetTextInternal!");
// sanitize arguments
uint32_t textLength = mText.GetLength();
if (aOffset > textLength) {
return NS_ERROR_DOM_INDEX_SIZE_ERR;
}
if (aCount > textLength - aOffset) {
@@ -443,36 +443,36 @@ CharacterData::ToCString(nsAString& aBuf
nsresult
CharacterData::BindToTree(nsIDocument* aDocument, nsIContent* aParent,
nsIContent* aBindingParent,
bool aCompileEventHandlers)
{
MOZ_ASSERT(aParent || aDocument, "Must have document if no parent!");
MOZ_ASSERT(NODE_FROM(aParent, aDocument)->OwnerDoc() == OwnerDoc(),
- "Must have the same owner document");
+ "Must have the same owner document");
MOZ_ASSERT(!aParent || aDocument == aParent->GetUncomposedDoc(),
- "aDocument must be current doc of aParent");
+ "aDocument must be current doc of aParent");
MOZ_ASSERT(!GetUncomposedDoc() && !IsInUncomposedDoc(),
- "Already have a document. Unbind first!");
+ "Already have a document. Unbind first!");
// Note that as we recurse into the kids, they'll have a non-null parent. So
// only assert if our parent is _changing_ while we have a parent.
MOZ_ASSERT(!GetParent() || aParent == GetParent(),
- "Already have a parent. Unbind first!");
+ "Already have a parent. Unbind first!");
MOZ_ASSERT(!GetBindingParent() ||
- aBindingParent == GetBindingParent() ||
- (!aBindingParent && aParent &&
- aParent->GetBindingParent() == GetBindingParent()),
- "Already have a binding parent. Unbind first!");
+ aBindingParent == GetBindingParent() ||
+ (!aBindingParent && aParent &&
+ aParent->GetBindingParent() == GetBindingParent()),
+ "Already have a binding parent. Unbind first!");
MOZ_ASSERT(aBindingParent != this,
- "Content must not be its own binding parent");
+ "Content must not be its own binding parent");
MOZ_ASSERT(!IsRootOfNativeAnonymousSubtree() ||
- aBindingParent == aParent,
- "Native anonymous content must have its parent as its "
- "own binding parent");
+ aBindingParent == aParent,
+ "Native anonymous content must have its parent as its "
+ "own binding parent");
if (!aBindingParent && aParent) {
aBindingParent = aParent->GetBindingParent();
}
// First set the binding parent
if (aBindingParent) {
NS_ASSERTION(IsRootOfNativeAnonymousSubtree() ||--- a/dom/base/Element.cpp
+++ b/dom/base/Element.cpp
@@ -1531,38 +1531,38 @@ EditableInclusiveDescendantCount(nsICont
nsresult
Element::BindToTree(nsIDocument* aDocument, nsIContent* aParent,
nsIContent* aBindingParent,
bool aCompileEventHandlers)
{
MOZ_ASSERT(aParent || aDocument, "Must have document if no parent!");
MOZ_ASSERT((NODE_FROM(aParent, aDocument)->OwnerDoc() == OwnerDoc()),
- "Must have the same owner document");
+ "Must have the same owner document");
MOZ_ASSERT(!aParent || aDocument == aParent->GetUncomposedDoc(),
- "aDocument must be current doc of aParent");
+ "aDocument must be current doc of aParent");
MOZ_ASSERT(!GetUncomposedDoc(), "Already have a document. Unbind first!");
// Note that as we recurse into the kids, they'll have a non-null parent. So
// only assert if our parent is _changing_ while we have a parent.
MOZ_ASSERT(!GetParent() || aParent == GetParent(),
- "Already have a parent. Unbind first!");
+ "Already have a parent. Unbind first!");
MOZ_ASSERT(!GetBindingParent() ||
- aBindingParent == GetBindingParent() ||
- (!aBindingParent && aParent &&
- aParent->GetBindingParent() == GetBindingParent()),
- "Already have a binding parent. Unbind first!");
+ aBindingParent == GetBindingParent() ||
+ (!aBindingParent && aParent &&
+ aParent->GetBindingParent() == GetBindingParent()),
+ "Already have a binding parent. Unbind first!");
MOZ_ASSERT(aBindingParent != this,
- "Content must not be its own binding parent");
+ "Content must not be its own binding parent");
MOZ_ASSERT(!IsRootOfNativeAnonymousSubtree() ||
- aBindingParent == aParent,
- "Native anonymous content must have its parent as its "
- "own binding parent");
+ aBindingParent == aParent,
+ "Native anonymous content must have its parent as its "
+ "own binding parent");
MOZ_ASSERT(aBindingParent || !aParent ||
- aBindingParent == aParent->GetBindingParent(),
- "We should be passed the right binding parent");
+ aBindingParent == aParent->GetBindingParent(),
+ "We should be passed the right binding parent");
#ifdef MOZ_XUL
// First set the binding parent
nsXULElement* xulElem = nsXULElement::FromNode(this);
if (xulElem) {
xulElem->SetXULBindingParent(aBindingParent);
}
else--- a/dom/base/Element.h
+++ b/dom/base/Element.h
@@ -599,31 +599,31 @@ private:
protected:
// Methods for the ESM, nsGlobalWindow and focus manager to manage state bits.
// These will handle setting up script blockers when they notify, so no need
// to do it in the callers unless desired. States passed here must only be
// those in EXTERNALLY_MANAGED_STATES.
virtual void AddStates(EventStates aStates)
{
MOZ_ASSERT(!aStates.HasAtLeastOneOfStates(INTRINSIC_STATES),
- "Should only be adding externally-managed states here");
+ "Should only be adding externally-managed states here");
AddStatesSilently(aStates);
NotifyStateChange(aStates);
}
virtual void RemoveStates(EventStates aStates)
{
MOZ_ASSERT(!aStates.HasAtLeastOneOfStates(INTRINSIC_STATES),
- "Should only be removing externally-managed states here");
+ "Should only be removing externally-managed states here");
RemoveStatesSilently(aStates);
NotifyStateChange(aStates);
}
virtual void ToggleStates(EventStates aStates, bool aNotify)
{
MOZ_ASSERT(!aStates.HasAtLeastOneOfStates(INTRINSIC_STATES),
- "Should only be removing externally-managed states here");
+ "Should only be removing externally-managed states here");
mState ^= aStates;
if (aNotify) {
NotifyStateChange(aStates);
}
}
public:
// Public methods to manage state bits in MANUALLY_MANAGED_STATES.--- a/dom/base/EventSource.cpp
+++ b/dom/base/EventSource.cpp
@@ -1368,18 +1368,17 @@ EventSourceImpl::TimerCallback(nsITimer*
{
AssertIsOnMainThread();
RefPtr<EventSourceImpl> thisObject = static_cast<EventSourceImpl*>(aClosure);
if (thisObject->IsClosed()) {
return;
}
- MOZ_ASSERT(!thisObject->mHttpChannel,
- "the channel hasn't been cancelled!!");
+ MOZ_ASSERT(!thisObject->mHttpChannel, "the channel hasn't been cancelled!!");
if (!thisObject->IsFrozen()) {
nsresult rv = thisObject->InitChannelAndRequestEventSource();
if (NS_FAILED(rv)) {
NS_WARNING("thisObject->InitChannelAndRequestEventSource() failed");
return;
}
}--- a/dom/base/FragmentOrElement.cpp
+++ b/dom/base/FragmentOrElement.cpp
@@ -810,17 +810,17 @@ FragmentOrElement::FragmentOrElement(alr
FragmentOrElement::FragmentOrElement(already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo)
: nsIContent(aNodeInfo)
{
}
FragmentOrElement::~FragmentOrElement()
{
MOZ_ASSERT(!IsInUncomposedDoc(),
- "Please remove this from the document properly");
+ "Please remove this from the document properly");
if (GetParent()) {
NS_RELEASE(mParent);
}
}
already_AddRefed<nsINodeList>
FragmentOrElement::GetChildren(uint32_t aFilter)
{--- a/dom/base/nsAttrAndChildArray.cpp
+++ b/dom/base/nsAttrAndChildArray.cpp
@@ -960,9 +960,8 @@ nsAttrAndChildArray::SizeOfExcludingThis
for (uint32_t i = 0; i < slotCount && AttrSlotIsTaken(i); ++i) {
nsAttrValue* value = &ATTRS(mImpl)[i].mValue;
n += value->SizeOfExcludingThis(aMallocSizeOf);
}
}
return n;
}
---- a/dom/base/nsAttrValue.cpp
+++ b/dom/base/nsAttrValue.cpp
@@ -1396,17 +1396,17 @@ nsAttrValue::ParseEnumValue(const nsAStr
return true;
}
tableEntry++;
}
if (aDefaultValue) {
MOZ_ASSERT(aTable <= aDefaultValue && aDefaultValue < tableEntry,
- "aDefaultValue not inside aTable?");
+ "aDefaultValue not inside aTable?");
SetIntValueAndType(EnumTableEntryToValue(aTable, aDefaultValue),
eEnum, &aValue);
return true;
}
return false;
}
@@ -1960,9 +1960,8 @@ nsAttrValue::SizeOfExcludingThis(MallocS
}
case eAtomBase: // Atoms are counted separately.
case eIntegerBase: // The value is in mBits, nothing to do.
break;
}
return n;
}
---- a/dom/base/nsContentAreaDragDrop.cpp
+++ b/dom/base/nsContentAreaDragDrop.cpp
@@ -538,17 +538,17 @@ DragDataProducer::GetImageData(imgIConta
nsresult
DragDataProducer::Produce(DataTransfer* aDataTransfer,
bool* aCanDrag,
nsISelection** aSelection,
nsIContent** aDragNode,
nsACString& aPrincipalURISpec)
{
MOZ_ASSERT(aCanDrag && aSelection && aDataTransfer && aDragNode,
- "null pointer passed to Produce");
+ "null pointer passed to Produce");
NS_ASSERTION(mWindow, "window not set");
NS_ASSERTION(mSelectionTargetNode, "selection target node should have been set");
*aDragNode = nullptr;
nsresult rv;
nsIContent* dragNode = nullptr;
*aSelection = nullptr;--- a/dom/base/nsContentList.cpp
+++ b/dom/base/nsContentList.cpp
@@ -824,17 +824,17 @@ nsContentList::Match(Element *aElement)
ni->Equals(mXMLMatchAtom, mMatchNameSpaceId);
}
bool
nsContentList::MatchSelf(nsIContent *aContent)
{
MOZ_ASSERT(aContent, "Can't match null stuff, you know");
MOZ_ASSERT(mDeep || aContent->GetParentNode() == mRootNode,
- "MatchSelf called on a node that we can't possibly match");
+ "MatchSelf called on a node that we can't possibly match");
if (!aContent->IsElement()) {
return false;
}
if (Match(aContent->AsElement()))
return true;
--- a/dom/base/nsContentList.h
+++ b/dom/base/nsContentList.h
@@ -383,17 +383,17 @@ public:
bool MatchesKey(const nsContentListKey& aKey) const
{
// The root node is most commonly the same: the document. And the
// most common namespace id is kNameSpaceID_Unknown. So check the
// string first. Cases in which whether our root's ownerDocument
// is HTML changes are extremely rare, so check those last.
MOZ_ASSERT(mXMLMatchAtom,
- "How did we get here with a null match atom on our list?");
+ "How did we get here with a null match atom on our list?");
return
mXMLMatchAtom->Equals(aKey.mTagname) &&
mRootNode == aKey.mRootNode &&
mMatchNameSpaceId == aKey.mMatchNameSpaceId &&
mIsHTMLDocument == aKey.mIsHTMLDocument;
}
/**--- a/dom/base/nsContentUtils.cpp
+++ b/dom/base/nsContentUtils.cpp
@@ -5402,20 +5402,18 @@ nsContentUtils::HasNonEmptyTextContent(n
return false;
}
/* static */
bool
nsContentUtils::IsInSameAnonymousTree(const nsINode* aNode,
const nsIContent* aContent)
{
- MOZ_ASSERT(aNode,
- "Must have a node to work with");
- MOZ_ASSERT(aContent,
- "Must have a content to work with");
+ MOZ_ASSERT(aNode, "Must have a node to work with");
+ MOZ_ASSERT(aContent, "Must have a content to work with");
if (!aNode->IsContent()) {
/**
* The root isn't an nsIContent, so it's a document or attribute. The only
* nodes in the same anonymous subtree as it will have a null
* bindingParent.
*
* XXXbz strictly speaking, that's not true for attribute nodes.--- a/dom/base/nsDocument.cpp
+++ b/dom/base/nsDocument.cpp
@@ -955,17 +955,17 @@ TransferShowingState(nsIDocument* aFromD
nsresult
nsExternalResourceMap::AddExternalResource(nsIURI* aURI,
nsIContentViewer* aViewer,
nsILoadGroup* aLoadGroup,
nsIDocument* aDisplayDocument)
{
MOZ_ASSERT(aURI, "Unexpected call");
MOZ_ASSERT((aViewer && aLoadGroup) || (!aViewer && !aLoadGroup),
- "Must have both or neither");
+ "Must have both or neither");
RefPtr<PendingLoad> load;
mPendingLoads.Remove(aURI, getter_AddRefs(load));
nsresult rv = NS_OK;
nsCOMPtr<nsIDocument> doc;
if (aViewer) {
@@ -2527,17 +2527,17 @@ AppendSheetsToStyleSet(ServoStyleSet* aS
}
void
nsIDocument::FillStyleSet(ServoStyleSet* aStyleSet)
{
MOZ_ASSERT(aStyleSet, "Must have a style set");
MOZ_ASSERT(aStyleSet->SheetCount(SheetType::Doc) == 0,
- "Style set already has document sheets?");
+ "Style set already has document sheets?");
MOZ_ASSERT(!mStyleSetFilled);
for (StyleSheet* sheet : Reversed(mStyleSheets)) {
if (sheet->IsApplicable()) {
aStyleSet->AddDocStyleSheet(sheet, this);
}
}
@@ -4410,17 +4410,17 @@ nsIDocument::RemoveStyleSheet(StyleSheet
void
nsIDocument::UpdateStyleSheets(nsTArray<RefPtr<StyleSheet>>& aOldSheets,
nsTArray<RefPtr<StyleSheet>>& aNewSheets)
{
BeginUpdate(UPDATE_STYLE);
// XXX Need to set the sheet on the ownernode, if any
MOZ_ASSERT(aOldSheets.Length() == aNewSheets.Length(),
- "The lists must be the same length!");
+ "The lists must be the same length!");
int32_t count = aOldSheets.Length();
RefPtr<StyleSheet> oldSheet;
int32_t i;
for (i = 0; i < count; ++i) {
oldSheet = aOldSheets[i];
// First remove the old sheet.
@@ -5481,17 +5481,17 @@ nsIDocument::UnblockDOMContentLoaded()
DispatchContentLoadedEvents();
}
}
void
nsIDocument::ContentStateChanged(nsIContent* aContent, EventStates aStateMask)
{
MOZ_ASSERT(!nsContentUtils::IsSafeToRunScript(),
- "Someone forgot a scriptblocker");
+ "Someone forgot a scriptblocker");
NS_DOCUMENT_NOTIFY_OBSERVERS(ContentStateChanged,
(this, aContent, aStateMask));
}
void
nsIDocument::DocumentStatesChanged(EventStates aStateMask)
{
UpdateDocumentStates(aStateMask);
@@ -8393,18 +8393,18 @@ nsIDocument::PostUnblockOnloadEvent()
}
void
nsIDocument::DoUnblockOnload()
{
MOZ_ASSERT(!mDisplayDocument,
"Shouldn't get here for resource document");
MOZ_ASSERT(mOnloadBlockCount != 0,
- "Shouldn't have a count of zero here, since we stabilized in "
- "PostUnblockOnloadEvent");
+ "Shouldn't have a count of zero here, since we stabilized in "
+ "PostUnblockOnloadEvent");
--mOnloadBlockCount;
if (mOnloadBlockCount != 0) {
// We blocked again after the last unblock. Nothing to do here. We'll
// post a new event when we unblock again.
return;
}--- a/dom/base/nsGlobalWindowInner.cpp
+++ b/dom/base/nsGlobalWindowInner.cpp
@@ -1663,17 +1663,17 @@ nsGlobalWindowInner::GetPopupControlStat
}
nsresult
nsGlobalWindowInner::SetNewDocument(nsIDocument* aDocument,
nsISupports* aState,
bool aForceReuseInnerWindow)
{
MOZ_ASSERT(mDocumentPrincipal == nullptr,
- "mDocumentPrincipal prematurely set!");
+ "mDocumentPrincipal prematurely set!");
MOZ_ASSERT(aDocument);
if (!mOuterWindow) {
return NS_ERROR_NOT_INITIALIZED;
}
// Refuse to set a new document if the call came from an inner
// window that's not the current inner window.--- a/dom/base/nsGlobalWindowOuter.cpp
+++ b/dom/base/nsGlobalWindowOuter.cpp
@@ -6898,19 +6898,19 @@ nsGlobalWindowOuter::OpenInternal(const
{
#ifdef DEBUG
uint32_t argc = 0;
if (argv)
argv->GetLength(&argc);
#endif
MOZ_ASSERT(!aExtraArgument || (!argv && argc == 0),
- "Can't pass in arguments both ways");
+ "Can't pass in arguments both ways");
MOZ_ASSERT(!aCalledNoScript || (!argv && argc == 0),
- "Can't pass JS args when called via the noscript methods");
+ "Can't pass JS args when called via the noscript methods");
mozilla::Maybe<AutoUnblockScriptClosing> closeUnblocker;
// Calls to window.open from script should navigate.
MOZ_ASSERT(aCalledNoScript || aNavigate);
*aReturn = nullptr;
--- a/dom/base/nsImageLoadingContent.cpp
+++ b/dom/base/nsImageLoadingContent.cpp
@@ -144,17 +144,17 @@ nsImageLoadingContent::Notify(imgIReques
return NS_OK;
}
if (aType == imgINotificationObserver::LOAD_COMPLETE) {
// We should definitely have a request here
MOZ_ASSERT(aRequest, "no request?");
MOZ_ASSERT(aRequest == mCurrentRequest || aRequest == mPendingRequest,
- "Unknown request");
+ "Unknown request");
}
{
// Calling Notify on observers can modify the list of observers so make
// a local copy.
AutoTArray<nsCOMPtr<imgINotificationObserver>, 2> observers;
for (ImageObserver* observer = &mObserverList, *next; observer;
observer = next) {
@@ -1743,9 +1743,9 @@ nsImageLoadingContent::ScriptedImageObse
}
// Only HTMLInputElement.h overrides this for <img> tags
// all other subclasses use this one, i.e. ignore referrer attributes
mozilla::net::ReferrerPolicy
nsImageLoadingContent::GetImageReferrerPolicy()
{
return mozilla::net::RP_Unset;
-};
+}--- a/dom/base/nsNodeUtils.cpp
+++ b/dom/base/nsNodeUtils.cpp
@@ -206,29 +206,29 @@ nsNodeUtils::NativeAnonymousChildListCha
isRemove);
}
void
nsNodeUtils::ContentInserted(nsINode* aContainer,
nsIContent* aChild)
{
MOZ_ASSERT(aContainer->IsContent() || aContainer->IsDocument(),
- "container must be an nsIContent or an nsIDocument");
+ "container must be an nsIContent or an nsIDocument");
nsIDocument* doc = aContainer->OwnerDoc();
IMPL_MUTATION_NOTIFICATION(ContentInserted, aContainer, (aChild),
IsRemoveNotification::No);
}
void
nsNodeUtils::ContentRemoved(nsINode* aContainer,
nsIContent* aChild,
nsIContent* aPreviousSibling)
{
MOZ_ASSERT(aContainer->IsContent() || aContainer->IsDocument(),
- "container must be an nsIContent or an nsIDocument");
+ "container must be an nsIContent or an nsIDocument");
nsIDocument* doc = aContainer->OwnerDoc();
MOZ_ASSERT(aChild->GetParentNode() == aContainer,
"We expect the parent link to be still around at this point");
IMPL_MUTATION_NOTIFICATION(ContentRemoved, aContainer,
(aChild, aPreviousSibling),
IsRemoveNotification::Yes);
}
@@ -379,20 +379,19 @@ nsNodeUtils::CloneNodeImpl(nsINode *aNod
already_AddRefed<nsINode>
nsNodeUtils::CloneAndAdopt(nsINode *aNode, bool aClone, bool aDeep,
nsNodeInfoManager *aNewNodeInfoManager,
JS::Handle<JSObject*> aReparentScope,
nsCOMArray<nsINode> *aNodesWithProperties,
nsINode* aParent, ErrorResult& aError)
{
MOZ_ASSERT((!aClone && aNewNodeInfoManager) || !aReparentScope,
- "If cloning or not getting a new nodeinfo we shouldn't "
- "rewrap");
+ "If cloning or not getting a new nodeinfo we shouldn't rewrap");
MOZ_ASSERT(!aParent || aNode->IsContent(),
- "Can't insert document or attribute nodes into a parent");
+ "Can't insert document or attribute nodes into a parent");
// First deal with aNode and walk its attributes (and their children). Then,
// if aDeep is true, deal with aNode's children (and recurse into their
// attributes and children).
nsAutoScriptBlocker scriptBlocker;
nsNodeInfoManager *nodeInfoManager = aNewNodeInfoManager;
@@ -708,9 +707,8 @@ nsNodeUtils::GetFirstChildOfTemplateOrNo
if (nsNodeUtils::IsTemplateElement(aNode)) {
DocumentFragment* frag =
static_cast<HTMLTemplateElement*>(aNode)->Content();
return frag->GetFirstChild();
}
return aNode->GetFirstChild();
}
---- a/dom/base/nsRange.cpp
+++ b/dom/base/nsRange.cpp
@@ -960,38 +960,41 @@ nsRange::NotifySelectionListenersAfterRa
// Calling DoSetRange with either parent argument null will collapse
// the range to have both endpoints point to the other node
void
nsRange::DoSetRange(const RawRangeBoundary& aStart,
const RawRangeBoundary& aEnd,
nsINode* aRoot, bool aNotInsertedYet)
{
MOZ_ASSERT((aStart.IsSet() && aEnd.IsSet() && aRoot) ||
- (!aStart.IsSet() && !aEnd.IsSet() && !aRoot),
- "Set all or none");
+ (!aStart.IsSet() && !aEnd.IsSet() && !aRoot),
+ "Set all or none");
+
MOZ_ASSERT(!aRoot || aNotInsertedYet ||
- (nsContentUtils::ContentIsDescendantOf(aStart.Container(), aRoot) &&
- nsContentUtils::ContentIsDescendantOf(aEnd.Container(), aRoot) &&
- aRoot == IsValidBoundary(aStart.Container()) &&
- aRoot == IsValidBoundary(aEnd.Container())),
- "Wrong root");
+ (nsContentUtils::ContentIsDescendantOf(aStart.Container(), aRoot) &&
+ nsContentUtils::ContentIsDescendantOf(aEnd.Container(), aRoot) &&
+ aRoot == IsValidBoundary(aStart.Container()) &&
+ aRoot == IsValidBoundary(aEnd.Container())),
+ "Wrong root");
+
MOZ_ASSERT(!aRoot ||
- (aStart.Container()->IsContent() &&
- aEnd.Container()->IsContent() &&
- aRoot ==
- static_cast<nsIContent*>(aStart.Container())->GetBindingParent() &&
- aRoot ==
- static_cast<nsIContent*>(aEnd.Container())->GetBindingParent()) ||
- (!aRoot->GetParentNode() &&
- (aRoot->IsDocument() ||
- aRoot->IsAttr() ||
- aRoot->IsDocumentFragment() ||
- /*For backward compatibility*/
- aRoot->IsContent())),
- "Bad root");
+ (aStart.Container()->IsContent() &&
+ aEnd.Container()->IsContent() &&
+ aRoot ==
+ static_cast<nsIContent*>(aStart.Container())->GetBindingParent() &&
+ aRoot ==
+ static_cast<nsIContent*>(aEnd.Container())->GetBindingParent()) ||
+ (!aRoot->GetParentNode() &&
+ (aRoot->IsDocument() ||
+ aRoot->IsAttr() ||
+ aRoot->IsDocumentFragment() ||
+ /*For backward compatibility*/
+ aRoot->IsContent())),
+ "Bad root");
+
if (mRoot != aRoot) {
if (mRoot) {
mRoot->RemoveMutationObserver(this);
}
if (aRoot) {
aRoot->AddMutationObserver(this);
}
}--- a/dom/base/nsTextNode.cpp
+++ b/dom/base/nsTextNode.cpp
@@ -235,17 +235,17 @@ NS_IMPL_ISUPPORTS_INHERITED(nsAttributeT
nsIMutationObserver)
nsresult
nsAttributeTextNode::BindToTree(nsIDocument* aDocument, nsIContent* aParent,
nsIContent* aBindingParent,
bool aCompileEventHandlers)
{
MOZ_ASSERT(aParent && aParent->GetParent(),
- "This node can't be a child of the document or of the document root");
+ "This node can't be a child of the document or of the document root");
nsresult rv = nsTextNode::BindToTree(aDocument, aParent,
aBindingParent, aCompileEventHandlers);
NS_ENSURE_SUCCESS(rv, rv);
NS_ASSERTION(!mGrandparent, "We were already bound!");
mGrandparent = aParent->GetParent()->AsElement();
mGrandparent->AddMutationObserver(this);
@@ -300,9 +300,8 @@ void
nsAttributeTextNode::UpdateText(bool aNotify)
{
if (mGrandparent) {
nsAutoString attrValue;
mGrandparent->GetAttr(mNameSpaceID, mAttrName, attrValue);
SetText(attrValue, aNotify);
}
}
---- a/dom/events/EventStateManager.cpp
+++ b/dom/events/EventStateManager.cpp
@@ -5268,20 +5268,20 @@ EventStateManager::UpdateAncestorState(n
}
bool
EventStateManager::SetContentState(nsIContent* aContent, EventStates aState)
{
// We manage 4 states here: ACTIVE, HOVER, DRAGOVER, URLTARGET
// The input must be exactly one of them.
MOZ_ASSERT(aState == NS_EVENT_STATE_ACTIVE ||
- aState == NS_EVENT_STATE_HOVER ||
- aState == NS_EVENT_STATE_DRAGOVER ||
- aState == NS_EVENT_STATE_URLTARGET,
- "Unexpected state");
+ aState == NS_EVENT_STATE_HOVER ||
+ aState == NS_EVENT_STATE_DRAGOVER ||
+ aState == NS_EVENT_STATE_URLTARGET,
+ "Unexpected state");
nsCOMPtr<nsIContent> notifyContent1;
nsCOMPtr<nsIContent> notifyContent2;
bool updateAncestors;
if (aState == NS_EVENT_STATE_HOVER || aState == NS_EVENT_STATE_ACTIVE) {
// Hover and active are hierarchical
updateAncestors = true;--- a/dom/html/HTMLFormElement.cpp
+++ b/dom/html/HTMLFormElement.cpp
@@ -1758,18 +1758,18 @@ HTMLFormElement::GetActionURL(nsIURI** a
return rv;
}
NS_IMETHODIMP_(nsIFormControl*)
HTMLFormElement::GetDefaultSubmitElement() const
{
MOZ_ASSERT(mDefaultSubmitElement == mFirstSubmitInElements ||
- mDefaultSubmitElement == mFirstSubmitNotInElements,
- "What happened here?");
+ mDefaultSubmitElement == mFirstSubmitNotInElements,
+ "What happened here?");
return mDefaultSubmitElement;
}
bool
HTMLFormElement::IsDefaultSubmitElement(const nsIFormControl* aControl) const
{
MOZ_ASSERT(aControl, "Unexpected call");--- a/dom/html/HTMLInputElement.cpp
+++ b/dom/html/HTMLInputElement.cpp
@@ -2790,17 +2790,17 @@ HTMLInputElement::UpdateFileList()
}
nsresult
HTMLInputElement::SetValueInternal(const nsAString& aValue,
const nsAString* aOldValue,
uint32_t aFlags)
{
MOZ_ASSERT(GetValueMode() != VALUE_MODE_FILENAME,
- "Don't call SetValueInternal for file inputs");
+ "Don't call SetValueInternal for file inputs");
// We want to remember if the SetValueInternal() call is being made for a XUL
// element. We do that by looking at the parent node here, and if that node
// is a XUL node, we consider our control a XUL control.
nsIContent* parent = GetParent();
if (parent && parent->IsXULElement()) {
aFlags |= nsTextEditorState::eSetValue_ForXUL;
}--- a/dom/html/nsGenericHTMLElement.cpp
+++ b/dom/html/nsGenericHTMLElement.cpp
@@ -540,17 +540,17 @@ nsGenericHTMLElement::FindAncestorForm(H
return nullptr;
}
bool
nsGenericHTMLElement::CheckHandleEventForAnchorsPreconditions(
EventChainVisitor& aVisitor)
{
MOZ_ASSERT(nsCOMPtr<Link>(do_QueryObject(this)),
- "should be called only when |this| implements |Link|");
+ "should be called only when |this| implements |Link|");
if (!aVisitor.mPresContext) {
// We need a pres context to do link stuff. Some events (e.g. mutation
// events) don't have one.
// XXX: ideally, shouldn't we be able to do what we need without one?
return false;
}
@@ -2219,17 +2219,17 @@ nsGenericHTMLFormElement::IsElementDisab
return IsDisabled();
}
void
nsGenericHTMLFormElement::UpdateFormOwner(bool aBindToTree,
Element* aFormIdElement)
{
MOZ_ASSERT(!aBindToTree || !aFormIdElement,
- "aFormIdElement shouldn't be set if aBindToTree is true!");
+ "aFormIdElement shouldn't be set if aBindToTree is true!");
bool needStateUpdate = false;
if (!aBindToTree) {
needStateUpdate = mForm && mForm->IsDefaultSubmitElement(this);
ClearForm(true, false);
}
HTMLFormElement *oldForm = mForm;--- a/dom/security/nsCSPContext.cpp
+++ b/dom/security/nsCSPContext.cpp
@@ -730,17 +730,17 @@ nsCSPContext::LogViolationDetails(uint16
#undef CASE_CHECK_AND_REPORT
NS_IMETHODIMP
nsCSPContext::SetRequestContext(nsIDOMDocument* aDOMDocument,
nsIPrincipal* aPrincipal)
{
MOZ_ASSERT(aDOMDocument || aPrincipal,
- "Can't set context without doc or principal");
+ "Can't set context without doc or principal");
NS_ENSURE_ARG(aDOMDocument || aPrincipal);
if (aDOMDocument) {
nsCOMPtr<nsIDocument> doc = do_QueryInterface(aDOMDocument);
mLoadingContext = do_GetWeakReference(doc);
mSelfURI = doc->GetDocumentURI();
mLoadingPrincipal = doc->NodePrincipal();
doc->GetReferrer(mReferrer);--- a/dom/smil/SMILBoolType.cpp
+++ b/dom/smil/SMILBoolType.cpp
@@ -45,18 +45,17 @@ SMILBoolType::IsEqual(const nsSMILValue&
return aLeft.mU.mBool == aRight.mU.mBool;
}
nsresult
SMILBoolType::Add(nsSMILValue& aDest, const nsSMILValue& aValueToAdd,
uint32_t aCount) const
{
- MOZ_ASSERT(aValueToAdd.mType == aDest.mType,
- "Trying to add invalid types");
+ MOZ_ASSERT(aValueToAdd.mType == aDest.mType, "Trying to add invalid types");
MOZ_ASSERT(aValueToAdd.mType == this, "Unexpected source type");
return NS_ERROR_FAILURE; // bool values can't be added to each other
}
nsresult
SMILBoolType::ComputeDistance(const nsSMILValue& aFrom,
const nsSMILValue& aTo,
double& aDistance) const
@@ -68,16 +67,16 @@ SMILBoolType::ComputeDistance(const nsSM
nsresult
SMILBoolType::Interpolate(const nsSMILValue& aStartVal,
const nsSMILValue& aEndVal,
double aUnitDistance,
nsSMILValue& aResult) const
{
MOZ_ASSERT(aStartVal.mType == aEndVal.mType,
- "Trying to interpolate different types");
+ "Trying to interpolate different types");
MOZ_ASSERT(aStartVal.mType == this,
"Unexpected types for interpolation");
MOZ_ASSERT(aResult.mType == this, "Unexpected result type");
return NS_ERROR_FAILURE; // bool values do not interpolate
}
} // namespace mozilla--- a/dom/smil/SMILIntegerType.cpp
+++ b/dom/smil/SMILIntegerType.cpp
@@ -70,19 +70,18 @@ SMILIntegerType::ComputeDistance(const n
nsresult
SMILIntegerType::Interpolate(const nsSMILValue& aStartVal,
const nsSMILValue& aEndVal,
double aUnitDistance,
nsSMILValue& aResult) const
{
MOZ_ASSERT(aStartVal.mType == aEndVal.mType,
- "Trying to interpolate different types");
- MOZ_ASSERT(aStartVal.mType == this,
- "Unexpected types for interpolation");
+ "Trying to interpolate different types");
+ MOZ_ASSERT(aStartVal.mType == this, "Unexpected types for interpolation");
MOZ_ASSERT(aResult.mType == this, "Unexpected result type");
const double startVal = double(aStartVal.mU.mInt);
const double endVal = double(aEndVal.mU.mInt);
const double currentVal = startVal + (endVal - startVal) * aUnitDistance;
// When currentVal is exactly midway between its two nearest integers, we
// jump to the "next" integer to provide simple, easy to remember and--- a/dom/smil/SMILStringType.cpp
+++ b/dom/smil/SMILStringType.cpp
@@ -76,16 +76,15 @@ SMILStringType::ComputeDistance(const ns
nsresult
SMILStringType::Interpolate(const nsSMILValue& aStartVal,
const nsSMILValue& aEndVal,
double aUnitDistance,
nsSMILValue& aResult) const
{
MOZ_ASSERT(aStartVal.mType == aEndVal.mType,
- "Trying to interpolate different types");
- MOZ_ASSERT(aStartVal.mType == this,
- "Unexpected types for interpolation");
+ "Trying to interpolate different types");
+ MOZ_ASSERT(aStartVal.mType == this, "Unexpected types for interpolation");
MOZ_ASSERT(aResult.mType == this, "Unexpected result type");
return NS_ERROR_FAILURE; // string values do not interpolate
}
} // namespace mozilla--- a/dom/smil/nsSMILFloatType.cpp
+++ b/dom/smil/nsSMILFloatType.cpp
@@ -73,17 +73,17 @@ nsSMILFloatType::ComputeDistance(const n
nsresult
nsSMILFloatType::Interpolate(const nsSMILValue& aStartVal,
const nsSMILValue& aEndVal,
double aUnitDistance,
nsSMILValue& aResult) const
{
MOZ_ASSERT(aStartVal.mType == aEndVal.mType,
- "Trying to interpolate different types");
+ "Trying to interpolate different types");
MOZ_ASSERT(aStartVal.mType == this,
"Unexpected types for interpolation");
MOZ_ASSERT(aResult.mType == this, "Unexpected result type");
const double &startVal = aStartVal.mU.mDouble;
const double &endVal = aEndVal.mU.mDouble;
aResult.mU.mDouble = (startVal + (endVal - startVal) * aUnitDistance);--- a/dom/svg/SVGIntegerPairSMILType.cpp
+++ b/dom/svg/SVGIntegerPairSMILType.cpp
@@ -84,19 +84,18 @@ SVGIntegerPairSMILType::ComputeDistance(
nsresult
SVGIntegerPairSMILType::Interpolate(const nsSMILValue& aStartVal,
const nsSMILValue& aEndVal,
double aUnitDistance,
nsSMILValue& aResult) const
{
MOZ_ASSERT(aStartVal.mType == aEndVal.mType,
- "Trying to interpolate different types");
- MOZ_ASSERT(aStartVal.mType == this,
- "Unexpected types for interpolation");
+ "Trying to interpolate different types");
+ MOZ_ASSERT(aStartVal.mType == this, "Unexpected types for interpolation");
MOZ_ASSERT(aResult.mType == this, "Unexpected result type");
double currentVal[2];
currentVal[0] = aStartVal.mU.mIntPair[0] +
(aEndVal.mU.mIntPair[0] - aStartVal.mU.mIntPair[0]) * aUnitDistance;
currentVal[1] = aStartVal.mU.mIntPair[1] +
(aEndVal.mU.mIntPair[1] - aStartVal.mU.mIntPair[1]) * aUnitDistance;
--- a/dom/svg/SVGLengthListSMILType.cpp
+++ b/dom/svg/SVGLengthListSMILType.cpp
@@ -227,19 +227,18 @@ SVGLengthListSMILType::ComputeDistance(c
nsresult
SVGLengthListSMILType::Interpolate(const nsSMILValue& aStartVal,
const nsSMILValue& aEndVal,
double aUnitDistance,
nsSMILValue& aResult) const
{
MOZ_ASSERT(aStartVal.mType == aEndVal.mType,
- "Trying to interpolate different types");
- MOZ_ASSERT(aStartVal.mType == this,
- "Unexpected types for interpolation");
+ "Trying to interpolate different types");
+ MOZ_ASSERT(aStartVal.mType == this, "Unexpected types for interpolation");
MOZ_ASSERT(aResult.mType == this, "Unexpected result type");
const SVGLengthListAndInfo& start =
*static_cast<const SVGLengthListAndInfo*>(aStartVal.mU.mPtr);
const SVGLengthListAndInfo& end =
*static_cast<const SVGLengthListAndInfo*>(aEndVal.mU.mPtr);
SVGLengthListAndInfo& result =
*static_cast<SVGLengthListAndInfo*>(aResult.mU.mPtr);--- a/dom/svg/SVGNumberListSMILType.cpp
+++ b/dom/svg/SVGNumberListSMILType.cpp
@@ -167,19 +167,18 @@ SVGNumberListSMILType::ComputeDistance(c
nsresult
SVGNumberListSMILType::Interpolate(const nsSMILValue& aStartVal,
const nsSMILValue& aEndVal,
double aUnitDistance,
nsSMILValue& aResult) const
{
MOZ_ASSERT(aStartVal.mType == aEndVal.mType,
- "Trying to interpolate different types");
- MOZ_ASSERT(aStartVal.mType == this,
- "Unexpected types for interpolation");
+ "Trying to interpolate different types");
+ MOZ_ASSERT(aStartVal.mType == this, "Unexpected types for interpolation");
MOZ_ASSERT(aResult.mType == this, "Unexpected result type");
const SVGNumberListAndInfo& start =
*static_cast<const SVGNumberListAndInfo*>(aStartVal.mU.mPtr);
const SVGNumberListAndInfo& end =
*static_cast<const SVGNumberListAndInfo*>(aEndVal.mU.mPtr);
SVGNumberListAndInfo& result =
*static_cast<SVGNumberListAndInfo*>(aResult.mU.mPtr);--- a/dom/svg/SVGNumberPairSMILType.cpp
+++ b/dom/svg/SVGNumberPairSMILType.cpp
@@ -86,19 +86,18 @@ SVGNumberPairSMILType::ComputeDistance(c
nsresult
SVGNumberPairSMILType::Interpolate(const nsSMILValue& aStartVal,
const nsSMILValue& aEndVal,
double aUnitDistance,
nsSMILValue& aResult) const
{
MOZ_ASSERT(aStartVal.mType == aEndVal.mType,
- "Trying to interpolate different types");
- MOZ_ASSERT(aStartVal.mType == this,
- "Unexpected types for interpolation");
+ "Trying to interpolate different types");
+ MOZ_ASSERT(aStartVal.mType == this, "Unexpected types for interpolation");
MOZ_ASSERT(aResult.mType == this, "Unexpected result type");
aResult.mU.mNumberPair[0] =
float(aStartVal.mU.mNumberPair[0] +
(aEndVal.mU.mNumberPair[0] - aStartVal.mU.mNumberPair[0]) * aUnitDistance);
aResult.mU.mNumberPair[1] =
float(aStartVal.mU.mNumberPair[1] +
(aEndVal.mU.mNumberPair[1] - aStartVal.mU.mNumberPair[1]) * aUnitDistance);--- a/dom/svg/SVGOrientSMILType.cpp
+++ b/dom/svg/SVGOrientSMILType.cpp
@@ -120,19 +120,18 @@ SVGOrientSMILType::ComputeDistance(const
nsresult
SVGOrientSMILType::Interpolate(const nsSMILValue& aStartVal,
const nsSMILValue& aEndVal,
double aUnitDistance,
nsSMILValue& aResult) const
{
MOZ_ASSERT(aStartVal.mType == aEndVal.mType,
- "Trying to interpolate different types");
- MOZ_ASSERT(aStartVal.mType == this,
- "Unexpected types for interpolation.");
+ "Trying to interpolate different types");
+ MOZ_ASSERT(aStartVal.mType == this, "Unexpected types for interpolation.");
MOZ_ASSERT(aResult.mType == this, "Unexpected result type.");
if (aStartVal.mU.mOrient.mOrientType != SVG_MARKER_ORIENT_ANGLE ||
aEndVal.mU.mOrient.mOrientType != SVG_MARKER_ORIENT_ANGLE) {
// TODO: it would be nice to be able to handle auto angles too.
return NS_ERROR_FAILURE;
}
--- a/dom/svg/SVGPathSegListSMILType.cpp
+++ b/dom/svg/SVGPathSegListSMILType.cpp
@@ -451,19 +451,18 @@ SVGPathSegListSMILType::ComputeDistance(
nsresult
SVGPathSegListSMILType::Interpolate(const nsSMILValue& aStartVal,
const nsSMILValue& aEndVal,
double aUnitDistance,
nsSMILValue& aResult) const
{
MOZ_ASSERT(aStartVal.mType == aEndVal.mType,
- "Trying to interpolate different types");
- MOZ_ASSERT(aStartVal.mType == this,
- "Unexpected types for interpolation");
+ "Trying to interpolate different types");
+ MOZ_ASSERT(aStartVal.mType == this, "Unexpected types for interpolation");
MOZ_ASSERT(aResult.mType == this, "Unexpected result type");
const SVGPathDataAndInfo& start =
*static_cast<const SVGPathDataAndInfo*>(aStartVal.mU.mPtr);
const SVGPathDataAndInfo& end =
*static_cast<const SVGPathDataAndInfo*>(aEndVal.mU.mPtr);
SVGPathDataAndInfo& result =
*static_cast<SVGPathDataAndInfo*>(aResult.mU.mPtr);--- a/dom/svg/SVGPointListSMILType.cpp
+++ b/dom/svg/SVGPointListSMILType.cpp
@@ -147,19 +147,18 @@ SVGPointListSMILType::ComputeDistance(co
nsresult
SVGPointListSMILType::Interpolate(const nsSMILValue& aStartVal,
const nsSMILValue& aEndVal,
double aUnitDistance,
nsSMILValue& aResult) const
{
MOZ_ASSERT(aStartVal.mType == aEndVal.mType,
- "Trying to interpolate different types");
- MOZ_ASSERT(aStartVal.mType == this,
- "Unexpected types for interpolation");
+ "Trying to interpolate different types");
+ MOZ_ASSERT(aStartVal.mType == this, "Unexpected types for interpolation");
MOZ_ASSERT(aResult.mType == this, "Unexpected result type");
const SVGPointListAndInfo& start =
*static_cast<const SVGPointListAndInfo*>(aStartVal.mU.mPtr);
const SVGPointListAndInfo& end =
*static_cast<const SVGPointListAndInfo*>(aEndVal.mU.mPtr);
SVGPointListAndInfo& result =
*static_cast<SVGPointListAndInfo*>(aResult.mU.mPtr);--- a/dom/svg/SVGTransformListSMILType.cpp
+++ b/dom/svg/SVGTransformListSMILType.cpp
@@ -241,19 +241,18 @@ SVGTransformListSMILType::ComputeDistanc
nsresult
SVGTransformListSMILType::Interpolate(const nsSMILValue& aStartVal,
const nsSMILValue& aEndVal,
double aUnitDistance,
nsSMILValue& aResult) const
{
MOZ_ASSERT(aStartVal.mType == aEndVal.mType,
- "Can't interpolate between different SMIL types");
- MOZ_ASSERT(aStartVal.mType == this,
- "Unexpected type for interpolation");
+ "Can't interpolate between different SMIL types");
+ MOZ_ASSERT(aStartVal.mType == this, "Unexpected type for interpolation");
MOZ_ASSERT(aResult.mType == this, "Unexpected result type");
const TransformArray& startTransforms =
(*static_cast<const TransformArray*>(aStartVal.mU.mPtr));
const TransformArray& endTransforms
(*static_cast<const TransformArray*>(aEndVal.mU.mPtr));
// We may have 0..n transforms in the start transform array (the base--- a/dom/svg/SVGViewBoxSMILType.cpp
+++ b/dom/svg/SVGViewBoxSMILType.cpp
@@ -106,19 +106,18 @@ SVGViewBoxSMILType::ComputeDistance(cons
nsresult
SVGViewBoxSMILType::Interpolate(const nsSMILValue& aStartVal,
const nsSMILValue& aEndVal,
double aUnitDistance,
nsSMILValue& aResult) const
{
MOZ_ASSERT(aStartVal.mType == aEndVal.mType,
- "Trying to interpolate different types");
- MOZ_ASSERT(aStartVal.mType == this,
- "Unexpected types for interpolation");
+ "Trying to interpolate different types");
+ MOZ_ASSERT(aStartVal.mType == this, "Unexpected types for interpolation");
MOZ_ASSERT(aResult.mType == this, "Unexpected result type");
const nsSVGViewBoxRect* start = static_cast<const nsSVGViewBoxRect*>(aStartVal.mU.mPtr);
const nsSVGViewBoxRect* end = static_cast<const nsSVGViewBoxRect*>(aEndVal.mU.mPtr);
if (start->none || end->none) {
return NS_ERROR_FAILURE;
}--- a/dom/xbl/nsXBLProtoImplField.cpp
+++ b/dom/xbl/nsXBLProtoImplField.cpp
@@ -371,18 +371,17 @@ nsXBLProtoImplField::InstallAccessors(JS
}
nsresult
nsXBLProtoImplField::InstallField(JS::Handle<JSObject*> aBoundNode,
const nsXBLPrototypeBinding& aProtoBinding,
bool* aDidInstall) const
{
MOZ_ASSERT(aBoundNode,
- "uh-oh, bound node should NOT be null or bad things will "
- "happen");
+ "uh-oh, bound node should NOT be null or bad things will happen");
*aDidInstall = false;
// Empty fields are treated as not actually present.
if (IsEmpty()) {
return NS_OK;
}
--- a/dom/xbl/nsXBLProtoImplMethod.cpp
+++ b/dom/xbl/nsXBLProtoImplMethod.cpp
@@ -40,32 +40,32 @@ nsXBLProtoImplMethod::~nsXBLProtoImplMet
delete GetUncompiledMethod();
}
}
void
nsXBLProtoImplMethod::AppendBodyText(const nsAString& aText)
{
MOZ_ASSERT(!IsCompiled(),
- "Must not be compiled when accessing uncompiled method");
+ "Must not be compiled when accessing uncompiled method");
nsXBLUncompiledMethod* uncompiledMethod = GetUncompiledMethod();
if (!uncompiledMethod) {
uncompiledMethod = new nsXBLUncompiledMethod();
SetUncompiledMethod(uncompiledMethod);
}
uncompiledMethod->AppendBodyText(aText);
}
void
nsXBLProtoImplMethod::AddParameter(const nsAString& aText)
{
MOZ_ASSERT(!IsCompiled(),
- "Must not be compiled when accessing uncompiled method");
+ "Must not be compiled when accessing uncompiled method");
if (aText.IsEmpty()) {
NS_WARNING("Empty name attribute in xbl:parameter!");
return;
}
nsXBLUncompiledMethod* uncompiledMethod = GetUncompiledMethod();
if (!uncompiledMethod) {
@@ -75,17 +75,17 @@ nsXBLProtoImplMethod::AddParameter(const
uncompiledMethod->AddParameter(aText);
}
void
nsXBLProtoImplMethod::SetLineNumber(uint32_t aLineNumber)
{
MOZ_ASSERT(!IsCompiled(),
- "Must not be compiled when accessing uncompiled method");
+ "Must not be compiled when accessing uncompiled method");
nsXBLUncompiledMethod* uncompiledMethod = GetUncompiledMethod();
if (!uncompiledMethod) {
uncompiledMethod = new nsXBLUncompiledMethod();
SetUncompiledMethod(uncompiledMethod);
}
uncompiledMethod->SetLineNumber(aLineNumber);--- a/dom/xbl/nsXBLService.cpp
+++ b/dom/xbl/nsXBLService.cpp
@@ -897,17 +897,17 @@ nsXBLService::LoadBindingDocumentInfo(ns
nsIDocument* aBoundDocument,
nsIURI* aBindingURI,
nsIPrincipal* aOriginPrincipal,
bool aForceSyncLoad,
nsXBLDocumentInfo** aResult)
{
MOZ_ASSERT(aBindingURI, "Must have a binding URI");
MOZ_ASSERT(!aOriginPrincipal || aBoundDocument,
- "If we're doing a security check, we better have a document!");
+ "If we're doing a security check, we better have a document!");
*aResult = nullptr;
// Allow XBL in unprivileged documents if it's specified in a privileged or
// chrome: stylesheet. This allows themes to specify XBL bindings.
if (aOriginPrincipal && !IsSystemOrChromeURLPrincipal(aOriginPrincipal)) {
NS_ENSURE_TRUE(!aBoundDocument || aBoundDocument->AllowXULXBL(),
NS_ERROR_XBL_BLOCKED);
}--- a/dom/xslt/xpath/txXPathTreeWalker.h
+++ b/dom/xslt/xpath/txXPathTreeWalker.h
@@ -172,18 +172,17 @@ txXPathTreeWalker::isOnNode(const txXPat
{
return (mPosition == aNode);
}
/* static */
inline int32_t
txXPathNodeUtils::getUniqueIdentifier(const txXPathNode& aNode)
{
- MOZ_ASSERT(!aNode.isAttribute(),
- "Not implemented for attributes.");
+ MOZ_ASSERT(!aNode.isAttribute(), "Not implemented for attributes.");
return NS_PTR_TO_INT32(aNode.mNode);
}
/* static */
inline void
txXPathNodeUtils::release(txXPathNode* aNode)
{
NS_RELEASE(aNode->mNode);--- a/dom/xslt/xslt/txMozillaXMLOutput.cpp
+++ b/dom/xslt/xslt/txMozillaXMLOutput.cpp
@@ -428,17 +428,17 @@ txMozillaXMLOutput::startDocument()
}
nsresult
txMozillaXMLOutput::startElement(nsAtom* aPrefix, nsAtom* aLocalName,
nsAtom* aLowercaseLocalName,
const int32_t aNsID)
{
MOZ_ASSERT(aNsID != kNameSpaceID_None || !aPrefix,
- "Can't have prefix without namespace");
+ "Can't have prefix without namespace");
if (mOutputFormat.mMethod == eHTMLOutput && aNsID == kNameSpaceID_None) {
RefPtr<nsAtom> owner;
if (!aLowercaseLocalName) {
owner = TX_ToLowerCaseAtom(aLocalName);
NS_ENSURE_TRUE(owner, NS_ERROR_OUT_OF_MEMORY);
aLowercaseLocalName = owner;--- a/dom/xul/nsXULContentSink.cpp
+++ b/dom/xul/nsXULContentSink.cpp
@@ -421,27 +421,27 @@ XULContentSinkImpl::CreateElement(mozill
element->mNodeInfo = aNodeInfo;
*aResult = element;
return NS_OK;
}
/**** BEGIN NEW APIs ****/
-
NS_IMETHODIMP
XULContentSinkImpl::HandleStartElement(const char16_t *aName,
const char16_t **aAtts,
uint32_t aAttsCount,
uint32_t aLineNumber)
{
// XXX Hopefully the parser will flag this before we get here. If
// we're in the epilog, there should be no new elements
MOZ_ASSERT(mState != eInEpilog, "tag in XUL doc epilog");
MOZ_ASSERT(aAttsCount % 2 == 0, "incorrect aAttsCount");
+
// Adjust aAttsCount so it's the actual number of attributes
aAttsCount /= 2;
if (mState == eInEpilog)
return NS_ERROR_UNEXPECTED;
if (mState != eInScript) {
FlushText();--- a/editor/libeditor/EditorBase.cpp
+++ b/editor/libeditor/EditorBase.cpp
@@ -3545,18 +3545,18 @@ EditorBase::GetNextNodeInternal(const Ed
nsIContent*
EditorBase::FindNextLeafNode(nsINode* aCurrentNode,
bool aGoForward,
bool bNoBlockCrossing)
{
// called only by GetPriorNode so we don't need to check params.
MOZ_ASSERT(IsDescendantOfEditorRoot(aCurrentNode) &&
- !IsEditorRoot(aCurrentNode),
- "Bogus arguments");
+ !IsEditorRoot(aCurrentNode),
+ "Bogus arguments");
nsINode* cur = aCurrentNode;
for (;;) {
// if aCurrentNode has a sibling in the right direction, return
// that sibling's closest child (or itself if it has no children)
nsIContent* sibling =
aGoForward ? cur->GetNextSibling() : cur->GetPreviousSibling();
if (sibling) {--- a/editor/libeditor/HTMLEditor.cpp
+++ b/editor/libeditor/HTMLEditor.cpp
@@ -387,17 +387,17 @@ HTMLEditor::UpdateRootElement()
already_AddRefed<nsIContent>
HTMLEditor::FindSelectionRoot(nsINode* aNode)
{
if (NS_WARN_IF(!aNode)) {
return nullptr;
}
MOZ_ASSERT(aNode->IsDocument() || aNode->IsContent(),
- "aNode must be content or document node");
+ "aNode must be content or document node");
nsCOMPtr<nsIDocument> doc = aNode->GetComposedDoc();
if (!doc) {
return nullptr;
}
nsCOMPtr<nsIContent> content;
if (aNode->IsInUncomposedDoc() &&--- a/gfx/thebes/gfxFont.cpp
+++ b/gfx/thebes/gfxFont.cpp
@@ -4185,18 +4185,18 @@ gfxFontStyle::Hash() const
nsRefPtrHashKey<nsAtom>::HashKey(language);
*/
}
void
gfxFontStyle::AdjustForSubSuperscript(int32_t aAppUnitsPerDevPixel)
{
MOZ_ASSERT(variantSubSuper != NS_FONT_VARIANT_POSITION_NORMAL &&
- baselineOffset == 0,
- "can't adjust this style for sub/superscript");
+ baselineOffset == 0,
+ "can't adjust this style for sub/superscript");
// calculate the baseline offset (before changing the size)
if (variantSubSuper == NS_FONT_VARIANT_POSITION_SUPER) {
baselineOffset = size * -NS_FONT_SUPERSCRIPT_OFFSET_RATIO;
} else {
baselineOffset = size * NS_FONT_SUBSCRIPT_OFFSET_RATIO;
}
--- a/gfx/thebes/gfxTextRun.cpp
+++ b/gfx/thebes/gfxTextRun.cpp
@@ -862,17 +862,17 @@ gfxTextRun::MeasureText(Range aRange,
#define MEASUREMENT_BUFFER_SIZE 100
void
gfxTextRun::ClassifyAutoHyphenations(uint32_t aStart, Range aRange,
nsTArray<HyphenType>& aHyphenBuffer,
HyphenationState* aWordState)
{
MOZ_ASSERT(aRange.end - aStart <= aHyphenBuffer.Length() &&
- aRange.start >= aStart, "Range out of bounds");
+ aRange.start >= aStart, "Range out of bounds");
MOZ_ASSERT(aWordState->mostRecentBoundary >= aStart,
"Unexpected aMostRecentWordBoundary!!");
uint32_t start = std::min<uint32_t>(aRange.start, aWordState->mostRecentBoundary);
for (uint32_t i = start; i < aRange.end; ++i) {
if (aHyphenBuffer[i - aStart] == HyphenType::Explicit &&
!aWordState->hasExplicitHyphen) {--- a/gfx/thebes/gfxXlibSurface.cpp
+++ b/gfx/thebes/gfxXlibSurface.cpp
@@ -67,17 +67,17 @@ gfxXlibSurface::gfxXlibSurface(Screen *s
gfxXlibSurface::gfxXlibSurface(cairo_surface_t *csurf)
: mPixmapTaken(false)
#if defined(GL_PROVIDER_GLX)
, mGLXPixmap(X11None)
#endif
{
MOZ_ASSERT(cairo_surface_status(csurf) == 0,
- "Not expecting an error surface");
+ "Not expecting an error surface");
mDrawable = cairo_xlib_surface_get_drawable(csurf);
mDisplay = cairo_xlib_surface_get_display(csurf);
Init(csurf, true);
}
gfxXlibSurface::~gfxXlibSurface()--- a/image/imgRequestProxy.cpp
+++ b/image/imgRequestProxy.cpp
@@ -180,17 +180,17 @@ imgRequestProxy::~imgRequestProxy()
nsresult
imgRequestProxy::Init(imgRequest* aOwner,
nsILoadGroup* aLoadGroup,
nsIDocument* aLoadingDocument,
ImageURL* aURI,
imgINotificationObserver* aObserver)
{
MOZ_ASSERT(!GetOwner() && !mListener,
- "imgRequestProxy is already initialized");
+ "imgRequestProxy is already initialized");
LOG_SCOPE_WITH_PARAM(gImgLog, "imgRequestProxy::Init", "request",
aOwner);
MOZ_ASSERT(mAnimationConsumers == 0, "Cannot have animation before Init");
mBehaviour->SetOwner(aOwner);
mListener = aObserver;--- a/intl/lwbrk/WordBreaker.cpp
+++ b/intl/lwbrk/WordBreaker.cpp
@@ -12,31 +12,29 @@ using mozilla::intl::WordRange;
/*static*/
already_AddRefed<WordBreaker>
WordBreaker::Create()
{
return RefPtr<WordBreaker>(new WordBreaker()).forget();
}
-
bool WordBreaker::BreakInBetween(
const char16_t* aText1 , uint32_t aTextLen1,
const char16_t* aText2 , uint32_t aTextLen2)
{
- MOZ_ASSERT( nullptr != aText1, "null ptr");
- MOZ_ASSERT( nullptr != aText2, "null ptr");
+ MOZ_ASSERT(nullptr != aText1, "null ptr");
+ MOZ_ASSERT(nullptr != aText2, "null ptr");
if(!aText1 || !aText2 || (0 == aTextLen1) || (0 == aTextLen2))
return false;
return GetClass(aText1[aTextLen1-1]) != GetClass(aText2[0]);
}
-
#define IS_ASCII(c) (0 == ( 0xFF80 & (c)))
#define ASCII_IS_ALPHA(c) ((( 'a' <= (c)) && ((c) <= 'z')) || (( 'A' <= (c)) && ((c) <= 'Z')))
#define ASCII_IS_DIGIT(c) (( '0' <= (c)) && ((c) <= '9'))
#define ASCII_IS_SPACE(c) (( ' ' == (c)) || ( '\t' == (c)) || ( '\r' == (c)) || ( '\n' == (c)))
#define IS_ALPHABETICAL_SCRIPT(c) ((c) < 0x2E80)
// we change the beginning of IS_HAN from 0x4e00 to 0x3400 to relfect Unicode 3.0
#define IS_HAN(c) (( 0x3400 <= (c)) && ((c) <= 0x9fff))||(( 0xf900 <= (c)) && ((c) <= 0xfaff))--- a/intl/uconv/nsConverterOutputStream.cpp
+++ b/intl/uconv/nsConverterOutputStream.cpp
@@ -127,9 +127,8 @@ nsConverterOutputStream::Close()
nsresult rv1 = Flush();
nsresult rv2 = mOutStream->Close();
mOutStream = nullptr;
mConverter = nullptr;
return NS_FAILED(rv1) ? rv1 : rv2;
}
---- a/ipc/glue/MessageChannel.cpp
+++ b/ipc/glue/MessageChannel.cpp
@@ -836,20 +836,19 @@ MessageChannel::Open(MessageChannel *aTa
MOZ_RELEASE_ASSERT(ChannelConnected == mChannelState, "not connected when awoken");
return (ChannelConnected == mChannelState);
}
void
MessageChannel::OnOpenAsSlave(MessageChannel *aTargetChan, Side aSide)
{
// Invoked when the other side has begun the open.
- MOZ_ASSERT(ChannelClosed == mChannelState,
- "Not currently closed");
+ MOZ_ASSERT(ChannelClosed == mChannelState, "Not currently closed");
MOZ_ASSERT(ChannelOpening == aTargetChan->mChannelState,
- "Target channel not in the process of opening");
+ "Target channel not in the process of opening");
CommonThreadOpenInit(aTargetChan, aSide);
mMonitor = aTargetChan->mMonitor;
MonitorAutoLock lock(*mMonitor);
MOZ_RELEASE_ASSERT(ChannelOpening == aTargetChan->mChannelState,
"Target channel not in the process of opening");
mChannelState = ChannelConnected;--- a/layout/base/PresShell.cpp
+++ b/layout/base/PresShell.cpp
@@ -2673,19 +2673,19 @@ PresShell::VerifyHasDirtyRootAncestor(ns
#endif
void
PresShell::FrameNeedsReflow(nsIFrame *aFrame, IntrinsicDirty aIntrinsicDirty,
nsFrameState aBitToAdd,
ReflowRootHandling aRootHandling)
{
MOZ_ASSERT(aBitToAdd == NS_FRAME_IS_DIRTY ||
- aBitToAdd == NS_FRAME_HAS_DIRTY_CHILDREN ||
- !aBitToAdd,
- "Unexpected bits being added");
+ aBitToAdd == NS_FRAME_HAS_DIRTY_CHILDREN ||
+ !aBitToAdd,
+ "Unexpected bits being added");
// FIXME removeAttribute bug 478135
NS_ASSERTION(!(aIntrinsicDirty == eStyleChange &&
aBitToAdd == NS_FRAME_HAS_DIRTY_CHILDREN),
"bits don't correspond to style change reason");
// FIXME bug 457400
NS_ASSERTION(!mIsReflowing, "can't mark frame dirty during reflow");
@@ -4566,17 +4566,17 @@ PresShell::NotifyCounterStylesAreDirty()
nsAutoCauseReflowNotifier reflowNotifier(this);
mFrameConstructor->NotifyCounterStylesAreDirty();
}
void
PresShell::ReconstructFrames()
{
MOZ_ASSERT(!mFrameConstructor->GetRootFrame() || mDidInitialize,
- "Must not have root frame before initial reflow");
+ "Must not have root frame before initial reflow");
if (!mDidInitialize || mIsDestroying) {
// Nothing to do here
return;
}
nsCOMPtr<nsIPresShell> kungFuDeathGrip(this);
// Have to make sure that the content notifications are flushed before we--- a/layout/base/RestyleManager.cpp
+++ b/layout/base/RestyleManager.cpp
@@ -987,17 +987,17 @@ NeedToReframeForAddingOrRemovingTransfor
return false;
}
static void
DoApplyRenderingChangeToTree(nsIFrame* aFrame,
nsChangeHint aChange)
{
MOZ_ASSERT(gInApplyRenderingChangeToTree,
- "should only be called within ApplyRenderingChangeToTree");
+ "should only be called within ApplyRenderingChangeToTree");
for ( ; aFrame; aFrame = nsLayoutUtils::GetNextContinuationOrIBSplitSibling(aFrame)) {
// Invalidate and sync views on all descendant frames, following placeholders.
// We don't need to update transforms in SyncViewsAndInvalidateDescendants, because
// there can't be any out-of-flows or popups that need to be transformed;
// all out-of-flow descendants of the transformed element must also be
// descendants of the transformed frame.
SyncViewsAndInvalidateDescendants(aFrame,
@@ -1087,17 +1087,18 @@ DoApplyRenderingChangeToTree(nsIFrame* a
: nsIFrame::PAINT_COMPOSITE_ONLY);
}
}
static void
SyncViewsAndInvalidateDescendants(nsIFrame* aFrame, nsChangeHint aChange)
{
MOZ_ASSERT(gInApplyRenderingChangeToTree,
- "should only be called within ApplyRenderingChangeToTree");
+ "should only be called within ApplyRenderingChangeToTree");
+
NS_ASSERTION(nsChangeHint_size_t(aChange) ==
(aChange & (nsChangeHint_RepaintFrame |
nsChangeHint_SyncFrameView |
nsChangeHint_UpdateOpacityLayer |
nsChangeHint_SchedulePaint)),
"Invalid change flag");
if (aChange & nsChangeHint_SyncFrameView) {--- a/layout/base/nsCSSFrameConstructor.cpp
+++ b/layout/base/nsCSSFrameConstructor.cpp
@@ -602,17 +602,17 @@ SetFrameIsIBSplit(nsContainerFrame* aFra
aIBSplitSibling->SetProperty(nsIFrame::IBSplitPrevSibling(), aFrame);
}
}
static nsIFrame*
GetIBContainingBlockFor(nsIFrame* aFrame)
{
MOZ_ASSERT(IsFramePartOfIBSplit(aFrame),
- "GetIBContainingBlockFor() should only be called on known IB frames");
+ "GetIBContainingBlockFor() should only be called on known IB frames");
// Get the first "normal" ancestor of the target frame.
nsIFrame* parentFrame;
do {
parentFrame = aFrame->GetParent();
if (! parentFrame) {
NS_ERROR("no unsplit block frame in IB hierarchy");
@@ -1144,18 +1144,18 @@ nsFrameConstructorState::PushAbsoluteCon
}
}
void
nsFrameConstructorState::PushFloatContainingBlock(nsContainerFrame* aNewFloatContainingBlock,
nsFrameConstructorSaveState& aSaveState)
{
MOZ_ASSERT(!aNewFloatContainingBlock ||
- aNewFloatContainingBlock->IsFloatContainingBlock(),
- "Please push a real float containing block!");
+ aNewFloatContainingBlock->IsFloatContainingBlock(),
+ "Please push a real float containing block!");
NS_ASSERTION(!aNewFloatContainingBlock ||
!ShouldSuppressFloatingOfDescendants(aNewFloatContainingBlock),
"We should not push a frame that is supposed to _suppress_ "
"floats as a float containing block!");
aSaveState.mItems = &mFloatedItems;
aSaveState.mSavedItems = mFloatedItems;
aSaveState.mChildListID = nsIFrame::kFloatList;
aSaveState.mState = this;
@@ -1375,22 +1375,22 @@ nsFrameConstructorState::ProcessFrameIns
((&aFrameItems == &mAbsoluteItems || \
&aFrameItems == &mTopLayerAbsoluteItems) && \
aChildListID == nsIFrame::kAbsoluteList) || \
((&aFrameItems == &mFixedItems || \
&aFrameItems == &mTopLayerFixedItems) && \
aChildListID == nsIFrame::kFixedList)
#ifdef MOZ_XUL
MOZ_ASSERT(NS_NONXUL_LIST_TEST ||
- (&aFrameItems == &mPopupItems &&
- aChildListID == nsIFrame::kPopupList),
- "Unexpected aFrameItems/aChildListID combination");
+ (&aFrameItems == &mPopupItems &&
+ aChildListID == nsIFrame::kPopupList),
+ "Unexpected aFrameItems/aChildListID combination");
#else
MOZ_ASSERT(NS_NONXUL_LIST_TEST,
- "Unexpected aFrameItems/aChildListID combination");
+ "Unexpected aFrameItems/aChildListID combination");
#endif
if (aFrameItems.IsEmpty()) {
return;
}
nsContainerFrame* containingBlock = aFrameItems.containingBlock;
@@ -2079,18 +2079,18 @@ PullOutCaptionFrames(nsFrameItems& aItem
nsIFrame*
nsCSSFrameConstructor::ConstructTable(nsFrameConstructorState& aState,
FrameConstructionItem& aItem,
nsContainerFrame* aParentFrame,
const nsStyleDisplay* aDisplay,
nsFrameItems& aFrameItems)
{
MOZ_ASSERT(aDisplay->mDisplay == StyleDisplay::Table ||
- aDisplay->mDisplay == StyleDisplay::InlineTable,
- "Unexpected call");
+ aDisplay->mDisplay == StyleDisplay::InlineTable,
+ "Unexpected call");
nsIContent* const content = aItem.mContent;
ComputedStyle* const computedStyle = aItem.mComputedStyle;
const bool isMathMLContent = content->IsMathMLElement();
// create the pseudo SC for the table wrapper as a child of the inner SC
RefPtr<ComputedStyle> outerComputedStyle;
outerComputedStyle = mPresShell->StyleSet()->
@@ -2372,19 +2372,19 @@ nsCSSFrameConstructor::ConstructTableCel
static inline bool
NeedFrameFor(const nsFrameConstructorState& aState,
nsIFrame* aParentFrame,
nsIContent* aChildContent)
{
// XXX the GetContent() != aChildContent check is needed due to bug 135040.
// Remove it once that's fixed.
MOZ_ASSERT(!aChildContent->GetPrimaryFrame() ||
- aState.mCreatingExtraFrames ||
- aChildContent->GetPrimaryFrame()->GetContent() != aChildContent,
- "Why did we get called?");
+ aState.mCreatingExtraFrames ||
+ aChildContent->GetPrimaryFrame()->GetContent() != aChildContent,
+ "Why did we get called?");
// don't create a whitespace frame if aParentFrame doesn't want it.
// always create frames for children in generated content. counter(),
// quotes, and attr() content can easily change dynamically and we don't
// want to be reconstructing frames. It's not even clear that these
// should be considered ignorable just because they evaluate to
// whitespace.
@@ -3053,17 +3053,18 @@ nsCSSFrameConstructor::CreatePlaceholder
// aStartContent. aStartContent must not be null unless aEndContent is also
// null. We do this so that when new children are inserted under elements whose
// frame is a leaf the new children don't cause us to try to construct frames
// for the existing children again.
static inline void
ClearLazyBits(nsIContent* aStartContent, nsIContent* aEndContent)
{
MOZ_ASSERT(aStartContent || !aEndContent,
- "Must have start child if we have an end child");
+ "Must have start child if we have an end child");
+
for (nsIContent* cur = aStartContent; cur != aEndContent;
cur = cur->GetNextSibling()) {
cur->UnsetFlags(NODE_DESCENDANTS_NEED_FRAMES | NODE_NEEDS_FRAME);
}
}
nsIFrame*
nsCSSFrameConstructor::ConstructSelectFrame(nsFrameConstructorState& aState,
@@ -5648,17 +5649,17 @@ nsCSSFrameConstructor::AddFrameConstruct
nsContainerFrame* aParentFrame,
bool aSuppressWhiteSpaceOptimizations,
ComputedStyle* aComputedStyle,
uint32_t aFlags,
nsTArray<nsIAnonymousContentCreator::ContentInfo>* aAnonChildren,
FrameConstructionItemList& aItems)
{
MOZ_ASSERT(aContent->IsText() || aContent->IsElement(),
- "Shouldn't get anything else here!");
+ "Shouldn't get anything else here!");
MOZ_ASSERT(aContent->IsInComposedDoc());
MOZ_ASSERT(!aContent->GetPrimaryFrame() || aState.mCreatingExtraFrames ||
aContent->NodeInfo()->NameAtom() == nsGkAtoms::area);
// The following code allows the user to specify the base tag
// of an element using XBL. XUL and HTML objects (like boxes, menus, etc.)
// can then be extended arbitrarily.
const nsStyleDisplay* display = aComputedStyle->StyleDisplay();
@@ -6272,21 +6273,21 @@ GetInsertNextSibling(nsIFrame* aParentFr
void
nsCSSFrameConstructor::AppendFramesToParent(nsFrameConstructorState& aState,
nsContainerFrame* aParentFrame,
nsFrameItems& aFrameList,
nsIFrame* aPrevSibling,
bool aIsRecursiveCall)
{
MOZ_ASSERT(!IsFramePartOfIBSplit(aParentFrame) ||
- !GetIBSplitSibling(aParentFrame) ||
- !GetIBSplitSibling(aParentFrame)->PrincipalChildList().FirstChild(),
- "aParentFrame has a ib-split sibling with kids?");
+ !GetIBSplitSibling(aParentFrame) ||
+ !GetIBSplitSibling(aParentFrame)->PrincipalChildList().FirstChild(),
+ "aParentFrame has a ib-split sibling with kids?");
MOZ_ASSERT(!aPrevSibling || aPrevSibling->GetParent() == aParentFrame,
- "Parent and prevsibling don't match");
+ "Parent and prevsibling don't match");
nsIFrame* nextSibling = ::GetInsertNextSibling(aParentFrame, aPrevSibling);
NS_ASSERTION(nextSibling ||
!aParentFrame->GetNextContinuation() ||
!aParentFrame->GetNextContinuation()->PrincipalChildList().FirstChild() ||
aIsRecursiveCall,
"aParentFrame has later continuations with kids?");
@@ -6599,18 +6600,17 @@ nsCSSFrameConstructor::FindSibling(const
return nullptr;
}
// For fieldsets, returns the area frame, if the child is not a legend.
static nsContainerFrame*
GetAdjustedParentFrame(nsContainerFrame* aParentFrame,
nsIContent* aChildContent)
{
- MOZ_ASSERT(!aParentFrame->IsTableWrapperFrame(),
- "Shouldn't be happening!");
+ MOZ_ASSERT(!aParentFrame->IsTableWrapperFrame(), "Shouldn't be happening!");
nsContainerFrame* newParent = nullptr;
if (aParentFrame->IsFieldSetFrame()) {
// If the parent is a fieldSet, use the fieldSet's area frame as the
// parent unless the new content is a legend.
if (!aChildContent->IsHTMLElement(nsGkAtoms::legend)) {
newParent = GetFieldSetBlockFrame(aParentFrame);
@@ -8854,17 +8854,17 @@ FindPreviousNonWhitespaceSibling(nsIFram
}
bool
nsCSSFrameConstructor::MaybeRecreateContainerForFrameRemoval(nsIFrame* aFrame)
{
MOZ_ASSERT(aFrame, "Must have a frame");
MOZ_ASSERT(aFrame->GetParent(), "Frame shouldn't be root");
MOZ_ASSERT(aFrame == aFrame->FirstContinuation(),
- "aFrame not the result of GetPrimaryFrame()?");
+ "aFrame not the result of GetPrimaryFrame()?");
if (IsFramePartOfIBSplit(aFrame)) {
// The removal functions can't handle removal of an {ib} split directly; we
// need to rebuild the containing block.
#ifdef DEBUG
if (gNoisyContentUpdates) {
printf("nsCSSFrameConstructor::MaybeRecreateContainerForFrameRemoval: "
"frame=");
@@ -10203,18 +10203,19 @@ nsCSSFrameConstructor::ProcessChildren(n
const bool aCanHaveGeneratedContent,
nsFrameItems& aFrameItems,
const bool aAllowBlockStyles,
PendingBinding* aPendingBinding,
nsIFrame* aPossiblyLeafFrame)
{
MOZ_ASSERT(aFrame, "Must have parent frame here");
MOZ_ASSERT(aFrame->GetContentInsertionFrame() == aFrame,
- "Parent frame in ProcessChildren should be its own "
- "content insertion frame");
+ "Parent frame in ProcessChildren should be its own "
+ "content insertion frame");
+
const uint32_t kMaxDepth = 2 * MAX_REFLOW_DEPTH;
static_assert(kMaxDepth <= UINT16_MAX, "mCurrentDepth type is too narrow");
AutoRestore<uint16_t> savedDepth(mCurrentDepth);
if (mCurrentDepth != UINT16_MAX) {
++mCurrentDepth;
}
if (!aPossiblyLeafFrame) {
@@ -11424,17 +11425,17 @@ nsCSSFrameConstructor::CreateIBSiblings(
nsContainerFrame* lastNewInline =
static_cast<nsContainerFrame*>(aInitialInline->FirstContinuation());
do {
// On entry to this loop aChildItems is not empty and the first frame in it
// is block-level.
MOZ_ASSERT(aChildItems.NotEmpty(), "Should have child items");
MOZ_ASSERT(!aChildItems.FirstChild()->IsInlineOutside(),
- "Must have list starting with block");
+ "Must have list starting with block");
// The initial run of blocks belongs to an anonymous block that we create
// right now. The anonymous block will be the parent of these block
// children of the inline.
nsBlockFrame* blockFrame = NS_NewBlockFrame(mPresShell, blockSC);
InitAndRestoreFrame(aState, content, parentFrame, blockFrame, false);
// Find the first non-block child which defines the end of our block kids
@@ -11542,18 +11543,18 @@ nsCSSFrameConstructor::BuildInlineChildI
}
// return whether it's ok to append (in the AppendFrames sense) to
// aParentFrame if our nextSibling is aNextSibling. aParentFrame must
// be an ib-split inline.
static bool
IsSafeToAppendToIBSplitInline(nsIFrame* aParentFrame, nsIFrame* aNextSibling)
{
- MOZ_ASSERT(IsInlineFrame(aParentFrame),
- "Must have an inline parent here");
+ MOZ_ASSERT(IsInlineFrame(aParentFrame), "Must have an inline parent here");
+
do {
NS_ASSERTION(IsFramePartOfIBSplit(aParentFrame),
"How is this not part of an ib-split?");
if (aNextSibling || aParentFrame->GetNextContinuation() ||
GetIBSplitSibling(aParentFrame)) {
return false;
}
@@ -12008,17 +12009,17 @@ nsCSSFrameConstructor::GenerateChildFram
//////////////////////////////////////////////////////////
// nsCSSFrameConstructor::FrameConstructionItem methods //
//////////////////////////////////////////////////////////
bool
nsCSSFrameConstructor::
FrameConstructionItem::IsWhitespace(nsFrameConstructorState& aState) const
{
MOZ_ASSERT(aState.mCreatingExtraFrames ||
- !mContent->GetPrimaryFrame(), "How did that happen?");
+ !mContent->GetPrimaryFrame(), "How did that happen?");
if (!mIsText) {
return false;
}
mContent->SetFlags(NS_CREATE_FRAME_IF_NON_WHITESPACE |
NS_REFRAME_IF_WHITESPACE);
return mContent->TextIsOnlyWhitespace();
}
--- a/layout/base/nsDocumentViewer.cpp
+++ b/layout/base/nsDocumentViewer.cpp
@@ -2582,17 +2582,17 @@ nsDocumentViewer::FindContainerView()
NS_ASSERTION(subdocFrame->GetView(), "Subdoc frames must have views");
return static_cast<nsSubDocumentFrame*>(subdocFrame)->EnsureInnerView();
}
nsresult
nsDocumentViewer::CreateDeviceContext(nsView* aContainerView)
{
MOZ_ASSERT(!mPresShell && !mWindow,
- "This will screw up our existing presentation");
+ "This will screw up our existing presentation");
MOZ_ASSERT(mDocument, "Gotta have a document here");
nsIDocument* doc = mDocument->GetDisplayDocument();
if (doc) {
NS_ASSERTION(!aContainerView, "External resource document embedded somewhere?");
// We want to use our display document's device context if possible
nsPresContext* ctx = doc->GetPresContext();
if (ctx) {--- a/layout/base/nsFrameManager.cpp
+++ b/layout/base/nsFrameManager.cpp
@@ -80,19 +80,19 @@ nsFrameManager::AppendFrames(nsContainer
void
nsFrameManager::InsertFrames(nsContainerFrame* aParentFrame,
ChildListID aListID,
nsIFrame* aPrevFrame,
nsFrameList& aFrameList)
{
MOZ_ASSERT(!aPrevFrame || (!aPrevFrame->GetNextContinuation()
- || (((aPrevFrame->GetNextContinuation()->GetStateBits() & NS_FRAME_IS_OVERFLOW_CONTAINER))
- && !(aPrevFrame->GetStateBits() & NS_FRAME_IS_OVERFLOW_CONTAINER))),
- "aPrevFrame must be the last continuation in its chain!");
+ || (((aPrevFrame->GetNextContinuation()->GetStateBits() & NS_FRAME_IS_OVERFLOW_CONTAINER))
+ && !(aPrevFrame->GetStateBits() & NS_FRAME_IS_OVERFLOW_CONTAINER))),
+ "aPrevFrame must be the last continuation in its chain!");
if (aParentFrame->IsAbsoluteContainer() &&
aListID == aParentFrame->GetAbsoluteListID()) {
aParentFrame->GetAbsoluteContainingBlock()->
InsertFrames(aParentFrame, aListID, aPrevFrame, aFrameList);
} else {
aParentFrame->InsertFrames(aListID, aPrevFrame, aFrameList);
}--- a/layout/base/nsLayoutUtils.cpp
+++ b/layout/base/nsLayoutUtils.cpp
@@ -4986,17 +4986,18 @@ enum eWidthProperty { PROP_WIDTH, PROP_M
static bool
GetIntrinsicCoord(const nsStyleCoord& aStyle,
gfxContext* aRenderingContext,
nsIFrame* aFrame,
eWidthProperty aProperty,
nscoord& aResult)
{
MOZ_ASSERT(aProperty == PROP_WIDTH || aProperty == PROP_MAX_WIDTH ||
- aProperty == PROP_MIN_WIDTH, "unexpected property");
+ aProperty == PROP_MIN_WIDTH, "unexpected property");
+
if (aStyle.GetUnit() != eStyleUnit_Enumerated)
return false;
int32_t val = aStyle.GetIntValue();
NS_ASSERTION(val == NS_STYLE_WIDTH_MAX_CONTENT ||
val == NS_STYLE_WIDTH_MIN_CONTENT ||
val == NS_STYLE_WIDTH_FIT_CONTENT ||
val == NS_STYLE_WIDTH_AVAILABLE,
"unexpected enumerated value for width property");
@@ -5209,17 +5210,17 @@ nsLayoutUtils::IntrinsicForAxis(Physical
nsIFrame* aFrame,
IntrinsicISizeType aType,
const Maybe<LogicalSize>& aPercentageBasis,
uint32_t aFlags,
nscoord aMarginBoxMinSizeClamp)
{
MOZ_ASSERT(aFrame, "null frame");
MOZ_ASSERT(aFrame->GetParent(),
- "IntrinsicForAxis called on frame not in tree");
+ "IntrinsicForAxis called on frame not in tree");
MOZ_ASSERT(aType == MIN_ISIZE || aType == PREF_ISIZE, "bad type");
MOZ_ASSERT(aFrame->GetParent()->Type() != LayoutFrameType::GridContainer ||
aPercentageBasis.isSome(),
"grid layout should always pass a percentage basis");
const bool horizontalAxis = MOZ_LIKELY(aAxis == eAxisHorizontal);
#ifdef DEBUG_INTRINSIC_WIDTH
nsFrame::IndentBy(stderr, gNoiseIndent);
@@ -5591,18 +5592,18 @@ nsLayoutUtils::ComputeBSizeDependentValu
// XXXldb Some callers explicitly check aContainingBlockBSize
// against NS_AUTOHEIGHT *and* unit against eStyleUnit_Percent or
// calc()s containing percents before calling this function.
// However, it would be much more likely to catch problems without
// the unit conditions.
// XXXldb Many callers pass a non-'auto' containing block height when
// according to CSS2.1 they should be passing 'auto'.
MOZ_ASSERT(NS_AUTOHEIGHT != aContainingBlockBSize ||
- !aCoord.HasPercent(),
- "unexpected containing block block-size");
+ !aCoord.HasPercent(),
+ "unexpected containing block block-size");
if (aCoord.IsCoordPercentCalcUnit()) {
return aCoord.ComputeCoordPercentCalc(aContainingBlockBSize);
}
NS_ASSERTION(aCoord.GetUnit() == eStyleUnit_None ||
aCoord.GetUnit() == eStyleUnit_Auto,
"unexpected block-size value");--- a/layout/base/nsRefreshDriver.cpp
+++ b/layout/base/nsRefreshDriver.cpp
@@ -1509,17 +1509,17 @@ nsRefreshDriver::ArrayFor(FlushType aFlu
*/
void
nsRefreshDriver::DoTick()
{
MOZ_ASSERT(!IsFrozen(), "Why are we notified while frozen?");
MOZ_ASSERT(mPresContext, "Why are we notified after disconnection?");
MOZ_ASSERT(!nsContentUtils::GetCurrentJSContext(),
- "Shouldn't have a JSContext on the stack");
+ "Shouldn't have a JSContext on the stack");
if (mTestControllingRefreshes) {
Tick(mMostRecentRefreshEpochTime, mMostRecentRefresh);
} else {
Tick(JS_Now(), TimeStamp::Now());
}
}
@@ -1778,17 +1778,17 @@ nsRefreshDriver::CancelIdleRunnable(nsIR
sPendingIdleRunnables = nullptr;
}
}
void
nsRefreshDriver::Tick(int64_t aNowEpoch, TimeStamp aNowTime)
{
MOZ_ASSERT(!nsContentUtils::GetCurrentJSContext(),
- "Shouldn't have a JSContext on the stack");
+ "Shouldn't have a JSContext on the stack");
if (nsNPAPIPluginInstance::InPluginCallUnsafeForReentry()) {
NS_ERROR("Refresh driver should not run during plugin call!");
// Try to survive this by just ignoring the refresh tick.
return;
}
AUTO_PROFILER_LABEL("nsRefreshDriver::Tick", GRAPHICS);--- a/layout/forms/nsFieldSetFrame.cpp
+++ b/layout/forms/nsFieldSetFrame.cpp
@@ -361,17 +361,17 @@ nsFieldSetFrame::Reflow(nsPresContext*
const ReflowInput& aReflowInput,
nsReflowStatus& aStatus)
{
MarkInReflow();
DO_GLOBAL_REFLOW_COUNT("nsFieldSetFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowInput, aDesiredSize, aStatus);
MOZ_ASSERT(aStatus.IsEmpty(), "Caller should pass a fresh reflow status!");
MOZ_ASSERT(aReflowInput.ComputedISize() != NS_INTRINSICSIZE,
- "Should have a precomputed inline-size!");
+ "Should have a precomputed inline-size!");
nsOverflowAreas ocBounds;
nsReflowStatus ocStatus;
if (GetPrevInFlow()) {
ReflowOverflowContainerChildren(aPresContext, aReflowInput, ocBounds, 0,
ocStatus);
}
--- a/layout/forms/nsListControlFrame.cpp
+++ b/layout/forms/nsListControlFrame.cpp
@@ -364,17 +364,17 @@ nsListControlFrame::GetMinISize(gfxConte
void
nsListControlFrame::Reflow(nsPresContext* aPresContext,
ReflowOutput& aDesiredSize,
const ReflowInput& aReflowInput,
nsReflowStatus& aStatus)
{
MOZ_ASSERT(aStatus.IsEmpty(), "Caller should pass a fresh reflow status!");
MOZ_ASSERT(aReflowInput.ComputedISize() != NS_UNCONSTRAINEDSIZE,
- "Must have a computed inline size");
+ "Must have a computed inline size");
SchedulePaint();
mHasPendingInterruptAtStartOfReflow = aPresContext->HasPendingInterrupt();
// If all the content and frames are here
// then initialize it before reflow
if (mIsAllContentHere && !mHasBeenInitialized) {
@@ -499,17 +499,17 @@ nsListControlFrame::Reflow(nsPresContext
void
nsListControlFrame::ReflowAsDropdown(nsPresContext* aPresContext,
ReflowOutput& aDesiredSize,
const ReflowInput& aReflowInput,
nsReflowStatus& aStatus)
{
MOZ_ASSERT(aReflowInput.ComputedBSize() == NS_UNCONSTRAINEDSIZE,
- "We should not have a computed block size here!");
+ "We should not have a computed block size here!");
mMightNeedSecondPass = NS_SUBTREE_DIRTY(this) ||
aReflowInput.ShouldReflowAllKids();
WritingMode wm = aReflowInput.GetWritingMode();
#ifdef DEBUG
nscoord oldBSizeOfARow = BSizeOfARow();
nscoord oldVisibleBSize = (GetStateBits() & NS_FRAME_FIRST_REFLOW) ?
@@ -1577,17 +1577,17 @@ nsListControlFrame::CalcFallbackRowBSize
return fontMet->MaxHeight();
}
nscoord
nsListControlFrame::CalcIntrinsicBSize(nscoord aBSizeOfARow,
int32_t aNumberOfOptions)
{
MOZ_ASSERT(!IsInDropDownMode(),
- "Shouldn't be in dropdown mode when we call this");
+ "Shouldn't be in dropdown mode when we call this");
dom::HTMLSelectElement* select =
dom::HTMLSelectElement::FromNodeOrNull(mContent);
if (select) {
mNumDisplayRows = select->Size();
} else {
mNumDisplayRows = 1;
}--- a/layout/forms/nsTextControlFrame.cpp
+++ b/layout/forms/nsTextControlFrame.cpp
@@ -1256,17 +1256,17 @@ nsTextControlFrame::UpdateValueDisplay(b
bool aBeforeEditorInit,
const nsAString *aValue)
{
if (!IsSingleLineTextControl()) // textareas don't use this
return NS_OK;
MOZ_ASSERT(mRootNode, "Must have a div content\n");
MOZ_ASSERT(!mEditorHasBeenInitialized,
- "Do not call this after editor has been initialized");
+ "Do not call this after editor has been initialized");
nsIContent* childContent = mRootNode->GetFirstChild();
Text* textContent;
if (!childContent) {
// Set up a textnode with our value
RefPtr<nsTextNode> textNode =
new nsTextNode(mContent->NodeInfo()->NodeInfoManager());
textNode->MarkAsMaybeModifiedFrequently();--- a/layout/generic/BlockReflowInput.cpp
+++ b/layout/generic/BlockReflowInput.cpp
@@ -565,17 +565,17 @@ BlockReflowInput::RecoverStateFrom(nsLin
bool
BlockReflowInput::AddFloat(nsLineLayout* aLineLayout,
nsIFrame* aFloat,
nscoord aAvailableISize)
{
MOZ_ASSERT(aLineLayout, "must have line layout");
MOZ_ASSERT(mBlock->LinesEnd() != mCurrentLine, "null ptr");
MOZ_ASSERT(aFloat->GetStateBits() & NS_FRAME_OUT_OF_FLOW,
- "aFloat must be an out-of-flow frame");
+ "aFloat must be an out-of-flow frame");
MOZ_ASSERT(aFloat->GetParent(), "float must have parent");
MOZ_ASSERT(aFloat->GetParent()->IsFrameOfType(nsIFrame::eBlockFrame),
"float's parent must be block");
MOZ_ASSERT(aFloat->GetParent() == mBlock ||
(aFloat->GetStateBits() & NS_FRAME_IS_PUSHED_FLOAT),
"float should be in this block unless it was marked as "
"pushed float");
@@ -1138,9 +1138,8 @@ BlockReflowInput::ClearFloats(nscoord aB
if (nsBlockFrame::gNoisyReflow) {
nsFrame::IndentBy(stdout, nsBlockFrame::gNoiseIndent);
printf("clear floats: out: y=%d\n", newBCoord);
}
#endif
return newBCoord;
}
---- a/layout/generic/ReflowInput.cpp
+++ b/layout/generic/ReflowInput.cpp
@@ -186,17 +186,17 @@ ReflowInput::ReflowInput(
, mFlags(aParentReflowInput.mFlags)
, mReflowDepth(aParentReflowInput.mReflowDepth + 1)
{
MOZ_ASSERT(aPresContext, "no pres context");
MOZ_ASSERT(aFrame, "no frame");
MOZ_ASSERT(aPresContext == aFrame->PresContext(), "wrong pres context");
MOZ_ASSERT(!mFlags.mSpecialBSizeReflow ||
!NS_SUBTREE_DIRTY(aFrame),
- "frame should be clean when getting special bsize reflow");
+ "frame should be clean when getting special bsize reflow");
mParentReflowInput = &aParentReflowInput;
AvailableISize() = aAvailableSpace.ISize(mWritingMode);
AvailableBSize() = aAvailableSpace.BSize(mWritingMode);
if (mWritingMode.IsOrthogonalTo(aParentReflowInput.GetWritingMode())) {
// If we're setting up for an orthogonal flow, and the parent reflow state
@@ -1588,17 +1588,17 @@ void
ReflowInput::InitAbsoluteConstraints(nsPresContext* aPresContext,
const ReflowInput* aReflowInput,
const LogicalSize& aCBSize,
LayoutFrameType aFrameType)
{
WritingMode wm = GetWritingMode();
WritingMode cbwm = aReflowInput->GetWritingMode();
MOZ_ASSERT(aCBSize.BSize(cbwm) != NS_AUTOHEIGHT,
- "containing block bsize must be constrained");
+ "containing block bsize must be constrained");
NS_ASSERTION(aFrameType != LayoutFrameType::Table,
"InitAbsoluteConstraints should not be called on table frames");
NS_ASSERTION(mFrame->GetStateBits() & NS_FRAME_OUT_OF_FLOW,
"Why are we here?");
const auto& styleOffset = mStylePosition->mOffset;
bool iStartIsAuto = styleOffset.GetIStartUnit(cbwm) == eStyleUnit_Auto;--- a/layout/generic/TextOverflow.cpp
+++ b/layout/generic/TextOverflow.cpp
@@ -69,21 +69,20 @@ GetSelfOrNearestBlock(nsIFrame* aFrame)
}
// Return true if the frame is an atomic inline-level element.
// It's not supposed to be called for block frames since we never
// process block descendants for text-overflow.
static bool
IsAtomicElement(nsIFrame* aFrame, LayoutFrameType aFrameType)
{
- MOZ_ASSERT(!nsLayoutUtils::GetAsBlock(aFrame) ||
- !aFrame->IsBlockOutside(),
- "unexpected block frame");
+ MOZ_ASSERT(!nsLayoutUtils::GetAsBlock(aFrame) || !aFrame->IsBlockOutside(),
+ "unexpected block frame");
MOZ_ASSERT(aFrameType != LayoutFrameType::Placeholder,
- "unexpected placeholder frame");
+ "unexpected placeholder frame");
return !aFrame->IsFrameOfType(nsIFrame::eLineParticipant);
}
static bool
IsFullyClipped(nsTextFrame* aFrame, nscoord aLeft, nscoord aRight,
nscoord* aSnappedLeft, nscoord* aSnappedRight)
{
*aSnappedLeft = aLeft;
@@ -94,17 +93,17 @@ IsFullyClipped(nsTextFrame* aFrame, nsco
return !aFrame->MeasureCharClippedText(aLeft, aRight,
aSnappedLeft, aSnappedRight);
}
static bool
IsInlineAxisOverflowVisible(nsIFrame* aFrame)
{
MOZ_ASSERT(nsLayoutUtils::GetAsBlock(aFrame) != nullptr,
- "expected a block frame");
+ "expected a block frame");
nsIFrame* f = aFrame;
while (f && f->Style()->IsAnonBox() && !f->IsScrollFrame()) {
f = f->GetParent();
}
if (!f) {
return true;
}--- a/layout/generic/nsBlockFrame.cpp
+++ b/layout/generic/nsBlockFrame.cpp
@@ -5071,17 +5071,17 @@ nsBlockFrame::GetOverflowOutOfFlows() co
}
// This takes ownership of the frames
void
nsBlockFrame::SetOverflowOutOfFlows(const nsFrameList& aList,
nsFrameList* aPropValue)
{
MOZ_ASSERT(!!(GetStateBits() & NS_BLOCK_HAS_OVERFLOW_OUT_OF_FLOWS) ==
- !!aPropValue, "state does not match value");
+ !!aPropValue, "state does not match value");
if (aList.IsEmpty()) {
if (!(GetStateBits() & NS_BLOCK_HAS_OVERFLOW_OUT_OF_FLOWS)) {
return;
}
nsFrameList* list = RemovePropTableFrames(OverflowOutOfFlowsProperty());
NS_ASSERTION(aPropValue == list, "prop value mismatch");
list->Clear();
@@ -6244,17 +6244,17 @@ nsBlockFrame::AdjustFloatAvailableSpace(
}
nscoord
nsBlockFrame::ComputeFloatISize(BlockReflowInput& aState,
const LogicalRect& aFloatAvailableSpace,
nsIFrame* aFloat)
{
MOZ_ASSERT(aFloat->GetStateBits() & NS_FRAME_OUT_OF_FLOW,
- "aFloat must be an out-of-flow frame");
+ "aFloat must be an out-of-flow frame");
// Reflow the float.
LogicalRect availSpace = AdjustFloatAvailableSpace(aState,
aFloatAvailableSpace,
aFloat);
WritingMode blockWM = aState.mReflowInput.GetWritingMode();
WritingMode floatWM = aFloat->GetWritingMode();
@@ -6270,17 +6270,17 @@ nsBlockFrame::ReflowFloat(BlockReflowInp
const LogicalRect& aAdjustedAvailableSpace,
nsIFrame* aFloat,
LogicalMargin& aFloatMargin,
LogicalMargin& aFloatOffsets,
bool aFloatPushedDown,
nsReflowStatus& aReflowStatus)
{
MOZ_ASSERT(aFloat->GetStateBits() & NS_FRAME_OUT_OF_FLOW,
- "aFloat must be an out-of-flow frame");
+ "aFloat must be an out-of-flow frame");
// Reflow the float.
aReflowStatus.Reset();
WritingMode wm = aState.mReflowInput.GetWritingMode();
#ifdef NOISY_FLOAT
printf("Reflow Float %p in parent %p, availSpace(%d,%d,%d,%d)\n",
aFloat, this,--- a/layout/generic/nsContainerFrame.cpp
+++ b/layout/generic/nsContainerFrame.cpp
@@ -739,17 +739,17 @@ void
nsContainerFrame::DoInlineIntrinsicISize(gfxContext *aRenderingContext,
InlineIntrinsicISizeData *aData,
nsLayoutUtils::IntrinsicISizeType aType)
{
if (GetPrevInFlow())
return; // Already added.
MOZ_ASSERT(aType == nsLayoutUtils::MIN_ISIZE ||
- aType == nsLayoutUtils::PREF_ISIZE, "bad type");
+ aType == nsLayoutUtils::PREF_ISIZE, "bad type");
WritingMode wm = GetWritingMode();
mozilla::Side startSide =
wm.PhysicalSideForInlineAxis(eLogicalEdgeStart);
mozilla::Side endSide =
wm.PhysicalSideForInlineAxis(eLogicalEdgeEnd);
const nsStylePadding *stylePadding = StylePadding();
@@ -1395,17 +1395,17 @@ nsContainerFrame::StealFramesAfter(nsIFr
* Create a next-in-flow for aFrame. Will return the newly created
* frame <b>if and only if</b> a new frame is created; otherwise
* nullptr is returned.
*/
nsIFrame*
nsContainerFrame::CreateNextInFlow(nsIFrame* aFrame)
{
MOZ_ASSERT(!IsBlockFrame(),
- "you should have called nsBlockFrame::CreateContinuationFor instead");
+ "you should have called nsBlockFrame::CreateContinuationFor instead");
MOZ_ASSERT(mFrames.ContainsFrame(aFrame), "expected an in-flow child frame");
nsPresContext* pc = PresContext();
nsIFrame* nextInFlow = aFrame->GetNextInFlow();
if (nullptr == nextInFlow) {
// Create a continuation frame for the child frame and insert it
// into our child list.
nextInFlow = pc->PresShell()->FrameConstructor()->
@@ -2128,20 +2128,21 @@ nsOverflowContinuationTracker::StepForwa
}
nsresult
nsOverflowContinuationTracker::Insert(nsIFrame* aOverflowCont,
nsReflowStatus& aReflowStatus)
{
MOZ_ASSERT(aOverflowCont, "null frame pointer");
MOZ_ASSERT(!mSkipOverflowContainerChildren || mWalkOOFFrames ==
- !!(aOverflowCont->GetStateBits() & NS_FRAME_OUT_OF_FLOW),
- "shouldn't insert frame that doesn't match walker type");
+ !!(aOverflowCont->GetStateBits() & NS_FRAME_OUT_OF_FLOW),
+ "shouldn't insert frame that doesn't match walker type");
MOZ_ASSERT(aOverflowCont->GetPrevInFlow(),
- "overflow containers must have a prev-in-flow");
+ "overflow containers must have a prev-in-flow");
+
nsresult rv = NS_OK;
bool reparented = false;
nsPresContext* presContext = aOverflowCont->PresContext();
bool addToList = !mSentry || aOverflowCont != mSentry->GetNextInFlow();
// If we have a list and aOverflowCont is already in it then don't try to
// add it again.
if (addToList && aOverflowCont->GetParent() == mParent &&
@@ -2232,17 +2233,18 @@ nsOverflowContinuationTracker::Insert(ns
return rv;
}
void
nsOverflowContinuationTracker::BeginFinish(nsIFrame* aChild)
{
MOZ_ASSERT(aChild, "null ptr");
MOZ_ASSERT(aChild->GetNextInFlow(),
- "supposed to call Finish *before* deleting next-in-flow!");
+ "supposed to call Finish *before* deleting next-in-flow!");
+
for (nsIFrame* f = aChild; f; f = f->GetNextInFlow()) {
// We'll update these in EndFinish after the next-in-flows are gone.
if (f == mPrevOverflowCont) {
mSentry = nullptr;
mPrevOverflowCont = nullptr;
break;
}
if (f == mSentry) {--- a/layout/generic/nsFrame.cpp
+++ b/layout/generic/nsFrame.cpp
@@ -7968,17 +7968,17 @@ nsFrame::IsEmpty()
{
return false;
}
bool
nsIFrame::CachedIsEmpty()
{
MOZ_ASSERT(!(GetStateBits() & NS_FRAME_IS_DIRTY),
- "Must only be called on reflowed lines");
+ "Must only be called on reflowed lines");
return IsEmpty();
}
/* virtual */ bool
nsFrame::IsSelfEmpty()
{
return false;
}--- a/layout/generic/nsFrameList.cpp
+++ b/layout/generic/nsFrameList.cpp
@@ -185,27 +185,24 @@ nsFrameList::InsertFrames(nsContainerFra
return Slice(*this, firstNewFrame, nextSibling);
}
nsFrameList
nsFrameList::ExtractHead(FrameLinkEnumerator& aLink)
{
MOZ_ASSERT(&aLink.List() == this, "Unexpected list");
MOZ_ASSERT(!aLink.PrevFrame() ||
- aLink.PrevFrame()->GetNextSibling() ==
- aLink.NextFrame(),
- "Unexpected PrevFrame()");
- MOZ_ASSERT(aLink.PrevFrame() ||
- aLink.NextFrame() == FirstChild(),
- "Unexpected NextFrame()");
- MOZ_ASSERT(!aLink.PrevFrame() ||
- aLink.NextFrame() != FirstChild(),
- "Unexpected NextFrame()");
+ aLink.PrevFrame()->GetNextSibling() == aLink.NextFrame(),
+ "Unexpected PrevFrame()");
+ MOZ_ASSERT(aLink.PrevFrame() || aLink.NextFrame() == FirstChild(),
+ "Unexpected NextFrame()");
+ MOZ_ASSERT(!aLink.PrevFrame() || aLink.NextFrame() != FirstChild(),
+ "Unexpected NextFrame()");
MOZ_ASSERT(aLink.mEnd == nullptr,
- "Unexpected mEnd for frame link enumerator");
+ "Unexpected mEnd for frame link enumerator");
nsIFrame* prev = aLink.PrevFrame();
nsIFrame* newFirstFrame = nullptr;
if (prev) {
// Truncate the list after |prev| and hand the first part to our new list.
prev->SetNextSibling(nullptr);
newFirstFrame = mFirstChild;
mFirstChild = aLink.NextFrame();
@@ -221,27 +218,24 @@ nsFrameList::ExtractHead(FrameLinkEnumer
return nsFrameList(newFirstFrame, prev);
}
nsFrameList
nsFrameList::ExtractTail(FrameLinkEnumerator& aLink)
{
MOZ_ASSERT(&aLink.List() == this, "Unexpected list");
MOZ_ASSERT(!aLink.PrevFrame() ||
- aLink.PrevFrame()->GetNextSibling() ==
- aLink.NextFrame(),
- "Unexpected PrevFrame()");
- MOZ_ASSERT(aLink.PrevFrame() ||
- aLink.NextFrame() == FirstChild(),
- "Unexpected NextFrame()");
- MOZ_ASSERT(!aLink.PrevFrame() ||
- aLink.NextFrame() != FirstChild(),
- "Unexpected NextFrame()");
+ aLink.PrevFrame()->GetNextSibling() == aLink.NextFrame(),
+ "Unexpected PrevFrame()");
+ MOZ_ASSERT(aLink.PrevFrame() || aLink.NextFrame() == FirstChild(),
+ "Unexpected NextFrame()");
+ MOZ_ASSERT(!aLink.PrevFrame() || aLink.NextFrame() != FirstChild(),
+ "Unexpected NextFrame()");
MOZ_ASSERT(aLink.mEnd == nullptr,
- "Unexpected mEnd for frame link enumerator");
+ "Unexpected mEnd for frame link enumerator");
nsIFrame* prev = aLink.PrevFrame();
nsIFrame* newFirstFrame;
nsIFrame* newLastFrame;
if (prev) {
// Truncate the list after |prev| and hand the second part to our new list
prev->SetNextSibling(nullptr);
newFirstFrame = aLink.NextFrame();--- a/layout/generic/nsFrameSelection.cpp
+++ b/layout/generic/nsFrameSelection.cpp
@@ -2056,18 +2056,17 @@ nsFrameSelection::ClearNormalSelection()
static nsIContent*
GetFirstSelectedContent(nsRange* aRange)
{
if (!aRange) {
return nullptr;
}
MOZ_ASSERT(aRange->GetStartContainer(), "Must have start parent!");
- MOZ_ASSERT(aRange->GetStartContainer()->IsElement(),
- "Unexpected parent");
+ MOZ_ASSERT(aRange->GetStartContainer()->IsElement(), "Unexpected parent");
return aRange->GetChildAtStartOffset();
}
// Table selection support.
// TODO: Separate table methods into a separate nsITableSelection interface
nsresult
nsFrameSelection::HandleTableSelection(nsINode* aParentContent,--- a/layout/generic/nsLineBox.cpp
+++ b/layout/generic/nsLineBox.cpp
@@ -735,17 +735,17 @@ nsLineIterator::CheckLineOrder(int32_t
NS_IMETHODIMP
nsLineIterator::FindFrameAt(int32_t aLineNumber,
nsPoint aPos,
nsIFrame** aFrameFound,
bool* aPosIsBeforeFirstFrame,
bool* aPosIsAfterLastFrame)
{
MOZ_ASSERT(aFrameFound && aPosIsBeforeFirstFrame && aPosIsAfterLastFrame,
- "null OUT ptr");
+ "null OUT ptr");
if (!aFrameFound || !aPosIsBeforeFirstFrame || !aPosIsAfterLastFrame) {
return NS_ERROR_NULL_POINTER;
}
if ((aLineNumber < 0) || (aLineNumber >= mNumLines)) {
return NS_ERROR_INVALID_ARG;
}
@@ -968,17 +968,17 @@ nsFloatCacheFreeList::DeleteAll()
nsFloatCacheList::DeleteAll();
mTail = nullptr;
}
nsFloatCache*
nsFloatCacheFreeList::Alloc(nsIFrame* aFloat)
{
MOZ_ASSERT(aFloat->GetStateBits() & NS_FRAME_OUT_OF_FLOW,
- "This is a float cache, why isn't the frame out-of-flow?");
+ "This is a float cache, why isn't the frame out-of-flow?");
nsFloatCache* fc = mHead;
if (mHead) {
if (mHead == mTail) {
mHead = mTail = nullptr;
}
else {
mHead = fc->mNext;--- a/layout/generic/nsLineLayout.cpp
+++ b/layout/generic/nsLineLayout.cpp
@@ -456,17 +456,17 @@ nsLineLayout::EndSpan(nsIFrame* aFrame)
mCurrentSpan = mCurrentSpan->mParent;
return iSizeResult;
}
void
nsLineLayout::AttachFrameToBaseLineLayout(PerFrameData* aFrame)
{
MOZ_ASSERT(mBaseLineLayout,
- "This method must not be called in a base line layout.");
+ "This method must not be called in a base line layout.");
PerFrameData* baseFrame = mBaseLineLayout->LastFrame();
MOZ_ASSERT(aFrame && baseFrame);
MOZ_ASSERT(!aFrame->mIsLinkedToBase,
"The frame must not have been linked with the base");
#ifdef DEBUG
LayoutFrameType baseType = baseFrame->mFrame->Type();
LayoutFrameType annotationType = aFrame->mFrame->Type();--- a/layout/generic/nsPlaceholderFrame.h
+++ b/layout/generic/nsPlaceholderFrame.h
@@ -172,17 +172,17 @@ public:
return aFrame;
}
/**
* @return the out-of-flow for aFrame, which is known to be a placeholder
*/
static nsIFrame* GetRealFrameForPlaceholder(nsIFrame* aFrame) {
MOZ_ASSERT(aFrame->IsPlaceholderFrame(),
- "Must have placeholder frame as input");
+ "Must have placeholder frame as input");
nsIFrame* outOfFlow =
static_cast<nsPlaceholderFrame*>(aFrame)->GetOutOfFlowFrame();
NS_ASSERTION(outOfFlow, "Null out-of-flow for placeholder?");
return outOfFlow;
}
protected:
nsIFrame* mOutOfFlowFrame;--- a/layout/generic/nsSimplePageSequenceFrame.cpp
+++ b/layout/generic/nsSimplePageSequenceFrame.cpp
@@ -143,17 +143,17 @@ nsSimplePageSequenceFrame::ComputeCenter
void
nsSimplePageSequenceFrame::Reflow(nsPresContext* aPresContext,
ReflowOutput& aDesiredSize,
const ReflowInput& aReflowInput,
nsReflowStatus& aStatus)
{
MarkInReflow();
MOZ_ASSERT(aPresContext->IsRootPaginatedDocument(),
- "A Page Sequence is only for real pages");
+ "A Page Sequence is only for real pages");
DO_GLOBAL_REFLOW_COUNT("nsSimplePageSequenceFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowInput, aDesiredSize, aStatus);
MOZ_ASSERT(aStatus.IsEmpty(), "Caller should pass a fresh reflow status!");
NS_FRAME_TRACE_REFLOW_IN("nsSimplePageSequenceFrame::Reflow");
// Don't do incremental reflow until we've taught tables how to do
// it right in paginated mode.
if (!(GetStateBits() & NS_FRAME_FIRST_REFLOW)) {--- a/layout/generic/nsTextFrame.cpp
+++ b/layout/generic/nsTextFrame.cpp
@@ -578,21 +578,21 @@ GetFrameForSimpleFlow(const gfxTextRun*
*/
static bool
ClearAllTextRunReferences(nsTextFrame* aFrame, gfxTextRun* aTextRun,
nsTextFrame* aStartContinuation,
nsFrameState aWhichTextRunState)
{
MOZ_ASSERT(aFrame, "null frame");
MOZ_ASSERT(!aStartContinuation ||
- (!aStartContinuation->GetTextRun(nsTextFrame::eInflated) ||
- aStartContinuation->GetTextRun(nsTextFrame::eInflated) == aTextRun) ||
- (!aStartContinuation->GetTextRun(nsTextFrame::eNotInflated) ||
- aStartContinuation->GetTextRun(nsTextFrame::eNotInflated) == aTextRun),
- "wrong aStartContinuation for this text run");
+ (!aStartContinuation->GetTextRun(nsTextFrame::eInflated) ||
+ aStartContinuation->GetTextRun(nsTextFrame::eInflated) == aTextRun) ||
+ (!aStartContinuation->GetTextRun(nsTextFrame::eNotInflated) ||
+ aStartContinuation->GetTextRun(nsTextFrame::eNotInflated) == aTextRun),
+ "wrong aStartContinuation for this text run");
if (!aStartContinuation || aStartContinuation == aFrame) {
aFrame->RemoveStateBits(aWhichTextRunState);
} else {
do {
NS_ASSERTION(aFrame->IsTextFrame(), "Bad frame");
aFrame = aFrame->GetNextContinuation();
} while (aFrame && aFrame != aStartContinuation);
@@ -3283,17 +3283,18 @@ static void FindClusterStart(const gfxTe
* start.
*/
static void FindClusterEnd(const gfxTextRun* aTextRun,
int32_t aOriginalEnd,
gfxSkipCharsIterator* aPos,
bool aAllowSplitLigature = true)
{
MOZ_ASSERT(aPos->GetOriginalOffset() < aOriginalEnd,
- "character outside string");
+ "character outside string");
+
aPos->AdvanceOriginal(1);
while (aPos->GetOriginalOffset() < aOriginalEnd) {
if (aPos->IsOriginalCharSkipped() ||
(aTextRun->IsClusterStart(aPos->GetSkippedOffset()) &&
(aAllowSplitLigature ||
aTextRun->IsLigatureGroupStart(aPos->GetSkippedOffset())))) {
break;
}
@@ -6692,18 +6693,19 @@ nsTextFrame::GetCaretColorAt(int32_t aOf
MOZ_ASSERT(aOffset >= 0, "aOffset must be positive");
nscolor result = nsFrame::GetCaretColorAt(aOffset);
gfxSkipCharsIterator iter = EnsureTextRun(nsTextFrame::eInflated);
PropertyProvider provider(this, iter, nsTextFrame::eInflated);
int32_t contentOffset = provider.GetStart().GetOriginalOffset();
int32_t contentLength = provider.GetOriginalLength();
MOZ_ASSERT(aOffset >= contentOffset &&
- aOffset <= contentOffset + contentLength,
- "aOffset must be in the frame's range");
+ aOffset <= contentOffset + contentLength,
+ "aOffset must be in the frame's range");
+
int32_t offsetInFrame = aOffset - contentOffset;
if (offsetInFrame < 0 || offsetInFrame >= contentLength) {
return result;
}
bool isSolidTextColor = true;
if (nsSVGUtils::IsInSVGTextSubtree(this)) {
const nsStyleSVG* style = StyleSVG();--- a/layout/painting/nsCSSRendering.cpp
+++ b/layout/painting/nsCSSRendering.cpp
@@ -2019,17 +2019,17 @@ nsCSSRendering::PaintBGParams::ForSingle
ImgDrawResult
nsCSSRendering::PaintStyleImageLayer(const PaintBGParams& aParams,
gfxContext& aRenderingCtx)
{
AUTO_PROFILER_LABEL("nsCSSRendering::PaintStyleImageLayer", GRAPHICS);
MOZ_ASSERT(aParams.frame,
- "Frame is expected to be provided to PaintStyleImageLayer");
+ "Frame is expected to be provided to PaintStyleImageLayer");
ComputedStyle *sc;
if (!FindBackground(aParams.frame, &sc)) {
// We don't want to bail out if moz-appearance is set on a root
// node. If it has a parent content node, bail because it's not
// a root, otherwise keep going in order to let the theme stuff
// draw the background. The canvas really should be drawing the
// bg, but there's no way to hook that up via css.
@@ -2617,17 +2617,17 @@ DetermineCompositionOp(const nsCSSRender
ImgDrawResult
nsCSSRendering::PaintStyleImageLayerWithSC(const PaintBGParams& aParams,
gfxContext& aRenderingCtx,
ComputedStyle *aBackgroundSC,
const nsStyleBorder& aBorder)
{
MOZ_ASSERT(aParams.frame,
- "Frame is expected to be provided to PaintStyleImageLayerWithSC");
+ "Frame is expected to be provided to PaintStyleImageLayerWithSC");
// If we're drawing all layers, aCompositonOp is ignored, so make sure that
// it was left at its default value.
MOZ_ASSERT(aParams.layer != -1 ||
aParams.compositionOp == CompositionOp::OP_OVER);
// Check to see if we have an appearance defined. If so, we let the theme
// renderer draw the background and bail out.--- a/layout/painting/nsDisplayList.cpp
+++ b/layout/painting/nsDisplayList.cpp
@@ -7988,19 +7988,19 @@ nsDisplayTransform::nsDisplayTransform(n
*/
/* static */ Point3D
nsDisplayTransform::GetDeltaToTransformOrigin(const nsIFrame* aFrame,
float aAppUnitsPerPixel,
const nsRect* aBoundsOverride)
{
MOZ_ASSERT(aFrame, "Can't get delta for a null frame!");
MOZ_ASSERT(aFrame->IsTransformed() ||
- aFrame->BackfaceIsHidden() ||
- aFrame->Combines3DTransformWithAncestors(),
- "Shouldn't get a delta for an untransformed frame!");
+ aFrame->BackfaceIsHidden() ||
+ aFrame->Combines3DTransformWithAncestors(),
+ "Shouldn't get a delta for an untransformed frame!");
if (!aFrame->IsTransformed()) {
return Point3D();
}
/* For both of the coordinates, if the value of transform is a
* percentage, it's relative to the size of the frame. Otherwise, if it's
* a distance, it's already computed for us!
@@ -8063,19 +8063,19 @@ nsDisplayTransform::GetDeltaToTransformO
/* static */ bool
nsDisplayTransform::ComputePerspectiveMatrix(const nsIFrame* aFrame,
float aAppUnitsPerPixel,
Matrix4x4& aOutMatrix)
{
MOZ_ASSERT(aFrame, "Can't get delta for a null frame!");
MOZ_ASSERT(aFrame->IsTransformed() ||
- aFrame->BackfaceIsHidden() ||
- aFrame->Combines3DTransformWithAncestors(),
- "Shouldn't get a delta for an untransformed frame!");
+ aFrame->BackfaceIsHidden() ||
+ aFrame->Combines3DTransformWithAncestors(),
+ "Shouldn't get a delta for an untransformed frame!");
MOZ_ASSERT(aOutMatrix.IsIdentity(), "Must have a blank output matrix");
if (!aFrame->IsTransformed()) {
return false;
}
/* Find our containing block, which is the element that provides the
* value for perspective we need to use--- a/layout/style/Loader.cpp
+++ b/layout/style/Loader.cpp
@@ -1293,17 +1293,17 @@ Loader::LoadSheet(SheetLoadData* aLoadDa
bool aIsPreload)
{
LOG(("css::Loader::LoadSheet"));
MOZ_ASSERT(aLoadData, "Need a load data");
MOZ_ASSERT(aLoadData->mURI, "Need a URI to load");
MOZ_ASSERT(aLoadData->mSheet, "Need a sheet to load into");
MOZ_ASSERT(aSheetState != eSheetComplete, "Why bother?");
MOZ_ASSERT(!aLoadData->mUseSystemPrincipal || aLoadData->mSyncLoad,
- "Shouldn't use system principal for async loads");
+ "Shouldn't use system principal for async loads");
NS_ASSERTION(mSheets, "mLoadingDatas should be initialized by now.");
LOG_URI(" Load from: '%s'", aLoadData->mURI);
nsresult rv = NS_OK;
if (!mDocument && !aLoadData->mIsNonDocumentSheet) {
// No point starting the load; just release all the data and such.
@@ -2364,17 +2364,17 @@ Loader::InternalLoadNonDocumentSheet(nsI
nsICSSLoaderObserver* aObserver,
CORSMode aCORSMode,
ReferrerPolicy aReferrerPolicy,
const nsAString& aIntegrity)
{
MOZ_ASSERT(aURL, "Must have a URI to load");
MOZ_ASSERT(aSheet || aObserver, "Sheet and observer can't both be null");
MOZ_ASSERT(!aUseSystemPrincipal || !aObserver,
- "Shouldn't load system-principal sheets async");
+ "Shouldn't load system-principal sheets async");
LOG_URI(" Non-document sheet uri: '%s'", aURL);
if (aSheet) {
*aSheet = nullptr;
}
if (!mEnabled) {
@@ -2448,17 +2448,17 @@ Loader::PostLoadEvent(nsIURI* aURI,
nsICSSLoaderObserver* aObserver,
IsAlternate aWasAlternate,
MediaMatched aMediaMatched,
nsIStyleSheetLinkingElement* aElement)
{
LOG(("css::Loader::PostLoadEvent"));
MOZ_ASSERT(aSheet, "Must have sheet");
MOZ_ASSERT(aObserver || !mObservers.IsEmpty() || aElement,
- "Must have observer or element");
+ "Must have observer or element");
RefPtr<SheetLoadData> evt =
new SheetLoadData(this, EmptyString(), // title doesn't matter here
aURI,
aSheet,
aElement,
aWasAlternate == IsAlternate::Yes,
aMediaMatched == MediaMatched::Yes,--- a/layout/style/nsDOMCSSDeclaration.cpp
+++ b/layout/style/nsDOMCSSDeclaration.cpp
@@ -34,17 +34,17 @@ nsDOMCSSDeclaration::WrapObject(JSContex
NS_IMPL_QUERY_INTERFACE(nsDOMCSSDeclaration,
nsICSSDeclaration)
nsresult
nsDOMCSSDeclaration::GetPropertyValue(const nsCSSPropertyID aPropID,
nsAString& aValue)
{
MOZ_ASSERT(aPropID != eCSSProperty_UNKNOWN,
- "Should never pass eCSSProperty_UNKNOWN around");
+ "Should never pass eCSSProperty_UNKNOWN around");
aValue.Truncate();
if (DeclarationBlock* decl = GetCSSDeclaration(eOperation_Read)) {
decl->GetPropertyValueByID(aPropID, aValue);
}
return NS_OK;
}
--- a/layout/style/nsROCSSPrimitiveValue.cpp
+++ b/layout/style/nsROCSSPrimitiveValue.cpp
@@ -528,18 +528,18 @@ nsROCSSPrimitiveValue::SetAppUnits(float
{
SetAppUnits(NSToCoordRound(aValue));
}
void
nsROCSSPrimitiveValue::SetIdent(nsCSSKeyword aKeyword)
{
MOZ_ASSERT(aKeyword != eCSSKeyword_UNKNOWN &&
- 0 <= aKeyword && aKeyword < eCSSKeyword_COUNT,
- "bad keyword");
+ 0 <= aKeyword && aKeyword < eCSSKeyword_COUNT,
+ "bad keyword");
Reset();
mValue.mKeyword = aKeyword;
mType = CSSPrimitiveValueBinding::CSS_IDENT;
}
// FIXME: CSS_STRING should imply a string with "" and a need for escaping.
void
nsROCSSPrimitiveValue::SetString(const nsACString& aString, uint16_t aType)--- a/layout/style/nsStyleUtil.cpp
+++ b/layout/style/nsStyleUtil.cpp
@@ -85,17 +85,17 @@ nsStyleUtil::ValueIncludes(const nsAStri
return false;
}
void nsStyleUtil::AppendEscapedCSSString(const nsAString& aString,
nsAString& aReturn,
char16_t quoteChar)
{
MOZ_ASSERT(quoteChar == '\'' || quoteChar == '"',
- "CSS strings must be quoted with ' or \"");
+ "CSS strings must be quoted with ' or \"");
aReturn.Append(quoteChar);
const char16_t* in = aString.BeginReading();
const char16_t* const end = aString.EndReading();
for (; in != end; in++) {
if (*in < 0x20 || *in == 0x7F) {
// Escape U+0000 through U+001F and U+007F numerically.
@@ -396,17 +396,17 @@ nsStyleUtil::AppendFontFeatureSettings(c
nsCSSUnit unit = aSrc.GetUnit();
if (unit == eCSSUnit_Normal) {
aResult.AppendLiteral("normal");
return;
}
MOZ_ASSERT(unit == eCSSUnit_PairList || unit == eCSSUnit_PairListDep,
- "improper value unit for font-feature-settings:");
+ "improper value unit for font-feature-settings:");
nsTArray<gfxFontFeature> featureSettings;
nsLayoutUtils::ComputeFontFeatures(aSrc.GetPairListValue(), featureSettings);
AppendFontFeatureSettings(featureSettings, aResult);
}
/* static */ void
nsStyleUtil::AppendFontVariationSettings(const nsTArray<gfxFontVariation>& aVariations,
@@ -435,17 +435,17 @@ nsStyleUtil::AppendFontVariationSettings
nsCSSUnit unit = aSrc.GetUnit();
if (unit == eCSSUnit_Normal) {
aResult.AppendLiteral("normal");
return;
}
MOZ_ASSERT(unit == eCSSUnit_PairList || unit == eCSSUnit_PairListDep,
- "improper value unit for font-variation-settings:");
+ "improper value unit for font-variation-settings:");
nsTArray<gfxFontVariation> variationSettings;
nsLayoutUtils::ComputeFontVariations(aSrc.GetPairListValue(),
variationSettings);
AppendFontVariationSettings(variationSettings, aResult);
}
/* static */ void
@@ -568,18 +568,19 @@ AppendSerializedUnicodePoint(uint32_t aC
// A unicode-range: descriptor is represented as an array of integers,
// to be interpreted as a sequence of pairs: min max min max ...
// It is in source order. (Possibly it should be sorted and overlaps
// consolidated, but right now we don't do that.)
/* static */ void
nsStyleUtil::AppendUnicodeRange(const nsCSSValue& aValue, nsAString& aResult)
{
MOZ_ASSERT(aValue.GetUnit() == eCSSUnit_Null ||
- aValue.GetUnit() == eCSSUnit_Array,
- "improper value unit for unicode-range:");
+ aValue.GetUnit() == eCSSUnit_Array,
+ "improper value unit for unicode-range:");
+
aResult.Truncate();
if (aValue.GetUnit() != eCSSUnit_Array)
return;
nsCSSValue::Array const & sources = *aValue.GetArrayValue();
nsAutoCString buf;
MOZ_ASSERT(sources.Count() % 2 == 0,
@@ -609,17 +610,17 @@ nsStyleUtil::AppendSerializedFontSrc(con
{
// A src: descriptor is represented as an array value; each entry in
// the array can be eCSSUnit_URL, eCSSUnit_Local_Font, or
// eCSSUnit_Font_Format. Blocks of eCSSUnit_Font_Format may appear
// only after one of the first two. (css3-fonts only contemplates
// annotating URLs with formats, but we handle the general case.)
MOZ_ASSERT(aValue.GetUnit() == eCSSUnit_Array,
- "improper value unit for src:");
+ "improper value unit for src:");
const nsCSSValue::Array& sources = *aValue.GetArrayValue();
size_t i = 0;
while (i < sources.Count()) {
nsAutoString formats;
if (sources[i].GetUnit() == eCSSUnit_URL) {--- a/layout/tables/nsCellMap.cpp
+++ b/layout/tables/nsCellMap.cpp
@@ -665,17 +665,17 @@ nsTableCellMap::RebuildConsideringCells(
void
nsTableCellMap::RebuildConsideringRows(nsCellMap* aCellMap,
int32_t aStartRowIndex,
nsTArray<nsTableRowFrame*>* aRowsToInsert,
int32_t aNumRowsToRemove,
TableArea& aDamageArea)
{
MOZ_ASSERT(!aRowsToInsert || aNumRowsToRemove == 0,
- "Can't handle both removing and inserting rows at once");
+ "Can't handle both removing and inserting rows at once");
int32_t numOrigCols = GetColCount();
ClearCols();
nsCellMap* cellMap = mFirstMap;
int32_t rowCount = 0;
while (cellMap) {
if (cellMap == aCellMap) {
cellMap->RebuildConsideringRows(*this, aStartRowIndex, aRowsToInsert,--- a/layout/tables/nsTableFrame.cpp
+++ b/layout/tables/nsTableFrame.cpp
@@ -154,17 +154,17 @@ nsTableFrame::nsTableFrame(ComputedStyle
void
nsTableFrame::Init(nsIContent* aContent,
nsContainerFrame* aParent,
nsIFrame* aPrevInFlow)
{
MOZ_ASSERT(!mCellMap, "Init called twice");
MOZ_ASSERT(!mTableLayoutStrategy, "Init called twice");
MOZ_ASSERT(!aPrevInFlow || aPrevInFlow->IsTableFrame(),
- "prev-in-flow must be of same type");
+ "prev-in-flow must be of same type");
// Let the base class do its processing
nsContainerFrame::Init(aContent, aParent, aPrevInFlow);
// see if border collapse is on, if so set it
const nsStyleTableBorder* tableStyle = StyleTableBorder();
bool borderCollapse = (NS_STYLE_BORDER_COLLAPSE == tableStyle->mBorderCollapse);
SetBorderCollapse(borderCollapse);
@@ -780,18 +780,17 @@ nsTableFrame::MatchCellMapToColCache(nsT
aCellMap->AddColsAtEnd(numColsNotRemoved);
}
}
}
void
nsTableFrame::DidResizeColumns()
{
- MOZ_ASSERT(!GetPrevInFlow(),
- "should only be called on first-in-flow");
+ MOZ_ASSERT(!GetPrevInFlow(), "should only be called on first-in-flow");
if (mBits.mResizedColumns)
return; // already marked
for (nsTableFrame *f = this; f;
f = static_cast<nsTableFrame*>(f->GetNextInFlow()))
f->mBits.mResizedColumns = true;
}--- a/layout/tables/nsTableRowGroupFrame.cpp
+++ b/layout/tables/nsTableRowGroupFrame.cpp
@@ -1062,17 +1062,17 @@ void
nsTableRowGroupFrame::UndoContinuedRow(nsPresContext* aPresContext,
nsTableRowFrame* aRow)
{
if (!aRow) return; // allow null aRow to avoid callers doing null checks
// rowBefore was the prev-sibling of aRow's next-sibling before aRow was created
nsTableRowFrame* rowBefore = (nsTableRowFrame*)aRow->GetPrevInFlow();
MOZ_ASSERT(mFrames.ContainsFrame(rowBefore),
- "rowBefore not in our frame list?");
+ "rowBefore not in our frame list?");
AutoFrameListPtr overflows(aPresContext, StealOverflowFrames());
if (!rowBefore || !overflows || overflows->IsEmpty() ||
overflows->FirstChild() != aRow) {
NS_ERROR("invalid continued row");
return;
}
--- a/layout/xul/nsPopupSetFrame.cpp
+++ b/layout/xul/nsPopupSetFrame.cpp
@@ -130,18 +130,18 @@ nsPopupSetFrame::DoXULLayout(nsBoxLayout
return rv;
}
void
nsPopupSetFrame::RemovePopupFrame(nsIFrame* aPopup)
{
MOZ_ASSERT((aPopup->GetStateBits() & NS_FRAME_OUT_OF_FLOW) &&
- aPopup->IsMenuPopupFrame(),
- "removing wrong type of frame in popupset's ::popupList");
+ aPopup->IsMenuPopupFrame(),
+ "removing wrong type of frame in popupset's ::popupList");
mPopupList.DestroyFrame(aPopup);
}
void
nsPopupSetFrame::AddPopupFrameList(nsFrameList& aPopupFrameList)
{
#ifdef DEBUG--- a/layout/xul/nsSprocketLayout.cpp
+++ b/layout/xul/nsSprocketLayout.cpp
@@ -908,17 +908,17 @@ nsSprocketLayout::AlignChildren(nsIFrame
{
nsFrameState frameState = nsFrameState(0);
GetFrameState(aBox, frameState);
bool isHorizontal = (frameState & NS_STATE_IS_HORIZONTAL) != 0;
nsRect clientRect;
aBox->GetXULClientRect(clientRect);
MOZ_ASSERT(!(frameState & NS_STATE_AUTO_STRETCH),
- "Only AlignChildren() with non-stretch alignment");
+ "Only AlignChildren() with non-stretch alignment");
// These are only calculated if needed
nsIFrame::Halignment halign;
nsIFrame::Valignment valign;
nscoord maxAscent = 0;
bool isLTR;
if (isHorizontal) {--- a/netwerk/base/nsStandardURL.cpp
+++ b/netwerk/base/nsStandardURL.cpp
@@ -3143,17 +3143,18 @@ nsStandardURL::SetFileExtensionInternal(
//----------------------------------------------------------------------------
// nsStandardURL::nsIFileURL
//----------------------------------------------------------------------------
nsresult
nsStandardURL::EnsureFile()
{
MOZ_ASSERT(mSupportsFileURL,
- "EnsureFile() called on a URL that doesn't support files!");
+ "EnsureFile() called on a URL that doesn't support files!");
+
if (mFile) {
// Nothing to do
return NS_OK;
}
// Parse the spec if we don't have a cached result
if (mSpec.IsEmpty()) {
NS_WARNING("url not initialized");
@@ -3167,17 +3168,18 @@ nsStandardURL::EnsureFile()
return net_GetFileFromURLSpec(mSpec, getter_AddRefs(mFile));
}
NS_IMETHODIMP
nsStandardURL::GetFile(nsIFile **result)
{
MOZ_ASSERT(mSupportsFileURL,
- "GetFile() called on a URL that doesn't support files!");
+ "GetFile() called on a URL that doesn't support files!");
+
nsresult rv = EnsureFile();
if (NS_FAILED(rv))
return rv;
if (LOG_ENABLED()) {
LOG(("nsStandardURL::GetFile [this=%p spec=%s resulting_path=%s]\n",
this, mSpec.get(), mFile->HumanReadablePath().get()));
}--- a/parser/html/nsHtml5Parser.cpp
+++ b/parser/html/nsHtml5Parser.cpp
@@ -98,18 +98,17 @@ nsHtml5Parser::SetCommand(eParserCommand
"Parser command was not eViewNormal.");
}
void
nsHtml5Parser::SetDocumentCharset(NotNull<const Encoding*> aEncoding,
int32_t aCharsetSource)
{
MOZ_ASSERT(!mExecutor->HasStarted(), "Document charset set too late.");
- MOZ_ASSERT(GetStreamParser(),
- "Setting charset on a script-only parser.");
+ MOZ_ASSERT(GetStreamParser(), "Setting charset on a script-only parser.");
GetStreamParser()->SetDocumentCharset(aEncoding, aCharsetSource);
mExecutor->SetDocumentCharsetAndSource(aEncoding, aCharsetSource);
}
NS_IMETHODIMP
nsHtml5Parser::GetChannel(nsIChannel** aChannel)
{
if (GetStreamParser()) {
@@ -183,19 +182,20 @@ nsHtml5Parser::Parse(nsIURI* aURL,
void* aKey, // legacy; ignored
nsDTDMode aMode) // legacy; ignored
{
/*
* Do NOT cause WillBuildModel to be called synchronously from here!
* The document won't be ready for it until OnStartRequest!
*/
MOZ_ASSERT(!mExecutor->HasStarted(),
- "Tried to start parse without initializing the parser.");
+ "Tried to start parse without initializing the parser.");
MOZ_ASSERT(GetStreamParser(),
- "Can't call this Parse() variant on script-created parser");
+ "Can't call this Parse() variant on script-created parser");
+
GetStreamParser()->SetObserver(aObserver);
GetStreamParser()->SetViewSourceTitle(aURL); // In case we're viewing source
mExecutor->SetStreamParser(GetStreamParser());
mExecutor->SetParser(this);
return NS_OK;
}
nsresult--- a/parser/html/nsHtml5SpeculativeLoad.h
+++ b/parser/html/nsHtml5SpeculativeLoad.h
@@ -43,53 +43,53 @@ class nsHtml5SpeculativeLoad
public:
nsHtml5SpeculativeLoad();
~nsHtml5SpeculativeLoad();
inline void InitBase(nsHtml5String aUrl)
{
MOZ_ASSERT(mOpCode == eSpeculativeLoadUninitialized,
- "Trying to reinitialize a speculative load!");
+ "Trying to reinitialize a speculative load!");
mOpCode = eSpeculativeLoadBase;
aUrl.ToString(mUrlOrSizes);
}
inline void InitMetaCSP(nsHtml5String aCSP)
{
MOZ_ASSERT(mOpCode == eSpeculativeLoadUninitialized,
- "Trying to reinitialize a speculative load!");
+ "Trying to reinitialize a speculative load!");
mOpCode = eSpeculativeLoadCSP;
nsString csp; // Not Auto, because using it to hold nsStringBuffer*
aCSP.ToString(csp);
mTypeOrCharsetSourceOrDocumentModeOrMetaCSPOrSizesOrIntegrity.Assign(
nsContentUtils::TrimWhitespace<nsContentUtils::IsHTMLWhitespace>(csp));
}
inline void InitMetaReferrerPolicy(nsHtml5String aReferrerPolicy)
{
MOZ_ASSERT(mOpCode == eSpeculativeLoadUninitialized,
- "Trying to reinitialize a speculative load!");
+ "Trying to reinitialize a speculative load!");
mOpCode = eSpeculativeLoadMetaReferrer;
nsString
referrerPolicy; // Not Auto, because using it to hold nsStringBuffer*
aReferrerPolicy.ToString(referrerPolicy);
mReferrerPolicyOrIntegrity.Assign(
nsContentUtils::TrimWhitespace<nsContentUtils::IsHTMLWhitespace>(
referrerPolicy));
}
inline void InitImage(nsHtml5String aUrl,
nsHtml5String aCrossOrigin,
nsHtml5String aReferrerPolicy,
nsHtml5String aSrcset,
nsHtml5String aSizes)
{
MOZ_ASSERT(mOpCode == eSpeculativeLoadUninitialized,
- "Trying to reinitialize a speculative load!");
+ "Trying to reinitialize a speculative load!");
mOpCode = eSpeculativeLoadImage;
aUrl.ToString(mUrlOrSizes);
aCrossOrigin.ToString(mCrossOriginOrMedia);
nsString
referrerPolicy; // Not Auto, because using it to hold nsStringBuffer*
aReferrerPolicy.ToString(referrerPolicy);
mReferrerPolicyOrIntegrity.Assign(
nsContentUtils::TrimWhitespace<nsContentUtils::IsHTMLWhitespace>(
@@ -104,34 +104,34 @@ public:
// can't determine validity at this point without parsing CSS and getting
// main thread state, we push preload operations for picture pushed and
// popped, so that the target of the preload ops can determine what picture
// and nesting level each source/img from the main preloading code exists
// at.
inline void InitOpenPicture()
{
MOZ_ASSERT(mOpCode == eSpeculativeLoadUninitialized,
- "Trying to reinitialize a speculative load!");
+ "Trying to reinitialize a speculative load!");
mOpCode = eSpeculativeLoadOpenPicture;
}
inline void InitEndPicture()
{
MOZ_ASSERT(mOpCode == eSpeculativeLoadUninitialized,
- "Trying to reinitialize a speculative load!");
+ "Trying to reinitialize a speculative load!");
mOpCode = eSpeculativeLoadEndPicture;
}
inline void InitPictureSource(nsHtml5String aSrcset,
nsHtml5String aSizes,
nsHtml5String aType,
nsHtml5String aMedia)
{
MOZ_ASSERT(mOpCode == eSpeculativeLoadUninitialized,
- "Trying to reinitialize a speculative load!");
+ "Trying to reinitialize a speculative load!");
mOpCode = eSpeculativeLoadPictureSource;
aSrcset.ToString(mCharsetOrSrcset);
aSizes.ToString(mUrlOrSizes);
aType.ToString(
mTypeOrCharsetSourceOrDocumentModeOrMetaCSPOrSizesOrIntegrity);
aMedia.ToString(mCrossOriginOrMedia);
}
@@ -141,17 +141,17 @@ public:
nsHtml5String aCrossOrigin,
nsHtml5String aIntegrity,
bool aParserInHead,
bool aAsync,
bool aDefer,
bool aNoModule)
{
MOZ_ASSERT(mOpCode == eSpeculativeLoadUninitialized,
- "Trying to reinitialize a speculative load!");
+ "Trying to reinitialize a speculative load!");
if (aNoModule) {
mOpCode = aParserInHead ? eSpeculativeLoadNoModuleScriptFromHead
: eSpeculativeLoadNoModuleScript;
} else {
mOpCode =
aParserInHead ? eSpeculativeLoadScriptFromHead : eSpeculativeLoadScript;
}
aUrl.ToString(mUrlOrSizes);
@@ -166,17 +166,17 @@ public:
inline void InitStyle(nsHtml5String aUrl,
nsHtml5String aCharset,
nsHtml5String aCrossOrigin,
nsHtml5String aReferrerPolicy,
nsHtml5String aIntegrity)
{
MOZ_ASSERT(mOpCode == eSpeculativeLoadUninitialized,
- "Trying to reinitialize a speculative load!");
+ "Trying to reinitialize a speculative load!");
mOpCode = eSpeculativeLoadStyle;
aUrl.ToString(mUrlOrSizes);
aCharset.ToString(mCharsetOrSrcset);
aCrossOrigin.ToString(mCrossOriginOrMedia);
aReferrerPolicy.ToString(mReferrerPolicyOrIntegrity);
aIntegrity.ToString(
mTypeOrCharsetSourceOrDocumentModeOrMetaCSPOrSizesOrIntegrity);
}
@@ -190,17 +190,17 @@ public:
* as opposed to tree operation queue is that the manifest must get
* processed before any actual speculative loads such as scripts. Thus,
* manifests seen by the parser thread have to maintain the queue order
* relative to true speculative loads. See bug 541079.
*/
inline void InitManifest(nsHtml5String aUrl)
{
MOZ_ASSERT(mOpCode == eSpeculativeLoadUninitialized,
- "Trying to reinitialize a speculative load!");
+ "Trying to reinitialize a speculative load!");
mOpCode = eSpeculativeLoadManifest;
aUrl.ToString(mUrlOrSizes);
}
/**
* "Speculative" charset setting isn't truly speculative. If the charset
* is set via this operation, we are committed to it unless chardet or
* a late meta cause a reload. The reason why a parser
@@ -209,43 +209,43 @@ public:
* must get processed before any actual speculative loads such as style
* sheets. Thus, encoding decisions by the parser thread have to maintain
* the queue order relative to true speculative loads. See bug 675499.
*/
inline void InitSetDocumentCharset(NotNull<const Encoding*> aEncoding,
int32_t aCharsetSource)
{
MOZ_ASSERT(mOpCode == eSpeculativeLoadUninitialized,
- "Trying to reinitialize a speculative load!");
+ "Trying to reinitialize a speculative load!");
mOpCode = eSpeculativeLoadSetDocumentCharset;
mCharsetOrSrcset.~nsString();
mEncoding = aEncoding;
mTypeOrCharsetSourceOrDocumentModeOrMetaCSPOrSizesOrIntegrity.Assign(
(char16_t)aCharsetSource);
}
/**
* Speculative document mode setting isn't really speculative. Once it
* happens, we are committed to it. However, this information needs to
* travel in the speculation queue in order to have this information
* available before parsing the speculatively loaded style sheets.
*/
inline void InitSetDocumentMode(nsHtml5DocumentMode aMode)
{
MOZ_ASSERT(mOpCode == eSpeculativeLoadUninitialized,
- "Trying to reinitialize a speculative load!");
+ "Trying to reinitialize a speculative load!");
mOpCode = eSpeculativeLoadSetDocumentMode;
mTypeOrCharsetSourceOrDocumentModeOrMetaCSPOrSizesOrIntegrity.Assign(
(char16_t)aMode);
}
inline void InitPreconnect(nsHtml5String aUrl, nsHtml5String aCrossOrigin)
{
MOZ_ASSERT(mOpCode == eSpeculativeLoadUninitialized,
- "Trying to reinitialize a speculative load!");
+ "Trying to reinitialize a speculative load!");
mOpCode = eSpeculativeLoadPreconnect;
aUrl.ToString(mUrlOrSizes);
aCrossOrigin.ToString(mCrossOriginOrMedia);
}
void Perform(nsHtml5TreeOpExecutor* aExecutor);
private:--- a/parser/html/nsHtml5StreamParser.h
+++ b/parser/html/nsHtml5StreamParser.h
@@ -162,17 +162,17 @@ public:
*
* @param aEncoding the charset of a document
* @param aCharsetSource the source of the charset
*/
inline void SetDocumentCharset(NotNull<const Encoding*> aEncoding,
int32_t aSource)
{
MOZ_ASSERT(mStreamState == STREAM_NOT_STARTED,
- "SetDocumentCharset called too late.");
+ "SetDocumentCharset called too late.");
NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
mEncoding = aEncoding;
mCharsetSource = aSource;
}
inline void SetObserver(nsIRequestObserver* aObserver)
{
NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");--- a/parser/html/nsHtml5TreeBuilderCppSupplement.h
+++ b/parser/html/nsHtml5TreeBuilderCppSupplement.h
@@ -74,19 +74,19 @@ nsHtml5TreeBuilder::createElement(int32_
nsAtom* aName,
nsHtml5HtmlAttributes* aAttributes,
nsIContentHandle* aIntendedParent,
nsHtml5ContentCreatorFunction aCreator)
{
MOZ_ASSERT(aAttributes, "Got null attributes.");
MOZ_ASSERT(aName, "Got null name.");
MOZ_ASSERT(aNamespace == kNameSpaceID_XHTML ||
- aNamespace == kNameSpaceID_SVG ||
- aNamespace == kNameSpaceID_MathML,
- "Bogus namespace.");
+ aNamespace == kNameSpaceID_SVG ||
+ aNamespace == kNameSpaceID_MathML,
+ "Bogus namespace.");
if (mBuilder) {
RefPtr<nsAtom> name = nsHtml5TreeOperation::Reget(aName);
nsIContent* intendedParent =
aIntendedParent ? static_cast<nsIContent*>(aIntendedParent) : nullptr;
// intendedParent == nullptr is a special case where the--- a/parser/html/nsHtml5TreeOperation.h
+++ b/parser/html/nsHtml5TreeOperation.h
@@ -227,48 +227,48 @@ public:
nsHtml5TreeOperation();
~nsHtml5TreeOperation();
inline void Init(eHtml5TreeOperation aOpCode)
{
MOZ_ASSERT(mOpCode == eTreeOpUninitialized,
- "Op code must be uninitialized when initializing.");
+ "Op code must be uninitialized when initializing.");
mOpCode = aOpCode;
}
inline void Init(eHtml5TreeOperation aOpCode, nsIContentHandle* aNode)
{
MOZ_ASSERT(mOpCode == eTreeOpUninitialized,
- "Op code must be uninitialized when initializing.");
+ "Op code must be uninitialized when initializing.");
MOZ_ASSERT(aNode, "Initialized tree op with null node.");
mOpCode = aOpCode;
mOne.node = static_cast<nsIContent**>(aNode);
}
inline void Init(eHtml5TreeOperation aOpCode,
nsIContentHandle* aNode,
nsIContentHandle* aParent)
{
MOZ_ASSERT(mOpCode == eTreeOpUninitialized,
- "Op code must be uninitialized when initializing.");
+ "Op code must be uninitialized when initializing.");
MOZ_ASSERT(aNode, "Initialized tree op with null node.");
MOZ_ASSERT(aParent, "Initialized tree op with null parent.");
mOpCode = aOpCode;
mOne.node = static_cast<nsIContent**>(aNode);
mTwo.node = static_cast<nsIContent**>(aParent);
}
inline void Init(eHtml5TreeOperation aOpCode,
const nsACString& aString,
int32_t aInt32)
{
MOZ_ASSERT(mOpCode == eTreeOpUninitialized,
- "Op code must be uninitialized when initializing.");
+ "Op code must be uninitialized when initializing.");
int32_t len = aString.Length();
char* str = new char[len + 1];
const char* start = aString.BeginReading();
for (int32_t i = 0; i < len; ++i) {
str[i] = start[i];
}
str[len] = '\0';
@@ -287,17 +287,17 @@ public:
mTwo.integer = aLineNumber;
}
inline void Init(eHtml5TreeOperation aOpCode,
NotNull<const Encoding*> aEncoding,
int32_t aInt32)
{
MOZ_ASSERT(mOpCode == eTreeOpUninitialized,
- "Op code must be uninitialized when initializing.");
+ "Op code must be uninitialized when initializing.");
mOpCode = aOpCode;
mOne.encoding = aEncoding;
mFour.integer = aInt32;
}
inline void Init(eHtml5TreeOperation aOpCode,
NotNull<const Encoding*> aEncoding,
@@ -309,54 +309,54 @@ public:
}
inline void Init(eHtml5TreeOperation aOpCode,
nsIContentHandle* aNode,
nsIContentHandle* aParent,
nsIContentHandle* aTable)
{
MOZ_ASSERT(mOpCode == eTreeOpUninitialized,
- "Op code must be uninitialized when initializing.");
+ "Op code must be uninitialized when initializing.");
MOZ_ASSERT(aNode, "Initialized tree op with null node.");
MOZ_ASSERT(aParent, "Initialized tree op with null parent.");
MOZ_ASSERT(aTable, "Initialized tree op with null table.");
mOpCode = aOpCode;
mOne.node = static_cast<nsIContent**>(aNode);
mTwo.node = static_cast<nsIContent**>(aParent);
mThree.node = static_cast<nsIContent**>(aTable);
}
inline void Init(nsHtml5DocumentMode aMode)
{
MOZ_ASSERT(mOpCode == eTreeOpUninitialized,
- "Op code must be uninitialized when initializing.");
+ "Op code must be uninitialized when initializing.");
mOpCode = eTreeOpDocumentMode;
mOne.mode = aMode;
}
inline void InitScript(nsIContentHandle* aNode)
{
MOZ_ASSERT(mOpCode == eTreeOpUninitialized,
- "Op code must be uninitialized when initializing.");
+ "Op code must be uninitialized when initializing.");
MOZ_ASSERT(aNode, "Initialized tree op with null node.");
mOpCode = eTreeOpRunScript;
mOne.node = static_cast<nsIContent**>(aNode);
mTwo.state = nullptr;
}
inline void Init(int32_t aNamespace,
nsAtom* aName,
nsHtml5HtmlAttributes* aAttributes,
nsIContentHandle* aTarget,
nsIContentHandle* aIntendedParent,
bool aFromNetwork,
nsHtml5ContentCreatorFunction aCreator)
{
MOZ_ASSERT(mOpCode == eTreeOpUninitialized,
- "Op code must be uninitialized when initializing.");
+ "Op code must be uninitialized when initializing.");
MOZ_ASSERT(aName, "Initialized tree op with null name.");
MOZ_ASSERT(aTarget, "Initialized tree op with null target node.");
if (aNamespace == kNameSpaceID_XHTML) {
mOpCode = aFromNetwork ? eTreeOpCreateHTMLElementNetwork
: eTreeOpCreateHTMLElementNotNetwork;
mFour.htmlCreator = aCreator.html;
} else if (aNamespace == kNameSpaceID_SVG) {
@@ -379,80 +379,80 @@ public:
inline void Init(eHtml5TreeOperation aOpCode,
char16_t* aBuffer,
int32_t aLength,
nsIContentHandle* aStackParent,
nsIContentHandle* aTable)
{
MOZ_ASSERT(mOpCode == eTreeOpUninitialized,
- "Op code must be uninitialized when initializing.");
+ "Op code must be uninitialized when initializing.");
MOZ_ASSERT(aBuffer, "Initialized tree op with null buffer.");
mOpCode = aOpCode;
mOne.node = static_cast<nsIContent**>(aStackParent);
mTwo.unicharPtr = aBuffer;
mThree.node = static_cast<nsIContent**>(aTable);
mFour.integer = aLength;
}
inline void Init(eHtml5TreeOperation aOpCode,
char16_t* aBuffer,
int32_t aLength,
nsIContentHandle* aParent)
{
MOZ_ASSERT(mOpCode == eTreeOpUninitialized,
- "Op code must be uninitialized when initializing.");
+ "Op code must be uninitialized when initializing.");
MOZ_ASSERT(aBuffer, "Initialized tree op with null buffer.");
mOpCode = aOpCode;
mOne.node = static_cast<nsIContent**>(aParent);
mTwo.unicharPtr = aBuffer;
mFour.integer = aLength;
}
inline void Init(eHtml5TreeOperation aOpCode,
char16_t* aBuffer,
int32_t aLength)
{
MOZ_ASSERT(mOpCode == eTreeOpUninitialized,
- "Op code must be uninitialized when initializing.");
+ "Op code must be uninitialized when initializing.");
MOZ_ASSERT(aBuffer, "Initialized tree op with null buffer.");
mOpCode = aOpCode;
mTwo.unicharPtr = aBuffer;
mFour.integer = aLength;
}
inline void Init(nsIContentHandle* aElement,
nsHtml5HtmlAttributes* aAttributes)
{
MOZ_ASSERT(mOpCode == eTreeOpUninitialized,
- "Op code must be uninitialized when initializing.");
+ "Op code must be uninitialized when initializing.");
MOZ_ASSERT(aElement, "Initialized tree op with null element.");
mOpCode = eTreeOpAddAttributes;
mOne.node = static_cast<nsIContent**>(aElement);
mTwo.attributes = aAttributes;
}
inline void Init(nsAtom* aName,
const nsAString& aPublicId,
const nsAString& aSystemId)
{
MOZ_ASSERT(mOpCode == eTreeOpUninitialized,
- "Op code must be uninitialized when initializing.");
+ "Op code must be uninitialized when initializing.");
mOpCode = eTreeOpAppendDoctypeToDocument;
mOne.atom = aName;
mTwo.stringPair = new nsHtml5TreeOperationStringPair(aPublicId, aSystemId);
}
inline void Init(nsIContentHandle* aElement,
const char* aMsgId,
nsAtom* aAtom,
nsAtom* aOtherAtom)
{
MOZ_ASSERT(mOpCode == eTreeOpUninitialized,
- "Op code must be uninitialized when initializing.");
+ "Op code must be uninitialized when initializing.");
mOpCode = eTreeOpAddError;
mOne.node = static_cast<nsIContent**>(aElement);
mTwo.charPtr = (char*)aMsgId;
mThree.atom = aAtom;
mFour.atom = aOtherAtom;
}
inline void Init(nsIContentHandle* aElement,
@@ -465,71 +465,71 @@ public:
inline void Init(nsIContentHandle* aElement, const char* aMsgId)
{
Init(aElement, aMsgId, nullptr, nullptr);
}
inline void Init(const char* aMsgId, bool aError, int32_t aLineNumber)
{
MOZ_ASSERT(mOpCode == eTreeOpUninitialized,
- "Op code must be uninitialized when initializing.");
+ "Op code must be uninitialized when initializing.");
mOpCode = eTreeOpMaybeComplainAboutCharset;
mOne.charPtr = const_cast<char*>(aMsgId);
mTwo.integer = aError;
mThree.integer = aLineNumber;
}
inline void Init(eHtml5TreeOperation aOpCode, const nsAString& aString)
{
MOZ_ASSERT(mOpCode == eTreeOpUninitialized,
- "Op code must be uninitialized when initializing.");
+ "Op code must be uninitialized when initializing.");
char16_t* str = ToNewUnicode(aString);
mOpCode = aOpCode;
mOne.unicharPtr = str;
}
inline void Init(eHtml5TreeOperation aOpCode,
nsIContentHandle* aNode,
int32_t aInt)
{
MOZ_ASSERT(mOpCode == eTreeOpUninitialized,
- "Op code must be uninitialized when initializing.");
+ "Op code must be uninitialized when initializing.");
MOZ_ASSERT(aNode, "Initialized tree op with null node.");
mOpCode = aOpCode;
mOne.node = static_cast<nsIContent**>(aNode);
mFour.integer = aInt;
}
inline void Init(nsresult aRv)
{
MOZ_ASSERT(mOpCode == eTreeOpUninitialized,
- "Op code must be uninitialized when initializing.");
+ "Op code must be uninitialized when initializing.");
MOZ_ASSERT(NS_FAILED(aRv), "Initialized tree op with non-failure.");
mOpCode = eTreeOpMarkAsBroken;
mOne.result = aRv;
}
inline void InitAddClass(nsIContentHandle* aNode, const char16_t* aClass)
{
MOZ_ASSERT(mOpCode == eTreeOpUninitialized,
- "Op code must be uninitialized when initializing.");
+ "Op code must be uninitialized when initializing.");
MOZ_ASSERT(aNode, "Initialized tree op with null node.");
MOZ_ASSERT(aClass, "Initialized tree op with null string.");
// aClass must be a literal string that does not need freeing
mOpCode = eTreeOpAddClass;
mOne.node = static_cast<nsIContent**>(aNode);
mTwo.unicharPtr = (char16_t*)aClass;
}
inline void InitAddLineNumberId(nsIContentHandle* aNode,
const int32_t aLineNumber)
{
MOZ_ASSERT(mOpCode == eTreeOpUninitialized,
- "Op code must be uninitialized when initializing.");
+ "Op code must be uninitialized when initializing.");
MOZ_ASSERT(aNode, "Initialized tree op with null node.");
MOZ_ASSERT(aLineNumber > 0, "Initialized tree op with line number.");
// aClass must be a literal string that does not need freeing
mOpCode = eTreeOpAddLineNumberId;
mOne.node = static_cast<nsIContent**>(aNode);
mFour.integer = aLineNumber;
}
--- a/parser/htmlparser/nsExpatDriver.cpp
+++ b/parser/htmlparser/nsExpatDriver.cpp
@@ -865,19 +865,19 @@ nsExpatDriver::ParseBuffer(const char16_
uint32_t aLength,
bool aIsFinal,
uint32_t *aConsumed)
{
NS_ASSERTION((aBuffer && aLength != 0) || (!aBuffer && aLength == 0), "?");
NS_ASSERTION(mInternalState != NS_OK || aIsFinal || aBuffer,
"Useless call, we won't call Expat");
MOZ_ASSERT(!BlockedOrInterrupted() || !aBuffer,
- "Non-null buffer when resuming");
+ "Non-null buffer when resuming");
MOZ_ASSERT(XML_GetCurrentByteIndex(mExpatParser) % sizeof(char16_t) == 0,
- "Consumed part of a char16_t?");
+ "Consumed part of a char16_t?");
if (mExpatParser && (mInternalState == NS_OK || BlockedOrInterrupted())) {
int32_t parserBytesBefore = XML_GetCurrentByteIndex(mExpatParser);
NS_ASSERTION(parserBytesBefore >= 0, "Unexpected value");
XML_Status status;
if (BlockedOrInterrupted()) {
mInternalState = NS_OK; // Resume in case we're blocked.--- a/parser/htmlparser/nsParser.cpp
+++ b/parser/htmlparser/nsParser.cpp
@@ -1163,18 +1163,18 @@ nsParser::BuildModel()
/*******************************************************************
These methods are used to talk to the netlib system...
*******************************************************************/
nsresult
nsParser::OnStartRequest(nsIRequest *request, nsISupports* aContext)
{
MOZ_ASSERT(eNone == mParserContext->mStreamListenerState,
- "Parser's nsIStreamListener API was not setup "
- "correctly in constructor.");
+ "Parser's nsIStreamListener API was not setup "
+ "correctly in constructor.");
if (mObserver) {
mObserver->OnStartRequest(request, aContext);
}
mParserContext->mStreamListenerState = eOnStart;
mParserContext->mAutoDetectStatus = eUnknownDetect;
mParserContext->mRequest = request;
@@ -1378,17 +1378,17 @@ nsresult
nsParser::OnDataAvailable(nsIRequest *request, nsISupports* aContext,
nsIInputStream *pIStream, uint64_t sourceOffset,
uint32_t aLength)
{
MOZ_ASSERT((eOnStart == mParserContext->mStreamListenerState ||
eOnDataAvail == mParserContext->mStreamListenerState),
"Error: OnStartRequest() must be called before OnDataAvailable()");
MOZ_ASSERT(NS_InputStreamIsBuffered(pIStream),
- "Must have a buffered input stream");
+ "Must have a buffered input stream");
nsresult rv = NS_OK;
if (mIsAboutBlank) {
MOZ_ASSERT(false, "Must not get OnDataAvailable for about:blank");
// ... but if an extension tries to feed us data for about:blank in a
// release build, silently ignore the data.
uint32_t totalRead;--- a/toolkit/components/places/nsNavHistoryResult.cpp
+++ b/toolkit/components/places/nsNavHistoryResult.cpp
@@ -2794,17 +2794,18 @@ nsNavHistoryQueryResultNode::OnPageChang
NS_IMETHODIMP
nsNavHistoryQueryResultNode::OnDeleteVisits(nsIURI* aURI,
PRTime aVisitTime,
const nsACString& aGUID,
uint16_t aReason,
uint32_t aTransitionType)
{
MOZ_ASSERT(mOptions->QueryType() == nsINavHistoryQueryOptions::QUERY_TYPE_HISTORY,
- "Bookmarks queries should not get a OnDeleteVisits notification");
+ "Bookmarks queries should not get a OnDeleteVisits notification");
+
if (aVisitTime == 0) {
// All visits for this uri have been removed, but the uri won't be removed
// from the databse, most likely because it's a bookmark. For a history
// query this is equivalent to a onDeleteURI notification.
nsresult rv = OnDeleteURI(aURI, aGUID, aReason);
NS_ENSURE_SUCCESS(rv, rv);
}
if (aTransitionType > 0) {--- a/uriloader/base/nsURILoader.cpp
+++ b/uriloader/base/nsURILoader.cpp
@@ -382,18 +382,18 @@ NS_IMETHODIMP nsDocumentOpenInfo::OnStop
return NS_OK;
}
nsresult nsDocumentOpenInfo::DispatchContent(nsIRequest *request, nsISupports * aCtxt)
{
LOG(("[0x%p] nsDocumentOpenInfo::DispatchContent for type '%s'", this, mContentType.get()));
MOZ_ASSERT(!m_targetStreamListener,
- "Why do we already have a target stream listener?");
-
+ "Why do we already have a target stream listener?");
+
nsresult rv;
nsCOMPtr<nsIChannel> aChannel = do_QueryInterface(request);
if (!aChannel) {
LOG_ERROR((" Request is not a channel. Bailing."));
return NS_ERROR_FAILURE;
}
NS_NAMED_LITERAL_CSTRING(anyType, "*/*");
@@ -645,17 +645,18 @@ nsDocumentOpenInfo::ConvertData(nsIReque
if (mDataConversionDepthLimit == 0) {
LOG(("[0x%p] nsDocumentOpenInfo::ConvertData - reached the recursion limit!", this));
// This will fall back to external helper app handling.
return NS_ERROR_ABORT;
}
MOZ_ASSERT(aSrcContentType != aOutContentType,
- "ConvertData called when the two types are the same!");
+ "ConvertData called when the two types are the same!");
+
nsresult rv = NS_OK;
nsCOMPtr<nsIStreamConverterService> StreamConvService =
do_GetService(NS_STREAMCONVERTERSERVICE_CONTRACTID, &rv);
if (NS_FAILED(rv)) return rv;
LOG((" Got converter service"));
@@ -990,10 +991,9 @@ NS_IMETHODIMP nsURILoader::Stop(nsISuppo
NS_ENSURE_ARG_POINTER(aLoadCookie);
docLoader = do_GetInterface(aLoadCookie, &rv);
if (docLoader) {
rv = docLoader->Stop();
}
return rv;
-}
-
+}
\ No newline at end of file--- a/uriloader/exthandler/nsExternalHelperAppService.cpp
+++ b/uriloader/exthandler/nsExternalHelperAppService.cpp
@@ -2534,17 +2534,17 @@ nsExternalAppHandler::GetName(nsACString
// The following section contains our nsIMIMEService implementation and related methods.
//
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
// nsIMIMEService methods
NS_IMETHODIMP nsExternalHelperAppService::GetFromTypeAndExtension(const nsACString& aMIMEType, const nsACString& aFileExt, nsIMIMEInfo **_retval)
{
MOZ_ASSERT(!aMIMEType.IsEmpty() || !aFileExt.IsEmpty(),
- "Give me something to work with");
+ "Give me something to work with");
LOG(("Getting mimeinfo from type '%s' ext '%s'\n",
PromiseFlatCString(aMIMEType).get(), PromiseFlatCString(aFileExt).get()));
*_retval = nullptr;
// OK... we need a type. Get one.
nsAutoCString typeToUse(aMIMEType);
if (typeToUse.IsEmpty()) {--- a/view/nsViewManager.cpp
+++ b/view/nsViewManager.cpp
@@ -133,17 +133,17 @@ nsViewManager::CreateView(const nsRect&
v->SetDimensions(dim, false);
return v;
}
void
nsViewManager::SetRootView(nsView *aView)
{
MOZ_ASSERT(!aView || aView->GetViewManager() == this,
- "Unexpected viewmanager on root view");
+ "Unexpected viewmanager on root view");
// Do NOT destroy the current root view. It's the caller's responsibility
// to destroy it
mRootView = aView;
if (mRootView) {
nsView* parent = mRootView->GetParent();
if (parent) {--- a/widget/nsBaseFilePicker.cpp
+++ b/widget/nsBaseFilePicker.cpp
@@ -424,9 +424,8 @@ nsBaseFilePicker::GetDomFileOrDirectoryE
NS_ENSURE_SUCCESS(rv, rv);
RefPtr<nsBaseFilePickerEnumerator> retIter =
new nsBaseFilePickerEnumerator(mParent, iter, mMode);
retIter.forget(aValue);
return NS_OK;
}
---- a/widget/windows/IMMHandler.cpp
+++ b/widget/windows/IMMHandler.cpp
@@ -1297,17 +1297,17 @@ IMMHandler::GetTextEventDispatcherFor(ns
mDispatcher.get() : aWindow->GetTextEventDispatcher();
}
void
IMMHandler::HandleStartComposition(nsWindow* aWindow,
const IMEContext& aContext)
{
MOZ_ASSERT(!mIsComposing,
- "HandleStartComposition is called but mIsComposing is TRUE");
+ "HandleStartComposition is called but mIsComposing is TRUE");
Selection& selection = GetSelection();
if (!selection.EnsureValidSelection(aWindow)) {
MOZ_LOG(gIMMLog, LogLevel::Error,
("HandleStartComposition, FAILED, due to "
"Selection::EnsureValidSelection() failure"));
return;
}--- a/xpcom/base/nsAutoPtr.h
+++ b/xpcom/base/nsAutoPtr.h
@@ -192,17 +192,17 @@ public:
mRawPtr = 0;
return temp;
}
T*
operator->() const
{
MOZ_ASSERT(mRawPtr != 0,
- "You can't dereference a NULL nsAutoPtr with operator->().");
+ "You can't dereference a NULL nsAutoPtr with operator->().");
return get();
}
template <typename R, typename... Args>
class Proxy
{
typedef R (T::*member_function)(Args...);
T* mRawPtr;
@@ -219,17 +219,17 @@ public:
return ((*mRawPtr).*mFunction)(mozilla::Forward<ActualArgs>(aArgs)...);
}
};
template <typename R, typename C, typename... Args>
Proxy<R, Args...> operator->*(R (C::*aFptr)(Args...)) const
{
MOZ_ASSERT(mRawPtr != 0,
- "You can't dereference a NULL nsAutoPtr with operator->*().");
+ "You can't dereference a NULL nsAutoPtr with operator->*().");
return Proxy<R, Args...>(get(), aFptr);
}
nsAutoPtr<T>*
get_address()
// This is not intended to be used by clients. See |address_of|
// below.
{
@@ -244,17 +244,17 @@ public:
return this;
}
public:
T&
operator*() const
{
MOZ_ASSERT(mRawPtr != 0,
- "You can't dereference a NULL nsAutoPtr with operator*().");
+ "You can't dereference a NULL nsAutoPtr with operator*().");
return *get();
}
T**
StartAssignment()
{
#ifndef NSCAP_FEATURE_INLINE_STARTASSIGNMENT
return reinterpret_cast<T**>(begin_assignment());