--- a/dom/base/Attr.h
+++ b/dom/base/Attr.h
@@ -74,17 +74,17 @@ public:
virtual already_AddRefed<nsIURI> GetBaseURI(bool aTryUseXHRDocBaseURI = false) const MOZ_OVERRIDE;
static void Initialize();
static void Shutdown();
NS_DECL_CYCLE_COLLECTION_SKIPPABLE_SCRIPT_HOLDER_CLASS_AMBIGUOUS(Attr,
nsIAttribute)
- virtual nsIDOMNode* AsDOMNode() MOZ_OVERRIDE { return this; }
+ virtual nsIDOMNode* AsDOMNode() { return this; }
// WebIDL
virtual JSObject* WrapNode(JSContext* aCx) MOZ_OVERRIDE;
// XPCOM GetName() is OK
// XPCOM GetValue() is OK
void SetValue(const nsAString& aValue, ErrorResult& aRv);
@@ -93,17 +93,17 @@ public:
// XPCOM GetNamespaceURI() is OK
// XPCOM GetPrefix() is OK
// XPCOM GetLocalName() is OK
Element* GetOwnerElement(ErrorResult& aRv);
protected:
- virtual Element* GetNameSpaceElement() MOZ_OVERRIDE
+ virtual Element* GetNameSpaceElement()
{
return GetElement();
}
static bool sInitialized;
private:
already_AddRefed<nsIAtom> GetNameAtom(nsIContent* aContent);
--- a/dom/base/Comment.h
+++ b/dom/base/Comment.h
@@ -47,17 +47,17 @@ public:
// nsIDOMCharacterData
NS_FORWARD_NSIDOMCHARACTERDATA(nsGenericDOMDataNode::)
using nsGenericDOMDataNode::SetData; // Prevent hiding overloaded virtual function.
// nsIDOMComment
// Empty interface
// nsINode
- virtual bool IsNodeOfType(uint32_t aFlags) const MOZ_OVERRIDE;
+ virtual bool IsNodeOfType(uint32_t aFlags) const;
virtual nsGenericDOMDataNode* CloneDataNode(mozilla::dom::NodeInfo *aNodeInfo,
bool aCloneText) const MOZ_OVERRIDE;
virtual nsIDOMNode* AsDOMNode() MOZ_OVERRIDE { return this; }
#ifdef DEBUG
virtual void List(FILE* out, int32_t aIndent) const MOZ_OVERRIDE;
virtual void DumpContent(FILE* out = stdout, int32_t aIndent = 0,
--- a/dom/base/DOMQuad.cpp
+++ b/dom/base/DOMQuad.cpp
@@ -79,35 +79,35 @@ public:
explicit QuadBounds(DOMQuad* aQuad)
: DOMRectReadOnly(aQuad->GetParentObject())
, mQuad(aQuad)
{}
NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(QuadBounds, DOMRectReadOnly)
NS_DECL_ISUPPORTS_INHERITED
- virtual double X() const MOZ_OVERRIDE
+ virtual double X() const
{
double x1, x2;
GetHorizontalMinMax(&x1, &x2);
return x1;
}
- virtual double Y() const MOZ_OVERRIDE
+ virtual double Y() const
{
double y1, y2;
GetVerticalMinMax(&y1, &y2);
return y1;
}
- virtual double Width() const MOZ_OVERRIDE
+ virtual double Width() const
{
double x1, x2;
GetHorizontalMinMax(&x1, &x2);
return x2 - x1;
}
- virtual double Height() const MOZ_OVERRIDE
+ virtual double Height() const
{
double y1, y2;
GetVerticalMinMax(&y1, &y2);
return y2 - y1;
}
void GetHorizontalMinMax(double* aX1, double* aX2) const
{
--- a/dom/base/DOMStringList.h
+++ b/dom/base/DOMStringList.h
@@ -19,17 +19,17 @@ class DOMStringList : public nsISupports
{
protected:
virtual ~DOMStringList();
public:
NS_DECL_CYCLE_COLLECTING_ISUPPORTS
NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(DOMStringList)
- virtual JSObject* WrapObject(JSContext* aCx) MOZ_OVERRIDE;
+ virtual JSObject* WrapObject(JSContext* aCx);
nsISupports* GetParentObject()
{
return nullptr;
}
void IndexedGetter(uint32_t aIndex, bool& aFound, nsAString& aResult)
{
EnsureFresh();
--- a/dom/base/DocumentFragment.h
+++ b/dom/base/DocumentFragment.h
@@ -107,17 +107,17 @@ public:
}
virtual void UnbindFromTree(bool aDeep, bool aNullParent) MOZ_OVERRIDE
{
NS_ASSERTION(false, "Trying to unbind a fragment from a tree");
return;
}
- virtual Element* GetNameSpaceElement() MOZ_OVERRIDE
+ virtual Element* GetNameSpaceElement()
{
return nullptr;
}
nsIContent* GetHost() const
{
return mHost;
}
--- a/dom/base/Element.h
+++ b/dom/base/Element.h
@@ -154,17 +154,17 @@ public:
NS_ABORT_IF_FALSE(mNodeInfo->NodeType() == nsIDOMNode::ELEMENT_NODE,
"Bad NodeType in aNodeInfo");
SetIsElement();
}
#endif // MOZILLA_INTERNAL_API
NS_DECLARE_STATIC_IID_ACCESSOR(NS_ELEMENT_IID)
- NS_IMETHOD QueryInterface(REFNSIID aIID, void** aInstancePtr) MOZ_OVERRIDE;
+ NS_IMETHOD QueryInterface(REFNSIID aIID, void** aInstancePtr);
/**
* Method to get the full state of this element. See mozilla/EventStates.h
* for the possible bits that could be set here.
*/
EventStates State() const
{
// mState is maintained by having whoever might have changed it
@@ -1206,17 +1206,17 @@ protected:
/**
* Internal hook for converting an attribute name-string to an atomized name
*/
virtual const nsAttrName* InternalGetExistingAttrNameFromQName(const nsAString& aStr) const;
nsIFrame* GetStyledFrame();
- virtual Element* GetNameSpaceElement() MOZ_OVERRIDE
+ virtual Element* GetNameSpaceElement()
{
return this;
}
Attr* GetAttributeNodeNSInternal(const nsAString& aNamespaceURI,
const nsAString& aLocalName);
inline void RegisterActivityObserver();
@@ -1306,19 +1306,19 @@ public:
NS_DECL_CYCLE_COLLECTING_ISUPPORTS
NS_DECL_CYCLE_COLLECTION_CLASS(DestinationInsertionPointList)
// nsIDOMNodeList
NS_DECL_NSIDOMNODELIST
// nsINodeList
- virtual nsIContent* Item(uint32_t aIndex) MOZ_OVERRIDE;
- virtual int32_t IndexOf(nsIContent* aContent) MOZ_OVERRIDE;
- virtual nsINode* GetParentObject() MOZ_OVERRIDE { return mParent; }
+ virtual nsIContent* Item(uint32_t aIndex);
+ virtual int32_t IndexOf(nsIContent* aContent);
+ virtual nsINode* GetParentObject() { return mParent; }
virtual uint32_t Length() const;
virtual JSObject* WrapObject(JSContext* aCx) MOZ_OVERRIDE;
protected:
virtual ~DestinationInsertionPointList();
nsRefPtr<Element> mParent;
nsCOMArray<nsIContent> mDestinationPoints;
};
@@ -1462,344 +1462,332 @@ nsresult
NS_IMETHODIMP \
_class::Set##_method(bool aValue) \
{ \
return SetBoolAttr(nsGkAtoms::_atom, aValue); \
}
#define NS_FORWARD_NSIDOMELEMENT_TO_GENERIC \
typedef mozilla::dom::Element Element; \
-NS_IMETHOD GetTagName(nsAString& aTagName) MOZ_FINAL MOZ_OVERRIDE \
+NS_IMETHOD GetTagName(nsAString& aTagName) MOZ_FINAL \
{ \
Element::GetTagName(aTagName); \
return NS_OK; \
} \
-NS_IMETHOD GetId(nsAString& aId) MOZ_FINAL MOZ_OVERRIDE \
+NS_IMETHOD GetId(nsAString& aId) MOZ_FINAL \
{ \
Element::GetId(aId); \
return NS_OK; \
} \
-NS_IMETHOD SetId(const nsAString& aId) MOZ_FINAL MOZ_OVERRIDE \
+NS_IMETHOD SetId(const nsAString& aId) MOZ_FINAL \
{ \
Element::SetId(aId); \
return NS_OK; \
} \
-NS_IMETHOD GetClassName(nsAString& aClassName) MOZ_FINAL MOZ_OVERRIDE \
+NS_IMETHOD GetClassName(nsAString& aClassName) MOZ_FINAL \
{ \
Element::GetClassName(aClassName); \
return NS_OK; \
} \
-NS_IMETHOD SetClassName(const nsAString& aClassName) MOZ_FINAL MOZ_OVERRIDE \
+NS_IMETHOD SetClassName(const nsAString& aClassName) MOZ_FINAL \
{ \
Element::SetClassName(aClassName); \
return NS_OK; \
} \
-NS_IMETHOD GetClassList(nsISupports** aClassList) MOZ_FINAL MOZ_OVERRIDE \
+NS_IMETHOD GetClassList(nsISupports** aClassList) MOZ_FINAL \
{ \
Element::GetClassList(aClassList); \
return NS_OK; \
} \
NS_IMETHOD GetAttributes(nsIDOMMozNamedAttrMap** aAttributes) MOZ_FINAL \
- MOZ_OVERRIDE \
{ \
NS_ADDREF(*aAttributes = Attributes()); \
return NS_OK; \
} \
using Element::GetAttribute; \
NS_IMETHOD GetAttribute(const nsAString& name, nsAString& _retval) MOZ_FINAL \
- MOZ_OVERRIDE \
{ \
nsString attr; \
GetAttribute(name, attr); \
_retval = attr; \
return NS_OK; \
} \
NS_IMETHOD GetAttributeNS(const nsAString& namespaceURI, \
const nsAString& localName, \
- nsAString& _retval) MOZ_FINAL MOZ_OVERRIDE \
+ nsAString& _retval) MOZ_FINAL \
{ \
Element::GetAttributeNS(namespaceURI, localName, _retval); \
return NS_OK; \
} \
NS_IMETHOD SetAttribute(const nsAString& name, \
- const nsAString& value) MOZ_OVERRIDE \
+ const nsAString& value) \
{ \
mozilla::ErrorResult rv; \
Element::SetAttribute(name, value, rv); \
return rv.ErrorCode(); \
} \
NS_IMETHOD SetAttributeNS(const nsAString& namespaceURI, \
const nsAString& qualifiedName, \
- const nsAString& value) MOZ_FINAL MOZ_OVERRIDE \
+ const nsAString& value) MOZ_FINAL \
{ \
mozilla::ErrorResult rv; \
Element::SetAttributeNS(namespaceURI, qualifiedName, value, rv); \
return rv.ErrorCode(); \
} \
using Element::RemoveAttribute; \
-NS_IMETHOD RemoveAttribute(const nsAString& name) MOZ_FINAL MOZ_OVERRIDE \
+NS_IMETHOD RemoveAttribute(const nsAString& name) MOZ_FINAL \
{ \
mozilla::ErrorResult rv; \
RemoveAttribute(name, rv); \
return rv.ErrorCode(); \
} \
NS_IMETHOD RemoveAttributeNS(const nsAString& namespaceURI, \
const nsAString& localName) MOZ_FINAL \
- MOZ_OVERRIDE \
{ \
mozilla::ErrorResult rv; \
Element::RemoveAttributeNS(namespaceURI, localName, rv); \
return rv.ErrorCode(); \
} \
using Element::HasAttribute; \
NS_IMETHOD HasAttribute(const nsAString& name, \
- bool* _retval) MOZ_FINAL MOZ_OVERRIDE \
+ bool* _retval) MOZ_FINAL \
{ \
*_retval = HasAttribute(name); \
return NS_OK; \
} \
NS_IMETHOD HasAttributeNS(const nsAString& namespaceURI, \
const nsAString& localName, \
- bool* _retval) MOZ_FINAL MOZ_OVERRIDE \
+ bool* _retval) MOZ_FINAL \
{ \
*_retval = Element::HasAttributeNS(namespaceURI, localName); \
return NS_OK; \
} \
-NS_IMETHOD HasAttributes(bool* _retval) MOZ_FINAL MOZ_OVERRIDE \
+NS_IMETHOD HasAttributes(bool* _retval) MOZ_FINAL \
{ \
*_retval = Element::HasAttributes(); \
return NS_OK; \
} \
NS_IMETHOD GetAttributeNode(const nsAString& name, \
- nsIDOMAttr** _retval) MOZ_FINAL MOZ_OVERRIDE \
+ nsIDOMAttr** _retval) MOZ_FINAL \
{ \
NS_IF_ADDREF(*_retval = Element::GetAttributeNode(name)); \
return NS_OK; \
} \
NS_IMETHOD SetAttributeNode(nsIDOMAttr* newAttr, \
- nsIDOMAttr** _retval) MOZ_FINAL MOZ_OVERRIDE \
+ nsIDOMAttr** _retval) MOZ_FINAL \
{ \
if (!newAttr) { \
return NS_ERROR_INVALID_POINTER; \
} \
mozilla::ErrorResult rv; \
mozilla::dom::Attr* attr = static_cast<mozilla::dom::Attr*>(newAttr); \
*_retval = Element::SetAttributeNode(*attr, rv).take(); \
return rv.ErrorCode(); \
} \
NS_IMETHOD RemoveAttributeNode(nsIDOMAttr* oldAttr, \
- nsIDOMAttr** _retval) MOZ_FINAL MOZ_OVERRIDE \
+ nsIDOMAttr** _retval) MOZ_FINAL \
{ \
if (!oldAttr) { \
return NS_ERROR_INVALID_POINTER; \
} \
mozilla::ErrorResult rv; \
mozilla::dom::Attr* attr = static_cast<mozilla::dom::Attr*>(oldAttr); \
*_retval = Element::RemoveAttributeNode(*attr, rv).take(); \
return rv.ErrorCode(); \
} \
NS_IMETHOD GetAttributeNodeNS(const nsAString& namespaceURI, \
const nsAString& localName, \
- nsIDOMAttr** _retval) MOZ_FINAL MOZ_OVERRIDE \
+ nsIDOMAttr** _retval) MOZ_FINAL \
{ \
NS_IF_ADDREF(*_retval = Element::GetAttributeNodeNS(namespaceURI, \
localName)); \
return NS_OK; \
} \
NS_IMETHOD SetAttributeNodeNS(nsIDOMAttr* newAttr, \
- nsIDOMAttr** _retval) MOZ_FINAL MOZ_OVERRIDE \
+ nsIDOMAttr** _retval) MOZ_FINAL \
{ \
mozilla::ErrorResult rv; \
mozilla::dom::Attr* attr = static_cast<mozilla::dom::Attr*>(newAttr); \
*_retval = Element::SetAttributeNodeNS(*attr, rv).take(); \
return rv.ErrorCode(); \
} \
NS_IMETHOD GetElementsByTagName(const nsAString& name, \
nsIDOMHTMLCollection** _retval) MOZ_FINAL \
- MOZ_OVERRIDE \
{ \
Element::GetElementsByTagName(name, _retval); \
return NS_OK; \
} \
NS_IMETHOD GetElementsByTagNameNS(const nsAString& namespaceURI, \
const nsAString& localName, \
nsIDOMHTMLCollection** _retval) MOZ_FINAL \
- MOZ_OVERRIDE\
{ \
return Element::GetElementsByTagNameNS(namespaceURI, localName, \
_retval); \
} \
NS_IMETHOD GetElementsByClassName(const nsAString& classes, \
nsIDOMHTMLCollection** _retval) MOZ_FINAL \
- MOZ_OVERRIDE\
{ \
return Element::GetElementsByClassName(classes, _retval); \
} \
NS_IMETHOD GetChildElements(nsIDOMNodeList** aChildElements) MOZ_FINAL \
- MOZ_OVERRIDE \
{ \
nsIHTMLCollection* list = FragmentOrElement::Children(); \
return CallQueryInterface(list, aChildElements); \
} \
NS_IMETHOD GetFirstElementChild(nsIDOMElement** aFirstElementChild) MOZ_FINAL \
- MOZ_OVERRIDE \
{ \
Element* element = Element::GetFirstElementChild(); \
if (!element) { \
*aFirstElementChild = nullptr; \
return NS_OK; \
} \
return CallQueryInterface(element, aFirstElementChild); \
} \
NS_IMETHOD GetLastElementChild(nsIDOMElement** aLastElementChild) MOZ_FINAL \
- MOZ_OVERRIDE \
{ \
Element* element = Element::GetLastElementChild(); \
if (!element) { \
*aLastElementChild = nullptr; \
return NS_OK; \
} \
return CallQueryInterface(element, aLastElementChild); \
} \
NS_IMETHOD GetPreviousElementSibling(nsIDOMElement** aPreviousElementSibling) \
- MOZ_FINAL MOZ_OVERRIDE \
+ MOZ_FINAL \
{ \
Element* element = Element::GetPreviousElementSibling(); \
if (!element) { \
*aPreviousElementSibling = nullptr; \
return NS_OK; \
} \
return CallQueryInterface(element, aPreviousElementSibling); \
} \
NS_IMETHOD GetNextElementSibling(nsIDOMElement** aNextElementSibling) \
- MOZ_FINAL MOZ_OVERRIDE \
+ MOZ_FINAL \
{ \
Element* element = Element::GetNextElementSibling(); \
if (!element) { \
*aNextElementSibling = nullptr; \
return NS_OK; \
} \
return CallQueryInterface(element, aNextElementSibling); \
} \
NS_IMETHOD GetChildElementCount(uint32_t* aChildElementCount) MOZ_FINAL \
- MOZ_OVERRIDE \
{ \
*aChildElementCount = Element::ChildElementCount(); \
return NS_OK; \
} \
-NS_IMETHOD MozRemove() MOZ_FINAL MOZ_OVERRIDE \
+NS_IMETHOD MozRemove() MOZ_FINAL \
{ \
nsINode::Remove(); \
return NS_OK; \
} \
NS_IMETHOD GetClientRects(nsIDOMClientRectList** _retval) MOZ_FINAL \
- MOZ_OVERRIDE \
{ \
*_retval = Element::GetClientRects().take(); \
return NS_OK; \
} \
NS_IMETHOD GetBoundingClientRect(nsIDOMClientRect** _retval) MOZ_FINAL \
- MOZ_OVERRIDE \
{ \
*_retval = Element::GetBoundingClientRect().take(); \
return NS_OK; \
} \
-NS_IMETHOD GetScrollTop(int32_t* aScrollTop) MOZ_FINAL MOZ_OVERRIDE \
+NS_IMETHOD GetScrollTop(int32_t* aScrollTop) MOZ_FINAL \
{ \
*aScrollTop = Element::ScrollTop(); \
return NS_OK; \
} \
-NS_IMETHOD SetScrollTop(int32_t aScrollTop) MOZ_FINAL MOZ_OVERRIDE \
+NS_IMETHOD SetScrollTop(int32_t aScrollTop) MOZ_FINAL \
{ \
Element::SetScrollTop(aScrollTop); \
return NS_OK; \
} \
-NS_IMETHOD GetScrollLeft(int32_t* aScrollLeft) MOZ_FINAL MOZ_OVERRIDE \
+NS_IMETHOD GetScrollLeft(int32_t* aScrollLeft) MOZ_FINAL \
{ \
*aScrollLeft = Element::ScrollLeft(); \
return NS_OK; \
} \
-NS_IMETHOD SetScrollLeft(int32_t aScrollLeft) MOZ_FINAL MOZ_OVERRIDE \
+NS_IMETHOD SetScrollLeft(int32_t aScrollLeft) MOZ_FINAL \
{ \
Element::SetScrollLeft(aScrollLeft); \
return NS_OK; \
} \
-NS_IMETHOD GetScrollWidth(int32_t* aScrollWidth) MOZ_FINAL MOZ_OVERRIDE \
+NS_IMETHOD GetScrollWidth(int32_t* aScrollWidth) MOZ_FINAL \
{ \
*aScrollWidth = Element::ScrollWidth(); \
return NS_OK; \
} \
-NS_IMETHOD GetScrollHeight(int32_t* aScrollHeight) MOZ_FINAL MOZ_OVERRIDE \
+NS_IMETHOD GetScrollHeight(int32_t* aScrollHeight) MOZ_FINAL \
{ \
*aScrollHeight = Element::ScrollHeight(); \
return NS_OK; \
} \
-NS_IMETHOD GetClientTop(int32_t* aClientTop) MOZ_FINAL MOZ_OVERRIDE \
+NS_IMETHOD GetClientTop(int32_t* aClientTop) MOZ_FINAL \
{ \
*aClientTop = Element::ClientTop(); \
return NS_OK; \
} \
-NS_IMETHOD GetClientLeft(int32_t* aClientLeft) MOZ_FINAL MOZ_OVERRIDE \
+NS_IMETHOD GetClientLeft(int32_t* aClientLeft) MOZ_FINAL \
{ \
*aClientLeft = Element::ClientLeft(); \
return NS_OK; \
} \
-NS_IMETHOD GetClientWidth(int32_t* aClientWidth) MOZ_FINAL MOZ_OVERRIDE \
+NS_IMETHOD GetClientWidth(int32_t* aClientWidth) MOZ_FINAL \
{ \
*aClientWidth = Element::ClientWidth(); \
return NS_OK; \
} \
-NS_IMETHOD GetClientHeight(int32_t* aClientHeight) MOZ_FINAL MOZ_OVERRIDE \
+NS_IMETHOD GetClientHeight(int32_t* aClientHeight) MOZ_FINAL \
{ \
*aClientHeight = Element::ClientHeight(); \
return NS_OK; \
} \
-NS_IMETHOD GetScrollLeftMax(int32_t* aScrollLeftMax) MOZ_FINAL MOZ_OVERRIDE \
+NS_IMETHOD GetScrollLeftMax(int32_t* aScrollLeftMax) MOZ_FINAL \
{ \
*aScrollLeftMax = Element::ScrollLeftMax(); \
return NS_OK; \
} \
-NS_IMETHOD GetScrollTopMax(int32_t* aScrollTopMax) MOZ_FINAL MOZ_OVERRIDE \
+NS_IMETHOD GetScrollTopMax(int32_t* aScrollTopMax) MOZ_FINAL \
{ \
*aScrollTopMax = Element::ScrollTopMax(); \
return NS_OK; \
} \
NS_IMETHOD MozMatchesSelector(const nsAString& selector, \
- bool* _retval) MOZ_FINAL MOZ_OVERRIDE \
+ bool* _retval) MOZ_FINAL \
{ \
mozilla::ErrorResult rv; \
*_retval = Element::MozMatchesSelector(selector, rv); \
return rv.ErrorCode(); \
} \
-NS_IMETHOD SetCapture(bool retargetToElement) MOZ_FINAL MOZ_OVERRIDE \
+NS_IMETHOD SetCapture(bool retargetToElement) MOZ_FINAL \
{ \
Element::SetCapture(retargetToElement); \
return NS_OK; \
} \
-NS_IMETHOD ReleaseCapture(void) MOZ_FINAL MOZ_OVERRIDE \
+NS_IMETHOD ReleaseCapture(void) MOZ_FINAL \
{ \
Element::ReleaseCapture(); \
return NS_OK; \
} \
-NS_IMETHOD MozRequestFullScreen(void) MOZ_FINAL MOZ_OVERRIDE \
+NS_IMETHOD MozRequestFullScreen(void) MOZ_FINAL \
{ \
Element::MozRequestFullScreen(mozilla::dom::RequestFullscreenOptions()); \
return NS_OK; \
} \
-NS_IMETHOD MozRequestPointerLock(void) MOZ_FINAL MOZ_OVERRIDE \
+NS_IMETHOD MozRequestPointerLock(void) MOZ_FINAL \
{ \
Element::MozRequestPointerLock(); \
return NS_OK; \
} \
using nsINode::QuerySelector; \
NS_IMETHOD QuerySelector(const nsAString& aSelector, \
- nsIDOMElement **aReturn) MOZ_FINAL MOZ_OVERRIDE \
+ nsIDOMElement **aReturn) MOZ_FINAL \
{ \
return nsINode::QuerySelector(aSelector, aReturn); \
} \
using nsINode::QuerySelectorAll; \
NS_IMETHOD QuerySelectorAll(const nsAString& aSelector, \
- nsIDOMNodeList **aReturn) MOZ_FINAL MOZ_OVERRIDE \
+ nsIDOMNodeList **aReturn) MOZ_FINAL \
{ \
return nsINode::QuerySelectorAll(aSelector, aReturn); \
}
#endif // mozilla_dom_Element_h__
--- a/dom/base/EventSource.cpp
+++ b/dom/base/EventSource.cpp
@@ -495,17 +495,17 @@ public:
: mEventSource(aEventsource)
{
}
NS_DECL_CYCLE_COLLECTING_ISUPPORTS
NS_DECL_CYCLE_COLLECTION_CLASS(AsyncVerifyRedirectCallbackFwr)
// nsIAsyncVerifyRedirectCallback implementation
- NS_IMETHOD OnRedirectVerifyCallback(nsresult aResult) MOZ_OVERRIDE
+ NS_IMETHOD OnRedirectVerifyCallback(nsresult aResult)
{
nsresult rv = mEventSource->OnRedirectVerifyCallback(aResult);
if (NS_FAILED(rv)) {
mEventSource->mErrorLoadOnRedirect = true;
mEventSource->DispatchFailConnection();
}
return NS_OK;
--- a/dom/base/File.cpp
+++ b/dom/base/File.cpp
@@ -1078,17 +1078,17 @@ class FileImplMemoryDataOwnerMemoryRepor
: public nsIMemoryReporter
{
~FileImplMemoryDataOwnerMemoryReporter() {}
public:
NS_DECL_THREADSAFE_ISUPPORTS
NS_IMETHOD CollectReports(nsIMemoryReporterCallback *aCallback,
- nsISupports *aClosure, bool aAnonymize) MOZ_OVERRIDE
+ nsISupports *aClosure, bool aAnonymize)
{
typedef FileImplMemory::DataOwner DataOwner;
StaticMutexAutoLock lock(DataOwner::sDataOwnerMutex);
if (!DataOwner::sDataOwners) {
return NS_OK;
}
--- a/dom/base/File.h
+++ b/dom/base/File.h
@@ -434,17 +434,17 @@ public:
return false;
}
virtual bool IsDateUnknown() const MOZ_OVERRIDE
{
return mIsFile && mLastModificationDate == UINT64_MAX;
}
- virtual bool IsFile() const MOZ_OVERRIDE
+ virtual bool IsFile() const
{
return mIsFile;
}
virtual bool IsStoredFile() const
{
return false;
}
@@ -455,23 +455,23 @@ public:
return false;
}
virtual bool IsSnapshot() const
{
return false;
}
- virtual bool IsSizeUnknown() const MOZ_OVERRIDE
+ virtual bool IsSizeUnknown() const
{
return mLength == UINT64_MAX;
}
- virtual void Unlink() MOZ_OVERRIDE {}
- virtual void Traverse(nsCycleCollectionTraversalCallback &aCb) MOZ_OVERRIDE {}
+ virtual void Unlink() {}
+ virtual void Traverse(nsCycleCollectionTraversalCallback &aCb) {}
protected:
virtual ~FileImplBase() {}
indexedDB::FileInfo* GetFileInfo() const
{
NS_ASSERTION(IsStoredFile(), "Should only be called on stored files!");
NS_ASSERTION(!mFileInfos.IsEmpty(), "Must have at least one file info!");
--- a/dom/base/FragmentOrElement.h
+++ b/dom/base/FragmentOrElement.h
@@ -94,17 +94,17 @@ public:
{
}
// nsISupports
NS_DECL_ISUPPORTS
// nsIWeakReference
NS_DECL_NSIWEAKREFERENCE
- virtual size_t SizeOfOnlyThis(mozilla::MallocSizeOf aMallocSizeOf) const MOZ_OVERRIDE;
+ virtual size_t SizeOfOnlyThis(mozilla::MallocSizeOf aMallocSizeOf) const;
void NoticeNodeDestruction()
{
mNode = nullptr;
}
private:
~nsNodeWeakReference();
--- a/dom/base/ImageEncoder.cpp
+++ b/dom/base/ImageEncoder.cpp
@@ -77,17 +77,17 @@ public:
: mImgSize(0)
, mType()
, mImgData(nullptr)
, mEncoderThread(aEncoderThread)
, mEncodeCompleteCallback(aEncodeCompleteCallback)
, mFailed(false)
{}
- NS_IMETHOD Run() MOZ_OVERRIDE
+ NS_IMETHOD Run()
{
nsresult rv = NS_OK;
MOZ_ASSERT(NS_IsMainThread());
if (!mFailed) {
// The correct parentObject has to be set by the mEncodeCompleteCallback.
nsRefPtr<File> blob =
File::CreateMemoryFile(nullptr, mImgData, mImgSize, mType);
@@ -185,17 +185,17 @@ public:
NS_ENSURE_TRUE(*aImgSize <= UINT32_MAX, NS_ERROR_FILE_TOO_BIG);
rv = NS_ReadInputStreamToBuffer(stream, aImgData, *aImgSize);
NS_ENSURE_SUCCESS(rv, rv);
return rv;
}
- NS_IMETHOD Run() MOZ_OVERRIDE
+ NS_IMETHOD Run()
{
uint64_t imgSize;
void* imgData = nullptr;
nsresult rv = ProcessImageData(&imgSize, &imgData);
if (NS_FAILED(rv)) {
mEncodingCompleteEvent->SetFailed();
} else {
--- a/dom/base/PerformanceResourceTiming.h
+++ b/dom/base/PerformanceResourceTiming.h
@@ -28,19 +28,19 @@ public:
PerformanceEntry)
PerformanceResourceTiming(nsPerformanceTiming* aPerformanceTiming,
nsPerformance* aPerformance);
virtual JSObject* WrapObject(JSContext* aCx) MOZ_OVERRIDE;
- virtual DOMHighResTimeStamp StartTime() const MOZ_OVERRIDE;
+ virtual DOMHighResTimeStamp StartTime() const;
- virtual DOMHighResTimeStamp Duration() const MOZ_OVERRIDE
+ virtual DOMHighResTimeStamp Duration() const
{
return ResponseEnd() - StartTime();
}
void GetInitiatorType(nsAString& aInitiatorType) const
{
aInitiatorType = mInitiatorType;
}
--- a/dom/base/WebSocket.cpp
+++ b/dom/base/WebSocket.cpp
@@ -1976,17 +1976,17 @@ public:
if (aStatus >= Canceling) {
mWebSocketImpl->mWorkerShuttingDown = true;
mWebSocketImpl->CloseConnection(nsIWebSocketChannel::CLOSE_GOING_AWAY);
}
return true;
}
- bool Suspend(JSContext* aCx) MOZ_OVERRIDE
+ bool Suspend(JSContext* aCx)
{
mWebSocketImpl->mWorkerShuttingDown = true;
mWebSocketImpl->CloseConnection(nsIWebSocketChannel::CLOSE_GOING_AWAY);
return true;
}
private:
WebSocketImpl* mWebSocketImpl;
--- a/dom/base/nsContentIterator.cpp
+++ b/dom/base/nsContentIterator.cpp
@@ -81,33 +81,33 @@ class nsContentIterator : public nsICont
public:
NS_DECL_CYCLE_COLLECTING_ISUPPORTS
NS_DECL_CYCLE_COLLECTION_CLASS(nsContentIterator)
explicit nsContentIterator(bool aPre);
// nsIContentIterator interface methods ------------------------------
- virtual nsresult Init(nsINode* aRoot) MOZ_OVERRIDE;
+ virtual nsresult Init(nsINode* aRoot);
- virtual nsresult Init(nsIDOMRange* aRange) MOZ_OVERRIDE;
+ virtual nsresult Init(nsIDOMRange* aRange);
- virtual void First() MOZ_OVERRIDE;
+ virtual void First();
- virtual void Last() MOZ_OVERRIDE;
+ virtual void Last();
- virtual void Next() MOZ_OVERRIDE;
+ virtual void Next();
- virtual void Prev() MOZ_OVERRIDE;
+ virtual void Prev();
- virtual nsINode* GetCurrentNode() MOZ_OVERRIDE;
+ virtual nsINode* GetCurrentNode();
- virtual bool IsDone() MOZ_OVERRIDE;
+ virtual bool IsDone();
- virtual nsresult PositionAt(nsINode* aCurNode) MOZ_OVERRIDE;
+ virtual nsresult PositionAt(nsINode* aCurNode);
protected:
virtual ~nsContentIterator();
// Recursively get the deepest first/last child of aRoot. This will return
// aRoot itself if it has no children.
nsINode* GetDeepFirstChild(nsINode* aRoot,
nsTArray<int32_t>* aIndexes = nullptr);
@@ -1108,31 +1108,31 @@ class nsContentSubtreeIterator : public
public:
nsContentSubtreeIterator() : nsContentIterator(false) {}
NS_DECL_ISUPPORTS_INHERITED
NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(nsContentSubtreeIterator, nsContentIterator)
// nsContentIterator overrides ------------------------------
- virtual nsresult Init(nsINode* aRoot) MOZ_OVERRIDE;
+ virtual nsresult Init(nsINode* aRoot);
- virtual nsresult Init(nsIDOMRange* aRange) MOZ_OVERRIDE;
+ virtual nsresult Init(nsIDOMRange* aRange);
- virtual void Next() MOZ_OVERRIDE;
+ virtual void Next();
- virtual void Prev() MOZ_OVERRIDE;
+ virtual void Prev();
- virtual nsresult PositionAt(nsINode* aCurNode) MOZ_OVERRIDE;
+ virtual nsresult PositionAt(nsINode* aCurNode);
// Must override these because we don't do PositionAt
- virtual void First() MOZ_OVERRIDE;
+ virtual void First();
// Must override these because we don't do PositionAt
- virtual void Last() MOZ_OVERRIDE;
+ virtual void Last();
protected:
virtual ~nsContentSubtreeIterator() {}
// Returns the highest inclusive ancestor of aNode that's in the range
// (possibly aNode itself). Returns null if aNode is null, or is not itself
// in the range. A node is in the range if (node, 0) comes strictly after
// the range endpoint, and (node, node.length) comes strictly before it, so
--- a/dom/base/nsContentUtils.cpp
+++ b/dom/base/nsContentUtils.cpp
@@ -334,17 +334,17 @@ class DOMEventListenerManagersHashReport
MOZ_DEFINE_MALLOC_SIZE_OF(MallocSizeOf)
~DOMEventListenerManagersHashReporter() {}
public:
NS_DECL_ISUPPORTS
NS_IMETHOD CollectReports(nsIHandleReportCallback* aHandleReport,
- nsISupports* aData, bool aAnonymize) MOZ_OVERRIDE
+ nsISupports* aData, bool aAnonymize)
{
// We don't measure the |EventListenerManager| objects pointed to by the
// entries because those references are non-owning.
int64_t amount = sEventListenerManagersHash.ops
? PL_DHashTableSizeOfExcludingThis(
&sEventListenerManagersHash, nullptr, MallocSizeOf)
: 0;
@@ -406,17 +406,17 @@ class SameOriginChecker MOZ_FINAL : publ
NS_DECL_NSIINTERFACEREQUESTOR
};
class CharsetDetectionObserver MOZ_FINAL : public nsICharsetDetectionObserver
{
public:
NS_DECL_ISUPPORTS
- NS_IMETHOD Notify(const char *aCharset, nsDetectionConfident aConf) MOZ_OVERRIDE
+ NS_IMETHOD Notify(const char *aCharset, nsDetectionConfident aConf)
{
mCharset = aCharset;
return NS_OK;
}
const nsACString& GetResult() const
{
return mCharset;
--- a/dom/base/nsDOMClassInfo.h
+++ b/dom/base/nsDOMClassInfo.h
@@ -280,17 +280,17 @@ public:
NS_IMETHOD Call(nsIXPConnectWrappedNative *wrapper, JSContext *cx,
JSObject *obj, const JS::CallArgs &args, bool *_retval) MOZ_OVERRIDE;
NS_IMETHOD Construct(nsIXPConnectWrappedNative *wrapper, JSContext *cx,
JSObject *obj, const JS::CallArgs &args, bool *_retval) MOZ_OVERRIDE;
NS_IMETHOD HasInstance(nsIXPConnectWrappedNative *wrapper, JSContext *cx,
JSObject *obj, JS::Handle<JS::Value> val, bool *bp,
- bool *_retval) MOZ_OVERRIDE;
+ bool *_retval);
static nsIClassInfo *doCreate(nsDOMClassInfoData* aData)
{
return new nsDOMConstructorSH(aData);
}
};
class nsNonDOMObjectSH : public nsDOMGenericSH
--- a/dom/base/nsDocument.cpp
+++ b/dom/base/nsDocument.cpp
@@ -9692,17 +9692,17 @@ namespace {
/**
* Stub for LoadSheet(), since all we want is to get the sheet into
* the CSSLoader's style cache
*/
class StubCSSLoaderObserver MOZ_FINAL : public nsICSSLoaderObserver {
~StubCSSLoaderObserver() {}
public:
NS_IMETHOD
- StyleSheetLoaded(CSSStyleSheet*, bool, nsresult) MOZ_OVERRIDE
+ StyleSheetLoaded(CSSStyleSheet*, bool, nsresult)
{
return NS_OK;
}
NS_DECL_ISUPPORTS
};
NS_IMPL_ISUPPORTS(StubCSSLoaderObserver, nsICSSLoaderObserver)
}
@@ -11832,17 +11832,17 @@ public:
nsPointerLockPermissionRequest(Element* aElement, bool aUserInputOrChromeCaller)
: mElement(do_GetWeakReference(aElement)),
mDocument(do_GetWeakReference(aElement->OwnerDoc())),
mUserInputOrChromeCaller(aUserInputOrChromeCaller) {}
NS_DECL_ISUPPORTS_INHERITED
NS_DECL_NSICONTENTPERMISSIONREQUEST
- NS_IMETHOD Run() MOZ_OVERRIDE
+ NS_IMETHOD Run()
{
nsCOMPtr<Element> e = do_QueryReferent(mElement);
nsCOMPtr<nsIDocument> d = do_QueryReferent(mDocument);
if (!e || !d || gPendingPointerLockRequest != this ||
e->GetUncomposedDoc() != d) {
Handled();
DispatchPointerLockError(d);
return NS_OK;
--- a/dom/base/nsDocument.h
+++ b/dom/base/nsDocument.h
@@ -986,75 +986,75 @@ public:
NS_DECL_NSIDOMXPATHEVALUATOR
virtual nsresult Init();
virtual nsresult CreateElem(const nsAString& aName, nsIAtom *aPrefix,
int32_t aNamespaceID,
nsIContent **aResult) MOZ_OVERRIDE;
- virtual void Sanitize() MOZ_OVERRIDE;
+ virtual void Sanitize();
virtual void EnumerateSubDocuments(nsSubDocEnumFunc aCallback,
- void *aData) MOZ_OVERRIDE;
+ void *aData);
- virtual bool CanSavePresentation(nsIRequest *aNewRequest) MOZ_OVERRIDE;
- virtual void Destroy() MOZ_OVERRIDE;
- virtual void RemovedFromDocShell() MOZ_OVERRIDE;
- virtual already_AddRefed<nsILayoutHistoryState> GetLayoutHistoryState() const MOZ_OVERRIDE;
+ virtual bool CanSavePresentation(nsIRequest *aNewRequest);
+ virtual void Destroy();
+ virtual void RemovedFromDocShell();
+ virtual already_AddRefed<nsILayoutHistoryState> GetLayoutHistoryState() const;
- virtual void BlockOnload() MOZ_OVERRIDE;
- virtual void UnblockOnload(bool aFireSync) MOZ_OVERRIDE;
+ virtual void BlockOnload();
+ virtual void UnblockOnload(bool aFireSync);
- virtual void AddStyleRelevantLink(mozilla::dom::Link* aLink) MOZ_OVERRIDE;
- virtual void ForgetLink(mozilla::dom::Link* aLink) MOZ_OVERRIDE;
+ virtual void AddStyleRelevantLink(mozilla::dom::Link* aLink);
+ virtual void ForgetLink(mozilla::dom::Link* aLink);
- virtual void ClearBoxObjectFor(nsIContent* aContent) MOZ_OVERRIDE;
+ void ClearBoxObjectFor(nsIContent* aContent);
virtual already_AddRefed<mozilla::dom::BoxObject>
GetBoxObjectFor(mozilla::dom::Element* aElement,
mozilla::ErrorResult& aRv) MOZ_OVERRIDE;
virtual Element*
GetAnonymousElementByAttribute(nsIContent* aElement,
nsIAtom* aAttrName,
- const nsAString& aAttrValue) const MOZ_OVERRIDE;
+ const nsAString& aAttrValue) const;
virtual Element* ElementFromPointHelper(float aX, float aY,
bool aIgnoreRootScrollFrame,
- bool aFlushLayout) MOZ_OVERRIDE;
+ bool aFlushLayout);
virtual nsresult NodesFromRectHelper(float aX, float aY,
float aTopSize, float aRightSize,
float aBottomSize, float aLeftSize,
bool aIgnoreRootScrollFrame,
bool aFlushLayout,
- nsIDOMNodeList** aReturn) MOZ_OVERRIDE;
+ nsIDOMNodeList** aReturn);
- virtual void FlushSkinBindings() MOZ_OVERRIDE;
+ virtual void FlushSkinBindings();
- virtual nsresult InitializeFrameLoader(nsFrameLoader* aLoader) MOZ_OVERRIDE;
- virtual nsresult FinalizeFrameLoader(nsFrameLoader* aLoader) MOZ_OVERRIDE;
- virtual void TryCancelFrameLoaderInitialization(nsIDocShell* aShell) MOZ_OVERRIDE;
- virtual bool FrameLoaderScheduledToBeFinalized(nsIDocShell* aShell) MOZ_OVERRIDE;
+ virtual nsresult InitializeFrameLoader(nsFrameLoader* aLoader);
+ virtual nsresult FinalizeFrameLoader(nsFrameLoader* aLoader);
+ virtual void TryCancelFrameLoaderInitialization(nsIDocShell* aShell);
+ virtual bool FrameLoaderScheduledToBeFinalized(nsIDocShell* aShell);
virtual nsIDocument*
RequestExternalResource(nsIURI* aURI,
nsINode* aRequestingNode,
- ExternalResourceLoad** aPendingLoad) MOZ_OVERRIDE;
+ ExternalResourceLoad** aPendingLoad);
virtual void
- EnumerateExternalResources(nsSubDocEnumFunc aCallback, void* aData) MOZ_OVERRIDE;
+ EnumerateExternalResources(nsSubDocEnumFunc aCallback, void* aData);
nsTArray<nsCString> mHostObjectURIs;
// Returns our (lazily-initialized) animation controller.
// If HasAnimationController is true, this is guaranteed to return non-null.
nsSMILAnimationController* GetAnimationController() MOZ_OVERRIDE;
virtual mozilla::PendingPlayerTracker*
- GetPendingPlayerTracker() MOZ_FINAL MOZ_OVERRIDE
+ GetPendingPlayerTracker() MOZ_FINAL
{
return mPendingPlayerTracker;
}
virtual mozilla::PendingPlayerTracker*
GetOrCreatePendingPlayerTracker() MOZ_OVERRIDE;
void SetImagesNeedAnimating(bool aAnimating) MOZ_OVERRIDE;
@@ -1130,19 +1130,19 @@ public:
virtual Element *GetElementById(const nsAString& aElementId) MOZ_OVERRIDE;
virtual const nsSmallVoidArray* GetAllElementsForId(const nsAString& aElementId) const MOZ_OVERRIDE;
virtual Element *LookupImageElement(const nsAString& aElementId) MOZ_OVERRIDE;
virtual void MozSetImageElement(const nsAString& aImageElementId,
Element* aElement) MOZ_OVERRIDE;
- virtual nsresult AddImage(imgIRequest* aImage) MOZ_OVERRIDE;
- virtual nsresult RemoveImage(imgIRequest* aImage, uint32_t aFlags) MOZ_OVERRIDE;
- virtual nsresult SetImageLockingState(bool aLocked) MOZ_OVERRIDE;
+ virtual nsresult AddImage(imgIRequest* aImage);
+ virtual nsresult RemoveImage(imgIRequest* aImage, uint32_t aFlags);
+ virtual nsresult SetImageLockingState(bool aLocked);
// AddPlugin adds a plugin-related element to mPlugins when the element is
// added to the tree.
virtual nsresult AddPlugin(nsIObjectLoadingContent* aPlugin) MOZ_OVERRIDE;
// RemovePlugin removes a plugin-related element to mPlugins when the
// element is removed from the tree.
virtual void RemovePlugin(nsIObjectLoadingContent* aPlugin) MOZ_OVERRIDE;
// GetPlugins returns the plugin-related elements from
@@ -1307,35 +1307,35 @@ public:
const nsAString& aTypeExtension,
mozilla::ErrorResult& rv) MOZ_OVERRIDE;
virtual already_AddRefed<Element> CreateElementNS(const nsAString& aNamespaceURI,
const nsAString& aQualifiedName,
const nsAString& aTypeExtension,
mozilla::ErrorResult& rv) MOZ_OVERRIDE;
virtual void UseRegistryFromDocument(nsIDocument* aDocument) MOZ_OVERRIDE;
- virtual nsIDocument* MasterDocument() MOZ_OVERRIDE
+ virtual nsIDocument* MasterDocument()
{
return mMasterDocument ? mMasterDocument.get()
: this;
}
- virtual void SetMasterDocument(nsIDocument* master) MOZ_OVERRIDE
+ virtual void SetMasterDocument(nsIDocument* master)
{
MOZ_ASSERT(master);
mMasterDocument = master;
UseRegistryFromDocument(mMasterDocument);
}
- virtual bool IsMasterDocument() MOZ_OVERRIDE
+ virtual bool IsMasterDocument()
{
return !mMasterDocument;
}
- virtual mozilla::dom::ImportManager* ImportManager() MOZ_OVERRIDE
+ virtual mozilla::dom::ImportManager* ImportManager()
{
if (mImportManager) {
MOZ_ASSERT(!mMasterDocument, "Only the master document has ImportManager set");
return mImportManager.get();
}
if (mMasterDocument) {
return mMasterDocument->ImportManager();
@@ -1344,32 +1344,32 @@ public:
// ImportManager is created lazily.
// If the manager is not yet set it has to be the
// master document and this is the first import in it.
// Let's create a new manager.
mImportManager = new mozilla::dom::ImportManager();
return mImportManager.get();
}
- virtual bool HasSubImportLink(nsINode* aLink) MOZ_OVERRIDE
+ virtual bool HasSubImportLink(nsINode* aLink)
{
return mSubImportLinks.Contains(aLink);
}
- virtual uint32_t IndexOfSubImportLink(nsINode* aLink) MOZ_OVERRIDE
+ virtual uint32_t IndexOfSubImportLink(nsINode* aLink)
{
return mSubImportLinks.IndexOf(aLink);
}
- virtual void AddSubImportLink(nsINode* aLink) MOZ_OVERRIDE
+ virtual void AddSubImportLink(nsINode* aLink)
{
mSubImportLinks.AppendElement(aLink);
}
- virtual nsINode* GetSubImportLink(uint32_t aIdx) MOZ_OVERRIDE
+ virtual nsINode* GetSubImportLink(uint32_t aIdx)
{
return aIdx < mSubImportLinks.Length() ? mSubImportLinks[aIdx].get()
: nullptr;
}
virtual void UnblockDOMContentLoaded() MOZ_OVERRIDE;
protected:
@@ -1557,17 +1557,17 @@ private:
public:
static void ProcessBaseElementQueue();
// Enqueue created callback or register upgrade candidate for
// newly created custom elements, possibly extending an existing type.
// ex. <x-button>, <button is="x-button> (type extension)
virtual void SetupCustomElement(Element* aElement,
uint32_t aNamespaceID,
- const nsAString* aTypeExtension) MOZ_OVERRIDE;
+ const nsAString* aTypeExtension);
static bool IsWebComponentsEnabled(JSContext* aCx, JSObject* aObject);
// The "registry" from the web components spec.
nsRefPtr<mozilla::dom::Registry> mRegistry;
nsRefPtr<mozilla::EventListenerManager> mListenerManager;
nsRefPtr<mozilla::dom::StyleSheetList> mDOMStyleSheets;
--- a/dom/base/nsFrameMessageManager.cpp
+++ b/dom/base/nsFrameMessageManager.cpp
@@ -1850,17 +1850,17 @@ public:
}
return true;
}
virtual bool DoSendAsyncMessage(JSContext* aCx,
const nsAString& aMessage,
const mozilla::dom::StructuredCloneData& aData,
JS::Handle<JSObject *> aCpows,
- nsIPrincipal* aPrincipal) MOZ_OVERRIDE
+ nsIPrincipal* aPrincipal)
{
if (!nsFrameMessageManager::sPendingSameProcessAsyncMessages) {
nsFrameMessageManager::sPendingSameProcessAsyncMessages = new nsTArray<nsCOMPtr<nsIRunnable> >;
}
nsCOMPtr<nsIRunnable> ev =
new nsAsyncMessageToSameProcessParent(aCx, aMessage, aData, aCpows, aPrincipal);
nsFrameMessageManager::sPendingSameProcessAsyncMessages->AppendElement(ev);
NS_DispatchToCurrentThread(ev);
--- a/dom/base/nsFrameMessageManager.h
+++ b/dom/base/nsFrameMessageManager.h
@@ -422,16 +422,16 @@ class nsScriptCacheCleaner MOZ_FINAL : p
{
nsCOMPtr<nsIObserverService> obsSvc = mozilla::services::GetObserverService();
if (obsSvc)
obsSvc->AddObserver(this, "xpcom-shutdown", false);
}
NS_IMETHODIMP Observe(nsISupports *aSubject,
const char *aTopic,
- const char16_t *aData) MOZ_OVERRIDE
+ const char16_t *aData)
{
nsFrameScriptExecutor::Shutdown();
return NS_OK;
}
};
#endif
--- a/dom/base/nsGenConImageContent.cpp
+++ b/dom/base/nsGenConImageContent.cpp
@@ -36,21 +36,21 @@ public:
{
// No need to notify, since we have no frame.
return UseAsPrimaryRequest(aImageRequest, false, eImageLoadType_Normal);
}
// nsIContent overrides
virtual nsresult BindToTree(nsIDocument* aDocument, nsIContent* aParent,
nsIContent* aBindingParent,
- bool aCompileEventHandlers) MOZ_OVERRIDE;
- virtual void UnbindFromTree(bool aDeep, bool aNullParent) MOZ_OVERRIDE;
- virtual EventStates IntrinsicState() const MOZ_OVERRIDE;
+ bool aCompileEventHandlers);
+ virtual void UnbindFromTree(bool aDeep, bool aNullParent);
+ virtual EventStates IntrinsicState() const;
- virtual nsresult PreHandleEvent(EventChainPreVisitor& aVisitor) MOZ_OVERRIDE
+ virtual nsresult PreHandleEvent(EventChainPreVisitor& aVisitor)
{
MOZ_ASSERT(IsInNativeAnonymousSubtree());
if (aVisitor.mEvent->message == NS_LOAD ||
aVisitor.mEvent->message == NS_LOAD_ERROR) {
// Don't propagate the events to the parent.
return NS_OK;
}
return nsXMLElement::PreHandleEvent(aVisitor);
--- a/dom/base/nsGenericDOMDataNode.h
+++ b/dom/base/nsGenericDOMDataNode.h
@@ -223,17 +223,17 @@ public:
void ToCString(nsAString& aBuf, int32_t aOffset, int32_t aLen) const;
#endif
NS_DECL_CYCLE_COLLECTION_SKIPPABLE_SCRIPT_HOLDER_CLASS(nsGenericDOMDataNode)
protected:
virtual ~nsGenericDOMDataNode();
- virtual mozilla::dom::Element* GetNameSpaceElement() MOZ_OVERRIDE
+ virtual mozilla::dom::Element* GetNameSpaceElement()
{
nsINode *parent = GetParentNode();
return parent && parent->IsElement() ? parent->AsElement() : nullptr;
}
/**
* There are a set of DOM- and scripting-specific instance variables
--- a/dom/base/nsGlobalWindow.cpp
+++ b/dom/base/nsGlobalWindow.cpp
@@ -475,24 +475,24 @@ static const char sPopStatePrefStr[] = "
* on nsGlobalWindow, where any script could see it.
*/
class nsGlobalWindowObserver MOZ_FINAL : public nsIObserver,
public nsIInterfaceRequestor
{
public:
explicit nsGlobalWindowObserver(nsGlobalWindow* aWindow) : mWindow(aWindow) {}
NS_DECL_ISUPPORTS
- NS_IMETHOD Observe(nsISupports* aSubject, const char* aTopic, const char16_t* aData) MOZ_OVERRIDE
+ NS_IMETHOD Observe(nsISupports* aSubject, const char* aTopic, const char16_t* aData)
{
if (!mWindow)
return NS_OK;
return mWindow->Observe(aSubject, aTopic, aData);
}
void Forget() { mWindow = nullptr; }
- NS_IMETHODIMP GetInterface(const nsIID& aIID, void** aResult) MOZ_OVERRIDE
+ NS_IMETHODIMP GetInterface(const nsIID& aIID, void** aResult)
{
if (mWindow && aIID.Equals(NS_GET_IID(nsIDOMWindow)) && mWindow) {
return mWindow->QueryInterface(aIID, aResult);
}
return NS_NOINTERFACE;
}
private:
--- a/dom/base/nsGlobalWindow.h
+++ b/dom/base/nsGlobalWindow.h
@@ -353,38 +353,38 @@ public:
// nsWrapperCache
virtual JSObject *WrapObject(JSContext *cx) MOZ_OVERRIDE
{
return IsInnerWindow() || EnsureInnerWindow() ? GetWrapper() : nullptr;
}
// nsIGlobalJSObjectHolder
- virtual JSObject* GetGlobalJSObject() MOZ_OVERRIDE;
+ virtual JSObject *GetGlobalJSObject();
// nsIScriptGlobalObject
JSObject *FastGetGlobalJSObject() const
{
return GetWrapperPreserveColor();
}
void TraceGlobalJSObject(JSTracer* aTrc);
- virtual nsresult EnsureScriptEnvironment() MOZ_OVERRIDE;
+ virtual nsresult EnsureScriptEnvironment();
- virtual nsIScriptContext *GetScriptContext() MOZ_OVERRIDE;
+ virtual nsIScriptContext *GetScriptContext();
void PoisonOuterWindowProxy(JSObject *aObject);
- virtual bool IsBlackForCC(bool aTracingNeeded = true) MOZ_OVERRIDE;
+ virtual bool IsBlackForCC(bool aTracingNeeded = true);
static JSObject* OuterObject(JSContext* aCx, JS::Handle<JSObject*> aObj);
// nsIScriptObjectPrincipal
- virtual nsIPrincipal* GetPrincipal() MOZ_OVERRIDE;
+ virtual nsIPrincipal* GetPrincipal();
// nsIDOMWindow
NS_DECL_NSIDOMWINDOW
// nsIDOMJSWindow
NS_DECL_NSIDOMJSWINDOW
// nsIDOMEventTarget
@@ -407,86 +407,86 @@ public:
if (IsOuterWindow()) {
return this;
}
return GetOuterFromCurrentInner(this);
}
// nsPIDOMWindow
- virtual nsPIDOMWindow* GetPrivateRoot() MOZ_OVERRIDE;
+ virtual nsPIDOMWindow* GetPrivateRoot();
// Outer windows only.
- virtual void ActivateOrDeactivate(bool aActivate) MOZ_OVERRIDE;
- virtual void SetActive(bool aActive) MOZ_OVERRIDE;
- virtual void SetIsBackground(bool aIsBackground) MOZ_OVERRIDE;
- virtual void SetChromeEventHandler(mozilla::dom::EventTarget* aChromeEventHandler) MOZ_OVERRIDE;
+ virtual void ActivateOrDeactivate(bool aActivate);
+ virtual void SetActive(bool aActive);
+ virtual void SetIsBackground(bool aIsBackground);
+ virtual void SetChromeEventHandler(mozilla::dom::EventTarget* aChromeEventHandler);
// Outer windows only.
- virtual void SetInitialPrincipalToSubject() MOZ_OVERRIDE;
+ virtual void SetInitialPrincipalToSubject();
- virtual PopupControlState PushPopupControlState(PopupControlState state, bool aForce) const MOZ_OVERRIDE;
- virtual void PopPopupControlState(PopupControlState state) const MOZ_OVERRIDE;
- virtual PopupControlState GetPopupControlState() const MOZ_OVERRIDE;
+ virtual PopupControlState PushPopupControlState(PopupControlState state, bool aForce) const;
+ virtual void PopPopupControlState(PopupControlState state) const;
+ virtual PopupControlState GetPopupControlState() const;
- virtual already_AddRefed<nsISupports> SaveWindowState() MOZ_OVERRIDE;
- virtual nsresult RestoreWindowState(nsISupports *aState) MOZ_OVERRIDE;
+ virtual already_AddRefed<nsISupports> SaveWindowState();
+ virtual nsresult RestoreWindowState(nsISupports *aState);
virtual void SuspendTimeouts(uint32_t aIncrease = 1,
- bool aFreezeChildren = true) MOZ_OVERRIDE;
- virtual nsresult ResumeTimeouts(bool aThawChildren = true) MOZ_OVERRIDE;
- virtual uint32_t TimeoutSuspendCount() MOZ_OVERRIDE;
- virtual nsresult FireDelayedDOMEvents() MOZ_OVERRIDE;
- virtual bool IsFrozen() const MOZ_OVERRIDE
+ bool aFreezeChildren = true);
+ virtual nsresult ResumeTimeouts(bool aThawChildren = true);
+ virtual uint32_t TimeoutSuspendCount();
+ virtual nsresult FireDelayedDOMEvents();
+ virtual bool IsFrozen() const
{
return mIsFrozen;
}
- virtual bool IsRunningTimeout() MOZ_OVERRIDE { return mTimeoutFiringDepth > 0; }
+ virtual bool IsRunningTimeout() { return mTimeoutFiringDepth > 0; }
// Outer windows only.
- virtual bool WouldReuseInnerWindow(nsIDocument* aNewDocument) MOZ_OVERRIDE;
+ virtual bool WouldReuseInnerWindow(nsIDocument* aNewDocument);
- virtual void SetDocShell(nsIDocShell* aDocShell) MOZ_OVERRIDE;
- virtual void DetachFromDocShell() MOZ_OVERRIDE;
+ virtual void SetDocShell(nsIDocShell* aDocShell);
+ virtual void DetachFromDocShell();
virtual nsresult SetNewDocument(nsIDocument *aDocument,
- nsISupports *aState,
- bool aForceReuseInnerWindow) MOZ_OVERRIDE;
+ nsISupports *aState,
+ bool aForceReuseInnerWindow);
// Outer windows only.
void DispatchDOMWindowCreated();
virtual void SetOpenerWindow(nsIDOMWindow* aOpener,
- bool aOriginalOpener) MOZ_OVERRIDE;
+ bool aOriginalOpener);
// Outer windows only.
- virtual void EnsureSizeUpToDate() MOZ_OVERRIDE;
+ virtual void EnsureSizeUpToDate();
- virtual void EnterModalState() MOZ_OVERRIDE;
- virtual void LeaveModalState() MOZ_OVERRIDE;
+ virtual void EnterModalState();
+ virtual void LeaveModalState();
// Outer windows only.
- virtual bool CanClose() MOZ_OVERRIDE;
- virtual void ForceClose() MOZ_OVERRIDE;
+ virtual bool CanClose();
+ virtual void ForceClose();
- virtual void MaybeUpdateTouchState() MOZ_OVERRIDE;
- virtual void UpdateTouchState() MOZ_OVERRIDE;
+ virtual void MaybeUpdateTouchState();
+ virtual void UpdateTouchState();
// Outer windows only.
- virtual bool DispatchCustomEvent(const nsAString& aEventName) MOZ_OVERRIDE;
+ virtual bool DispatchCustomEvent(const nsAString& aEventName);
bool DispatchResizeEvent(const mozilla::CSSIntSize& aSize);
// Inner windows only.
- virtual void RefreshCompartmentPrincipal() MOZ_OVERRIDE;
+ virtual void RefreshCompartmentPrincipal();
// Outer windows only.
virtual nsresult SetFullScreenInternal(bool aIsFullScreen, bool aRequireTrust,
- mozilla::gfx::VRHMDInfo *aHMD = nullptr) MOZ_OVERRIDE;
+ mozilla::gfx::VRHMDInfo *aHMD = nullptr);
bool FullScreen() const;
// Inner windows only.
- virtual void SetHasGamepadEventListener(bool aHasGamepad = true) MOZ_OVERRIDE;
+ virtual void SetHasGamepadEventListener(bool aHasGamepad = true);
// nsIInterfaceRequestor
NS_DECL_NSIINTERFACEREQUESTOR
// WebIDL interface.
already_AddRefed<nsIDOMWindow> IndexedGetter(uint32_t aIndex, bool& aFound);
void GetSupportedNames(nsTArray<nsString>& aNames);
@@ -627,58 +627,58 @@ public:
#ifdef DEBUG
// Call Unlink on this window. This may cause bad things to happen, so use
// with caution.
void RiskyUnlink();
#endif
virtual JSObject*
- GetCachedXBLPrototypeHandler(nsXBLPrototypeHandler* aKey) MOZ_OVERRIDE;
+ GetCachedXBLPrototypeHandler(nsXBLPrototypeHandler* aKey);
virtual void
CacheXBLPrototypeHandler(nsXBLPrototypeHandler* aKey,
- JS::Handle<JSObject*> aHandler) MOZ_OVERRIDE;
+ JS::Handle<JSObject*> aHandler);
- virtual bool TakeFocus(bool aFocus, uint32_t aFocusMethod) MOZ_OVERRIDE;
- virtual void SetReadyForFocus() MOZ_OVERRIDE;
- virtual void PageHidden() MOZ_OVERRIDE;
- virtual nsresult DispatchAsyncHashchange(nsIURI *aOldURI, nsIURI *aNewURI) MOZ_OVERRIDE;
- virtual nsresult DispatchSyncPopState() MOZ_OVERRIDE;
+ virtual bool TakeFocus(bool aFocus, uint32_t aFocusMethod);
+ virtual void SetReadyForFocus();
+ virtual void PageHidden();
+ virtual nsresult DispatchAsyncHashchange(nsIURI *aOldURI, nsIURI *aNewURI);
+ virtual nsresult DispatchSyncPopState();
// Inner windows only.
- virtual void EnableDeviceSensor(uint32_t aType) MOZ_OVERRIDE;
- virtual void DisableDeviceSensor(uint32_t aType) MOZ_OVERRIDE;
+ virtual void EnableDeviceSensor(uint32_t aType);
+ virtual void DisableDeviceSensor(uint32_t aType);
- virtual void EnableTimeChangeNotifications() MOZ_OVERRIDE;
- virtual void DisableTimeChangeNotifications() MOZ_OVERRIDE;
+ virtual void EnableTimeChangeNotifications();
+ virtual void DisableTimeChangeNotifications();
#ifdef MOZ_B2G
// Inner windows only.
- virtual void EnableNetworkEvent(uint32_t aType) MOZ_OVERRIDE;
- virtual void DisableNetworkEvent(uint32_t aType) MOZ_OVERRIDE;
+ virtual void EnableNetworkEvent(uint32_t aType);
+ virtual void DisableNetworkEvent(uint32_t aType);
#endif // MOZ_B2G
- virtual nsresult SetArguments(nsIArray* aArguments) MOZ_OVERRIDE;
+ virtual nsresult SetArguments(nsIArray *aArguments);
void MaybeForgiveSpamCount();
bool IsClosedOrClosing() {
return (mIsClosed ||
mInClose ||
mHavePendingClose ||
mCleanedUp);
}
virtual void
FirePopupBlockedEvent(nsIDocument* aDoc,
nsIURI* aPopupURI,
const nsAString& aPopupWindowName,
const nsAString& aPopupWindowFeatures) MOZ_OVERRIDE;
- virtual uint32_t GetSerial() MOZ_OVERRIDE {
+ virtual uint32_t GetSerial() {
return mSerial;
}
static nsGlobalWindow* GetOuterWindowWithId(uint64_t aWindowID) {
AssertIsOnMainThread();
if (!sWindowsById) {
return nullptr;
@@ -1148,17 +1148,17 @@ protected:
// Window Control Functions
// Outer windows only.
virtual nsresult
OpenNoNavigate(const nsAString& aUrl,
const nsAString& aName,
const nsAString& aOptions,
- nsIDOMWindow** _retval) MOZ_OVERRIDE;
+ nsIDOMWindow **_retval);
private:
/**
* @param aUrl the URL we intend to load into the window. If aNavigate is
* true, we'll actually load this URL into the window. Otherwise,
* aUrl is advisory; OpenInternal will not load the URL into the
* new window.
*
@@ -1217,27 +1217,27 @@ private:
nsIDOMWindow **aReturn);
public:
// Timeout Functions
// Language agnostic timeout function (all args passed).
// |interval| is in milliseconds.
nsresult SetTimeoutOrInterval(nsIScriptTimeoutHandler *aHandler,
int32_t interval,
- bool aIsInterval, int32_t* aReturn) MOZ_OVERRIDE;
+ bool aIsInterval, int32_t *aReturn);
int32_t SetTimeoutOrInterval(mozilla::dom::Function& aFunction,
int32_t aTimeout,
const mozilla::dom::Sequence<JS::Value>& aArguments,
bool aIsInterval, mozilla::ErrorResult& aError);
int32_t SetTimeoutOrInterval(JSContext* aCx, const nsAString& aHandler,
int32_t aTimeout, bool aIsInterval,
mozilla::ErrorResult& aError);
void ClearTimeoutOrInterval(int32_t aTimerID,
mozilla::ErrorResult& aError);
- nsresult ClearTimeoutOrInterval(int32_t aTimerID) MOZ_OVERRIDE
+ nsresult ClearTimeoutOrInterval(int32_t aTimerID)
{
mozilla::ErrorResult rv;
ClearTimeoutOrInterval(aTimerID, rv);
return rv.ErrorCode();
}
// JS specific timeout functions (JS args grabbed from context).
nsresult SetTimeoutOrInterval(bool aIsInterval, int32_t* aReturn);
@@ -1272,20 +1272,20 @@ public:
const nsAString &aPopupWindowFeatures);
void FireOfflineStatusEventIfChanged();
// Inner windows only.
nsresult ScheduleNextIdleObserverCallback();
uint32_t GetFuzzTimeMS();
nsresult ScheduleActiveTimerCallback();
uint32_t FindInsertionIndex(IdleObserverHolder* aIdleObserver);
- virtual nsresult RegisterIdleObserver(nsIIdleObserver* aIdleObserverPtr) MOZ_OVERRIDE;
+ virtual nsresult RegisterIdleObserver(nsIIdleObserver* aIdleObserverPtr);
nsresult FindIndexOfElementToRemove(nsIIdleObserver* aIdleObserver,
int32_t* aRemoveElementIndex);
- virtual nsresult UnregisterIdleObserver(nsIIdleObserver* aIdleObserverPtr) MOZ_OVERRIDE;
+ virtual nsresult UnregisterIdleObserver(nsIIdleObserver* aIdleObserverPtr);
// Inner windows only.
nsresult FireHashchange(const nsAString &aOldURL, const nsAString &aNewURL);
void FlushPendingNotifications(mozFlushType aType);
// Outer windows only.
void EnsureReflowFlushAndPaint();
@@ -1357,43 +1357,43 @@ public:
// context is not available, they will assume a 1:1 ratio.
int32_t DevToCSSIntPixels(int32_t px);
int32_t CSSToDevIntPixels(int32_t px);
nsIntSize DevToCSSIntPixels(nsIntSize px);
nsIntSize CSSToDevIntPixels(nsIntSize px);
virtual void SetFocusedNode(nsIContent* aNode,
uint32_t aFocusMethod = 0,
- bool aNeedsFocus = false) MOZ_OVERRIDE;
+ bool aNeedsFocus = false);
- virtual uint32_t GetFocusMethod() MOZ_OVERRIDE;
+ virtual uint32_t GetFocusMethod();
- virtual bool ShouldShowFocusRing() MOZ_OVERRIDE;
+ virtual bool ShouldShowFocusRing();
virtual void SetKeyboardIndicators(UIStateChangeType aShowAccelerators,
- UIStateChangeType aShowFocusRings) MOZ_OVERRIDE;
+ UIStateChangeType aShowFocusRings);
virtual void GetKeyboardIndicators(bool* aShowAccelerators,
- bool* aShowFocusRings) MOZ_OVERRIDE;
+ bool* aShowFocusRings);
// Inner windows only.
void UpdateCanvasFocus(bool aFocusChanged, nsIContent* aNewContent);
public:
virtual already_AddRefed<nsPIWindowRoot> GetTopWindowRoot() MOZ_OVERRIDE;
protected:
static void NotifyDOMWindowDestroyed(nsGlobalWindow* aWindow);
void NotifyWindowIDDestroyed(const char* aTopic);
static void NotifyDOMWindowFrozen(nsGlobalWindow* aWindow);
static void NotifyDOMWindowThawed(nsGlobalWindow* aWindow);
void ClearStatus();
- virtual void UpdateParentTarget() MOZ_OVERRIDE;
+ virtual void UpdateParentTarget();
inline int32_t DOMMinTimeoutValue() const;
// Clear the document-dependent slots on our JS wrapper. Inner windows only.
void ClearDocumentDependentSlots(JSContext* aCx);
// Inner windows only.
already_AddRefed<mozilla::dom::StorageEvent>
--- a/dom/base/nsGlobalWindowCommands.cpp
+++ b/dom/base/nsGlobalWindowCommands.cpp
@@ -107,19 +107,19 @@ const char * const sSelectDown2String =
#pragma mark -
#endif
// a base class for selection-related commands, for code sharing
class nsSelectionCommandsBase : public nsIControllerCommand
{
public:
NS_DECL_ISUPPORTS
- NS_IMETHOD IsCommandEnabled(const char* aCommandName, nsISupports* aCommandContext, bool* _retval) MOZ_OVERRIDE;
- NS_IMETHOD GetCommandStateParams(const char* aCommandName, nsICommandParams* aParams, nsISupports* aCommandContext) MOZ_OVERRIDE;
- NS_IMETHOD DoCommandParams(const char* aCommandName, nsICommandParams* aParams, nsISupports* aCommandContext) MOZ_OVERRIDE;
+ NS_IMETHOD IsCommandEnabled(const char * aCommandName, nsISupports *aCommandContext, bool *_retval);
+ NS_IMETHOD GetCommandStateParams(const char * aCommandName, nsICommandParams *aParams, nsISupports *aCommandContext);
+ NS_IMETHOD DoCommandParams(const char * aCommandName, nsICommandParams *aParams, nsISupports *aCommandContext);
protected:
virtual ~nsSelectionCommandsBase() {}
static nsresult GetPresShellFromWindow(nsPIDOMWindow *aWindow, nsIPresShell **aPresShell);
static nsresult GetSelectionControllerFromWindow(nsPIDOMWindow *aWindow, nsISelectionController **aSelCon);
// no member variables, please, we're stateless!
--- a/dom/base/nsHostObjectProtocolHandler.cpp
+++ b/dom/base/nsHostObjectProtocolHandler.cpp
@@ -39,17 +39,17 @@ namespace mozilla {
class HostObjectURLsReporter MOZ_FINAL : public nsIMemoryReporter
{
~HostObjectURLsReporter() {}
public:
NS_DECL_ISUPPORTS
NS_IMETHOD CollectReports(nsIHandleReportCallback* aHandleReport,
- nsISupports* aData, bool aAnonymize) MOZ_OVERRIDE
+ nsISupports* aData, bool aAnonymize)
{
return MOZ_COLLECT_REPORT(
"host-object-urls", KIND_OTHER, UNITS_COUNT,
gDataTable ? gDataTable->Count() : 0,
"The number of host objects stored for access via URLs "
"(e.g. blobs passed to URL.createObjectURL).");
}
};
@@ -57,17 +57,17 @@ class HostObjectURLsReporter MOZ_FINAL :
NS_IMPL_ISUPPORTS(HostObjectURLsReporter, nsIMemoryReporter)
class BlobURLsReporter MOZ_FINAL : public nsIMemoryReporter
{
public:
NS_DECL_ISUPPORTS
NS_IMETHOD CollectReports(nsIHandleReportCallback* aCallback,
- nsISupports* aData, bool aAnonymize) MOZ_OVERRIDE
+ nsISupports* aData, bool aAnonymize)
{
EnumArg env;
env.mCallback = aCallback;
env.mData = aData;
env.mAnonymize = aAnonymize;
if (gDataTable) {
gDataTable->EnumerateRead(CountCallback, &env);
--- a/dom/base/nsIDocument.h
+++ b/dom/base/nsIDocument.h
@@ -2503,17 +2503,17 @@ protected:
* These methods should be called before and after dispatching
* a mutation event.
* To make this easy and painless, use the mozAutoSubtreeModified helper class.
*/
virtual void WillDispatchMutationEvent(nsINode* aTarget) = 0;
virtual void MutationEventDispatched(nsINode* aTarget) = 0;
friend class mozAutoSubtreeModified;
- virtual Element* GetNameSpaceElement() MOZ_OVERRIDE
+ virtual Element* GetNameSpaceElement()
{
return GetRootElement();
}
void SetContentTypeInternal(const nsACString& aType);
nsCString GetContentTypeInternal() const
{
--- a/dom/base/nsIDocumentObserver.h
+++ b/dom/base/nsIDocumentObserver.h
@@ -190,66 +190,66 @@ public:
nsIStyleSheet* aStyleSheet,
nsIStyleRule* aStyleRule) = 0;
};
NS_DEFINE_STATIC_IID_ACCESSOR(nsIDocumentObserver, NS_IDOCUMENT_OBSERVER_IID)
#define NS_DECL_NSIDOCUMENTOBSERVER_BEGINUPDATE \
virtual void BeginUpdate(nsIDocument* aDocument, \
- nsUpdateType aUpdateType) MOZ_OVERRIDE;
+ nsUpdateType aUpdateType);
#define NS_DECL_NSIDOCUMENTOBSERVER_ENDUPDATE \
- virtual void EndUpdate(nsIDocument* aDocument, nsUpdateType aUpdateType) MOZ_OVERRIDE;
+ virtual void EndUpdate(nsIDocument* aDocument, nsUpdateType aUpdateType);
#define NS_DECL_NSIDOCUMENTOBSERVER_BEGINLOAD \
- virtual void BeginLoad(nsIDocument* aDocument) MOZ_OVERRIDE;
+ virtual void BeginLoad(nsIDocument* aDocument);
#define NS_DECL_NSIDOCUMENTOBSERVER_ENDLOAD \
- virtual void EndLoad(nsIDocument* aDocument) MOZ_OVERRIDE;
+ virtual void EndLoad(nsIDocument* aDocument);
#define NS_DECL_NSIDOCUMENTOBSERVER_CONTENTSTATECHANGED \
virtual void ContentStateChanged(nsIDocument* aDocument, \
nsIContent* aContent, \
- mozilla::EventStates aStateMask) MOZ_OVERRIDE;
+ mozilla::EventStates aStateMask);
#define NS_DECL_NSIDOCUMENTOBSERVER_DOCUMENTSTATESCHANGED \
virtual void DocumentStatesChanged(nsIDocument* aDocument, \
- mozilla::EventStates aStateMask) MOZ_OVERRIDE;
+ mozilla::EventStates aStateMask);
#define NS_DECL_NSIDOCUMENTOBSERVER_STYLESHEETADDED \
virtual void StyleSheetAdded(nsIDocument* aDocument, \
nsIStyleSheet* aStyleSheet, \
- bool aDocumentSheet) MOZ_OVERRIDE;
+ bool aDocumentSheet);
#define NS_DECL_NSIDOCUMENTOBSERVER_STYLESHEETREMOVED \
virtual void StyleSheetRemoved(nsIDocument* aDocument, \
nsIStyleSheet* aStyleSheet, \
- bool aDocumentSheet) MOZ_OVERRIDE;
+ bool aDocumentSheet);
#define NS_DECL_NSIDOCUMENTOBSERVER_STYLESHEETAPPLICABLESTATECHANGED \
virtual void StyleSheetApplicableStateChanged(nsIDocument* aDocument, \
nsIStyleSheet* aStyleSheet,\
- bool aApplicable) MOZ_OVERRIDE;
+ bool aApplicable);
#define NS_DECL_NSIDOCUMENTOBSERVER_STYLERULECHANGED \
virtual void StyleRuleChanged(nsIDocument* aDocument, \
nsIStyleSheet* aStyleSheet, \
nsIStyleRule* aOldStyleRule, \
- nsIStyleRule* aNewStyleRule) MOZ_OVERRIDE;
+ nsIStyleRule* aNewStyleRule);
#define NS_DECL_NSIDOCUMENTOBSERVER_STYLERULEADDED \
virtual void StyleRuleAdded(nsIDocument* aDocument, \
nsIStyleSheet* aStyleSheet, \
- nsIStyleRule* aStyleRule) MOZ_OVERRIDE;
+ nsIStyleRule* aStyleRule);
#define NS_DECL_NSIDOCUMENTOBSERVER_STYLERULEREMOVED \
virtual void StyleRuleRemoved(nsIDocument* aDocument, \
nsIStyleSheet* aStyleSheet, \
- nsIStyleRule* aStyleRule) MOZ_OVERRIDE;
+ nsIStyleRule* aStyleRule);
#define NS_DECL_NSIDOCUMENTOBSERVER \
NS_DECL_NSIDOCUMENTOBSERVER_BEGINUPDATE \
NS_DECL_NSIDOCUMENTOBSERVER_ENDUPDATE \
NS_DECL_NSIDOCUMENTOBSERVER_BEGINLOAD \
NS_DECL_NSIDOCUMENTOBSERVER_ENDLOAD \
NS_DECL_NSIDOCUMENTOBSERVER_CONTENTSTATECHANGED \
NS_DECL_NSIDOCUMENTOBSERVER_DOCUMENTSTATESCHANGED \
--- a/dom/base/nsIMutationObserver.h
+++ b/dom/base/nsIMutationObserver.h
@@ -318,61 +318,61 @@ public:
virtual void ParentChainChanged(nsIContent *aContent) = 0;
};
NS_DEFINE_STATIC_IID_ACCESSOR(nsIMutationObserver, NS_IMUTATION_OBSERVER_IID)
#define NS_DECL_NSIMUTATIONOBSERVER_CHARACTERDATAWILLCHANGE \
virtual void CharacterDataWillChange(nsIDocument* aDocument, \
nsIContent* aContent, \
- CharacterDataChangeInfo* aInfo) MOZ_OVERRIDE;
+ CharacterDataChangeInfo* aInfo);
#define NS_DECL_NSIMUTATIONOBSERVER_CHARACTERDATACHANGED \
virtual void CharacterDataChanged(nsIDocument* aDocument, \
nsIContent* aContent, \
- CharacterDataChangeInfo* aInfo) MOZ_OVERRIDE;
+ CharacterDataChangeInfo* aInfo);
#define NS_DECL_NSIMUTATIONOBSERVER_ATTRIBUTEWILLCHANGE \
virtual void AttributeWillChange(nsIDocument* aDocument, \
mozilla::dom::Element* aElement, \
int32_t aNameSpaceID, \
nsIAtom* aAttribute, \
- int32_t aModType) MOZ_OVERRIDE;
+ int32_t aModType);
#define NS_DECL_NSIMUTATIONOBSERVER_ATTRIBUTECHANGED \
virtual void AttributeChanged(nsIDocument* aDocument, \
mozilla::dom::Element* aElement, \
int32_t aNameSpaceID, \
nsIAtom* aAttribute, \
- int32_t aModType) MOZ_OVERRIDE;
+ int32_t aModType);
#define NS_DECL_NSIMUTATIONOBSERVER_CONTENTAPPENDED \
virtual void ContentAppended(nsIDocument* aDocument, \
nsIContent* aContainer, \
nsIContent* aFirstNewContent, \
- int32_t aNewIndexInContainer) MOZ_OVERRIDE;
+ int32_t aNewIndexInContainer);
#define NS_DECL_NSIMUTATIONOBSERVER_CONTENTINSERTED \
virtual void ContentInserted(nsIDocument* aDocument, \
nsIContent* aContainer, \
nsIContent* aChild, \
- int32_t aIndexInContainer) MOZ_OVERRIDE;
+ int32_t aIndexInContainer);
#define NS_DECL_NSIMUTATIONOBSERVER_CONTENTREMOVED \
virtual void ContentRemoved(nsIDocument* aDocument, \
nsIContent* aContainer, \
nsIContent* aChild, \
int32_t aIndexInContainer, \
- nsIContent* aPreviousSibling) MOZ_OVERRIDE;
+ nsIContent* aPreviousSibling);
#define NS_DECL_NSIMUTATIONOBSERVER_NODEWILLBEDESTROYED \
- virtual void NodeWillBeDestroyed(const nsINode* aNode) MOZ_OVERRIDE;
+ virtual void NodeWillBeDestroyed(const nsINode* aNode);
#define NS_DECL_NSIMUTATIONOBSERVER_PARENTCHAINCHANGED \
- virtual void ParentChainChanged(nsIContent *aContent) MOZ_OVERRIDE;
+ virtual void ParentChainChanged(nsIContent *aContent);
#define NS_DECL_NSIMUTATIONOBSERVER \
NS_DECL_NSIMUTATIONOBSERVER_CHARACTERDATAWILLCHANGE \
NS_DECL_NSIMUTATIONOBSERVER_CHARACTERDATACHANGED \
NS_DECL_NSIMUTATIONOBSERVER_ATTRIBUTEWILLCHANGE \
NS_DECL_NSIMUTATIONOBSERVER_ATTRIBUTECHANGED \
NS_DECL_NSIMUTATIONOBSERVER_CONTENTAPPENDED \
NS_DECL_NSIMUTATIONOBSERVER_CONTENTINSERTED \
--- a/dom/base/nsINode.h
+++ b/dom/base/nsINode.h
@@ -234,17 +234,17 @@ private:
};
// This should be used for any nsINode sub-class that has fields of its own
// that it needs to measure; any sub-class that doesn't use it will inherit
// SizeOfExcludingThis from its super-class. SizeOfIncludingThis() need not be
// defined, it is inherited from nsINode.
// This macro isn't actually specific to nodes, and bug 956400 will move it into MFBT.
#define NS_DECL_SIZEOF_EXCLUDING_THIS \
- virtual size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const MOZ_OVERRIDE;
+ virtual size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
// Categories of node properties
// 0 is global.
#define DOM_USER_DATA 1
#define SMIL_MAPPED_ATTR_ANIMVAL 2
// IID for the nsINode interface
#define NS_INODE_IID \
@@ -288,17 +288,17 @@ public:
// - nsHTMLSelectElement: mOptions, mRestoreState
// - nsHTMLTableElement: mTBodies, mRows, mTableInheritedAttributes
// - nsHTMLTableSectionElement: mRows
// - nsHTMLTextAreaElement: mControllers, mState
//
// The following members don't need to be measured:
// - nsIContent: mPrimaryFrame, because it's non-owning and measured elsewhere
//
- virtual size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
+ NS_DECL_SIZEOF_EXCLUDING_THIS
// SizeOfIncludingThis doesn't need to be overridden by sub-classes because
// sub-classes of nsINode are guaranteed to be laid out in memory in such a
// way that |this| points to the start of the allocated object, even in
// methods of nsINode's sub-classes, and so |aMallocSizeOf(this)| is always
// safe to call no matter which object it was invoked on.
virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {
return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
@@ -1872,177 +1872,177 @@ ToSupports(nsINode* aPointer)
inline nsISupports*
ToCanonicalSupports(nsINode* aPointer)
{
return aPointer;
}
#define NS_FORWARD_NSIDOMNODE_TO_NSINODE_HELPER(...) \
- NS_IMETHOD GetNodeName(nsAString& aNodeName) __VA_ARGS__ MOZ_OVERRIDE \
+ NS_IMETHOD GetNodeName(nsAString& aNodeName) __VA_ARGS__ \
{ \
aNodeName = nsINode::NodeName(); \
return NS_OK; \
} \
- NS_IMETHOD GetNodeValue(nsAString& aNodeValue) __VA_ARGS__ MOZ_OVERRIDE \
+ NS_IMETHOD GetNodeValue(nsAString& aNodeValue) __VA_ARGS__ \
{ \
nsINode::GetNodeValue(aNodeValue); \
return NS_OK; \
} \
- NS_IMETHOD SetNodeValue(const nsAString& aNodeValue) __VA_ARGS__ MOZ_OVERRIDE \
+ NS_IMETHOD SetNodeValue(const nsAString& aNodeValue) __VA_ARGS__ \
{ \
mozilla::ErrorResult rv; \
nsINode::SetNodeValue(aNodeValue, rv); \
return rv.ErrorCode(); \
} \
- NS_IMETHOD GetNodeType(uint16_t* aNodeType) __VA_ARGS__ MOZ_OVERRIDE \
+ NS_IMETHOD GetNodeType(uint16_t* aNodeType) __VA_ARGS__ \
{ \
*aNodeType = nsINode::NodeType(); \
return NS_OK; \
} \
- NS_IMETHOD GetParentNode(nsIDOMNode** aParentNode) __VA_ARGS__ MOZ_OVERRIDE \
+ NS_IMETHOD GetParentNode(nsIDOMNode** aParentNode) __VA_ARGS__ \
{ \
return nsINode::GetParentNode(aParentNode); \
} \
- NS_IMETHOD GetParentElement(nsIDOMElement** aParentElement) __VA_ARGS__ MOZ_OVERRIDE \
+ NS_IMETHOD GetParentElement(nsIDOMElement** aParentElement) __VA_ARGS__ \
{ \
return nsINode::GetParentElement(aParentElement); \
} \
- NS_IMETHOD GetChildNodes(nsIDOMNodeList** aChildNodes) __VA_ARGS__ MOZ_OVERRIDE \
+ NS_IMETHOD GetChildNodes(nsIDOMNodeList** aChildNodes) __VA_ARGS__ \
{ \
return nsINode::GetChildNodes(aChildNodes); \
} \
- NS_IMETHOD GetFirstChild(nsIDOMNode** aFirstChild) __VA_ARGS__ MOZ_OVERRIDE \
+ NS_IMETHOD GetFirstChild(nsIDOMNode** aFirstChild) __VA_ARGS__ \
{ \
return nsINode::GetFirstChild(aFirstChild); \
} \
- NS_IMETHOD GetLastChild(nsIDOMNode** aLastChild) __VA_ARGS__ MOZ_OVERRIDE \
+ NS_IMETHOD GetLastChild(nsIDOMNode** aLastChild) __VA_ARGS__ \
{ \
return nsINode::GetLastChild(aLastChild); \
} \
- NS_IMETHOD GetPreviousSibling(nsIDOMNode** aPreviousSibling) __VA_ARGS__ MOZ_OVERRIDE \
+ NS_IMETHOD GetPreviousSibling(nsIDOMNode** aPreviousSibling) __VA_ARGS__ \
{ \
return nsINode::GetPreviousSibling(aPreviousSibling); \
} \
- NS_IMETHOD GetNextSibling(nsIDOMNode** aNextSibling) __VA_ARGS__ MOZ_OVERRIDE \
+ NS_IMETHOD GetNextSibling(nsIDOMNode** aNextSibling) __VA_ARGS__ \
{ \
return nsINode::GetNextSibling(aNextSibling); \
} \
- NS_IMETHOD GetOwnerDocument(nsIDOMDocument** aOwnerDocument) __VA_ARGS__ MOZ_OVERRIDE \
+ NS_IMETHOD GetOwnerDocument(nsIDOMDocument** aOwnerDocument) __VA_ARGS__ \
{ \
return nsINode::GetOwnerDocument(aOwnerDocument); \
} \
- NS_IMETHOD InsertBefore(nsIDOMNode* aNewChild, nsIDOMNode* aRefChild, nsIDOMNode** aResult) __VA_ARGS__ MOZ_OVERRIDE \
+ NS_IMETHOD InsertBefore(nsIDOMNode* aNewChild, nsIDOMNode* aRefChild, nsIDOMNode** aResult) __VA_ARGS__ \
{ \
return ReplaceOrInsertBefore(false, aNewChild, aRefChild, aResult); \
} \
- NS_IMETHOD ReplaceChild(nsIDOMNode* aNewChild, nsIDOMNode* aOldChild, nsIDOMNode** aResult) __VA_ARGS__ MOZ_OVERRIDE \
+ NS_IMETHOD ReplaceChild(nsIDOMNode* aNewChild, nsIDOMNode* aOldChild, nsIDOMNode** aResult) __VA_ARGS__ \
{ \
return ReplaceOrInsertBefore(true, aNewChild, aOldChild, aResult); \
} \
- NS_IMETHOD RemoveChild(nsIDOMNode* aOldChild, nsIDOMNode** aResult) __VA_ARGS__ MOZ_OVERRIDE \
+ NS_IMETHOD RemoveChild(nsIDOMNode* aOldChild, nsIDOMNode** aResult) __VA_ARGS__ \
{ \
return nsINode::RemoveChild(aOldChild, aResult); \
} \
- NS_IMETHOD AppendChild(nsIDOMNode* aNewChild, nsIDOMNode** aResult) __VA_ARGS__ MOZ_OVERRIDE \
+ NS_IMETHOD AppendChild(nsIDOMNode* aNewChild, nsIDOMNode** aResult) __VA_ARGS__ \
{ \
return InsertBefore(aNewChild, nullptr, aResult); \
} \
- NS_IMETHOD HasChildNodes(bool* aResult) __VA_ARGS__ MOZ_OVERRIDE \
+ NS_IMETHOD HasChildNodes(bool* aResult) __VA_ARGS__ \
{ \
*aResult = nsINode::HasChildNodes(); \
return NS_OK; \
} \
- NS_IMETHOD CloneNode(bool aDeep, uint8_t aArgc, nsIDOMNode** aResult) __VA_ARGS__ MOZ_OVERRIDE \
+ NS_IMETHOD CloneNode(bool aDeep, uint8_t aArgc, nsIDOMNode** aResult) __VA_ARGS__ \
{ \
if (aArgc == 0) { \
aDeep = true; \
} \
mozilla::ErrorResult rv; \
nsCOMPtr<nsINode> clone = nsINode::CloneNode(aDeep, rv); \
if (rv.Failed()) { \
return rv.ErrorCode(); \
} \
*aResult = clone.forget().take()->AsDOMNode(); \
return NS_OK; \
} \
- NS_IMETHOD Normalize() __VA_ARGS__ MOZ_OVERRIDE \
+ NS_IMETHOD Normalize() __VA_ARGS__ \
{ \
nsINode::Normalize(); \
return NS_OK; \
} \
- NS_IMETHOD GetNamespaceURI(nsAString& aNamespaceURI) __VA_ARGS__ MOZ_OVERRIDE \
+ NS_IMETHOD GetNamespaceURI(nsAString& aNamespaceURI) __VA_ARGS__ \
{ \
nsINode::GetNamespaceURI(aNamespaceURI); \
return NS_OK; \
} \
- NS_IMETHOD GetPrefix(nsAString& aPrefix) __VA_ARGS__ MOZ_OVERRIDE \
+ NS_IMETHOD GetPrefix(nsAString& aPrefix) __VA_ARGS__ \
{ \
nsINode::GetPrefix(aPrefix); \
return NS_OK; \
} \
- NS_IMETHOD GetLocalName(nsAString& aLocalName) __VA_ARGS__ MOZ_OVERRIDE \
+ NS_IMETHOD GetLocalName(nsAString& aLocalName) __VA_ARGS__ \
{ \
aLocalName = nsINode::LocalName(); \
return NS_OK; \
} \
- NS_IMETHOD UnusedPlaceholder(bool* aResult) __VA_ARGS__ MOZ_OVERRIDE \
+ NS_IMETHOD UnusedPlaceholder(bool* aResult) __VA_ARGS__ \
{ \
*aResult = false; \
return NS_OK; \
} \
- NS_IMETHOD GetDOMBaseURI(nsAString& aBaseURI) __VA_ARGS__ MOZ_OVERRIDE \
+ NS_IMETHOD GetDOMBaseURI(nsAString& aBaseURI) __VA_ARGS__ \
{ \
nsINode::GetBaseURI(aBaseURI); \
return NS_OK; \
} \
- NS_IMETHOD CompareDocumentPosition(nsIDOMNode* aOther, uint16_t* aResult) __VA_ARGS__ MOZ_OVERRIDE \
+ NS_IMETHOD CompareDocumentPosition(nsIDOMNode* aOther, uint16_t* aResult) __VA_ARGS__ \
{ \
return nsINode::CompareDocumentPosition(aOther, aResult); \
} \
- NS_IMETHOD GetTextContent(nsAString& aTextContent) __VA_ARGS__ MOZ_OVERRIDE \
+ NS_IMETHOD GetTextContent(nsAString& aTextContent) __VA_ARGS__ \
{ \
mozilla::ErrorResult rv; \
nsINode::GetTextContent(aTextContent, rv); \
return rv.ErrorCode(); \
} \
- NS_IMETHOD SetTextContent(const nsAString& aTextContent) __VA_ARGS__ MOZ_OVERRIDE \
+ NS_IMETHOD SetTextContent(const nsAString& aTextContent) __VA_ARGS__ \
{ \
mozilla::ErrorResult rv; \
nsINode::SetTextContent(aTextContent, rv); \
return rv.ErrorCode(); \
} \
- NS_IMETHOD LookupPrefix(const nsAString& aNamespaceURI, nsAString& aResult) __VA_ARGS__ MOZ_OVERRIDE \
+ NS_IMETHOD LookupPrefix(const nsAString& aNamespaceURI, nsAString& aResult) __VA_ARGS__ \
{ \
nsINode::LookupPrefix(aNamespaceURI, aResult); \
return NS_OK; \
} \
- NS_IMETHOD IsDefaultNamespace(const nsAString& aNamespaceURI, bool* aResult) __VA_ARGS__ MOZ_OVERRIDE \
+ NS_IMETHOD IsDefaultNamespace(const nsAString& aNamespaceURI, bool* aResult) __VA_ARGS__ \
{ \
*aResult = nsINode::IsDefaultNamespace(aNamespaceURI); \
return NS_OK; \
} \
- NS_IMETHOD LookupNamespaceURI(const nsAString& aPrefix, nsAString& aResult) __VA_ARGS__ MOZ_OVERRIDE \
+ NS_IMETHOD LookupNamespaceURI(const nsAString& aPrefix, nsAString& aResult) __VA_ARGS__ \
{ \
nsINode::LookupNamespaceURI(aPrefix, aResult); \
return NS_OK; \
} \
- NS_IMETHOD IsEqualNode(nsIDOMNode* aArg, bool* aResult) __VA_ARGS__ MOZ_OVERRIDE \
+ NS_IMETHOD IsEqualNode(nsIDOMNode* aArg, bool* aResult) __VA_ARGS__ \
{ \
return nsINode::IsEqualNode(aArg, aResult); \
} \
- NS_IMETHOD SetUserData(const nsAString& aKey, nsIVariant* aData, nsIVariant** aResult) __VA_ARGS__ MOZ_OVERRIDE \
+ NS_IMETHOD SetUserData(const nsAString& aKey, nsIVariant* aData, nsIVariant** aResult) __VA_ARGS__ \
{ \
return nsINode::SetUserData(aKey, aData, aResult); \
} \
- NS_IMETHOD GetUserData(const nsAString& aKey, nsIVariant** aResult) __VA_ARGS__ MOZ_OVERRIDE \
+ NS_IMETHOD GetUserData(const nsAString& aKey, nsIVariant** aResult) __VA_ARGS__ \
{ \
return nsINode::GetUserData(aKey, aResult); \
} \
- NS_IMETHOD Contains(nsIDOMNode* aOther, bool* aResult) __VA_ARGS__ MOZ_OVERRIDE \
+ NS_IMETHOD Contains(nsIDOMNode* aOther, bool* aResult) __VA_ARGS__ \
{ \
return nsINode::Contains(aOther, aResult); \
}
#define NS_FORWARD_NSIDOMNODE_TO_NSINODE \
NS_FORWARD_NSIDOMNODE_TO_NSINODE_HELPER(MOZ_FINAL)
#define NS_FORWARD_NSIDOMNODE_TO_NSINODE_OVERRIDABLE \
--- a/dom/base/nsInProcessTabChildGlobal.h
+++ b/dom/base/nsInProcessTabChildGlobal.h
@@ -45,30 +45,30 @@ public:
NS_FORWARD_SAFE_NSIMESSAGELISTENERMANAGER(mMessageManager)
NS_FORWARD_SAFE_NSIMESSAGESENDER(mMessageManager)
NS_IMETHOD SendSyncMessage(const nsAString& aMessageName,
JS::Handle<JS::Value> aObject,
JS::Handle<JS::Value> aRemote,
nsIPrincipal* aPrincipal,
JSContext* aCx,
uint8_t aArgc,
- JS::MutableHandle<JS::Value> aRetval) MOZ_OVERRIDE
+ JS::MutableHandle<JS::Value> aRetval)
{
return mMessageManager
? mMessageManager->SendSyncMessage(aMessageName, aObject, aRemote,
aPrincipal, aCx, aArgc, aRetval)
: NS_ERROR_NULL_POINTER;
}
NS_IMETHOD SendRpcMessage(const nsAString& aMessageName,
JS::Handle<JS::Value> aObject,
JS::Handle<JS::Value> aRemote,
nsIPrincipal* aPrincipal,
JSContext* aCx,
uint8_t aArgc,
- JS::MutableHandle<JS::Value> aRetval) MOZ_OVERRIDE
+ JS::MutableHandle<JS::Value> aRetval)
{
return mMessageManager
? mMessageManager->SendRpcMessage(aMessageName, aObject, aRemote,
aPrincipal, aCx, aArgc, aRetval)
: NS_ERROR_NULL_POINTER;
}
NS_IMETHOD GetContent(nsIDOMWindow** aContent) MOZ_OVERRIDE;
NS_IMETHOD GetDocShell(nsIDocShell** aDocShell) MOZ_OVERRIDE;
--- a/dom/base/nsJSEnvironment.cpp
+++ b/dom/base/nsJSEnvironment.cpp
@@ -2937,17 +2937,17 @@ public:
NS_DECL_CYCLE_COLLECTING_ISUPPORTS
NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_AMBIGUOUS(nsJSArgArray,
nsIJSArgArray)
// nsIArray
NS_DECL_NSIARRAY
// nsIJSArgArray
- nsresult GetArgs(uint32_t* argc, void** argv) MOZ_OVERRIDE;
+ nsresult GetArgs(uint32_t *argc, void **argv);
void ReleaseJSObjects();
protected:
~nsJSArgArray();
JSContext *mContext;
JS::Heap<JS::Value> *mArgv;
uint32_t mArgc;
--- a/dom/base/nsJSTimeoutHandler.cpp
+++ b/dom/base/nsJSTimeoutHandler.cpp
@@ -37,28 +37,28 @@ public:
// This will call SwapElements on aArguments with an empty array.
nsJSScriptTimeoutHandler(nsGlobalWindow *aWindow, Function& aFunction,
FallibleTArray<JS::Heap<JS::Value> >& aArguments,
ErrorResult& aError);
nsJSScriptTimeoutHandler(JSContext* aCx, nsGlobalWindow *aWindow,
const nsAString& aExpression, bool* aAllowEval,
ErrorResult& aError);
- virtual const char16_t* GetHandlerText() MOZ_OVERRIDE;
- virtual Function* GetCallback() MOZ_OVERRIDE
+ virtual const char16_t *GetHandlerText();
+ virtual Function* GetCallback()
{
return mFunction;
}
- virtual void GetLocation(const char** aFileName, uint32_t* aLineNo) MOZ_OVERRIDE
+ virtual void GetLocation(const char **aFileName, uint32_t *aLineNo)
{
*aFileName = mFileName.get();
*aLineNo = mLineNo;
}
- virtual const nsTArray<JS::Value>& GetArgs() MOZ_OVERRIDE
+ virtual const nsTArray<JS::Value>& GetArgs()
{
return mArgs;
}
nsresult Init(nsGlobalWindow *aWindow, bool *aIsInterval,
int32_t *aInterval, bool* aAllowEval);
void ReleaseJSObjects();
--- a/dom/base/nsObjectLoadingContent.cpp
+++ b/dom/base/nsObjectLoadingContent.cpp
@@ -356,20 +356,20 @@ public:
: mInstanceOwner(aInstanceOwner)
, mContent(aContent)
{
NS_ASSERTION(aInstanceOwner, "need an owner");
NS_ASSERTION(aContent, "need a nsObjectLoadingContent");
}
// nsRunnable
- NS_IMETHOD Run() MOZ_OVERRIDE;
+ NS_IMETHOD Run();
// nsITimerCallback
- NS_IMETHOD Notify(nsITimer* timer) MOZ_OVERRIDE;
+ NS_IMETHOD Notify(nsITimer *timer);
protected:
virtual ~nsStopPluginRunnable() {}
private:
nsCOMPtr<nsITimer> mTimer;
nsRefPtr<nsPluginInstanceOwner> mInstanceOwner;
nsCOMPtr<nsIObjectLoadingContent> mContent;
--- a/dom/base/nsReferencedElement.h
+++ b/dom/base/nsReferencedElement.h
@@ -136,18 +136,18 @@ private:
NS_DECL_ISUPPORTS_INHERITED
NS_IMETHOD Run() MOZ_OVERRIDE {
if (mTarget) {
mTarget->mPendingNotification = nullptr;
mTarget->ElementChanged(mFrom, mTo);
}
return NS_OK;
}
- virtual void SetTo(Element* aTo) MOZ_OVERRIDE { mTo = aTo; }
- virtual void Clear() MOZ_OVERRIDE
+ virtual void SetTo(Element* aTo) { mTo = aTo; }
+ virtual void Clear()
{
Notification::Clear(); mFrom = nullptr; mTo = nullptr;
}
protected:
virtual ~ChangeNotification() {}
nsRefPtr<Element> mFrom;
nsRefPtr<Element> mTo;
@@ -167,17 +167,17 @@ private:
}
}
NS_DECL_ISUPPORTS
NS_DECL_NSIOBSERVER
private:
virtual ~DocumentLoadNotification() {}
- virtual void SetTo(Element* aTo) MOZ_OVERRIDE { }
+ virtual void SetTo(Element* aTo) { }
nsString mRef;
};
friend class DocumentLoadNotification;
nsCOMPtr<nsIAtom> mWatchID;
nsCOMPtr<nsIDocument> mWatchDocument;
nsRefPtr<Element> mElement;
--- a/dom/base/nsScreen.h
+++ b/dom/base/nsScreen.h
@@ -119,17 +119,17 @@ public:
IMPL_EVENT_HANDLER(mozorientationchange)
bool MozLockOrientation(const nsAString& aOrientation, ErrorResult& aRv);
bool MozLockOrientation(const mozilla::dom::Sequence<nsString>& aOrientations, ErrorResult& aRv);
void MozUnlockOrientation();
virtual JSObject* WrapObject(JSContext* aCx) MOZ_OVERRIDE;
- void Notify(const mozilla::hal::ScreenConfiguration& aConfiguration) MOZ_OVERRIDE;
+ void Notify(const mozilla::hal::ScreenConfiguration& aConfiguration);
protected:
nsDeviceContext* GetDeviceContext();
nsresult GetRect(nsRect& aRect);
nsresult GetAvailRect(nsRect& aRect);
mozilla::dom::ScreenOrientation mOrientation;
--- a/dom/base/nsStyledElement.h
+++ b/dom/base/nsStyledElement.h
@@ -31,17 +31,17 @@ class nsStyledElementNotElementCSSInline
protected:
inline explicit nsStyledElementNotElementCSSInlineStyle(already_AddRefed<mozilla::dom::NodeInfo>& aNodeInfo)
: nsStyledElementBase(aNodeInfo)
{}
public:
// nsIContent interface methods
- virtual mozilla::css::StyleRule* GetInlineStyleRule() MOZ_OVERRIDE;
+ virtual mozilla::css::StyleRule* GetInlineStyleRule();
virtual nsresult SetInlineStyleRule(mozilla::css::StyleRule* aStyleRule,
const nsAString* aSerialized,
bool aNotify) MOZ_OVERRIDE;
nsICSSDeclaration* Style();
protected:
--- a/dom/base/nsTextNode.cpp
+++ b/dom/base/nsTextNode.cpp
@@ -42,25 +42,25 @@ public:
mAttrName(aAttrName)
{
NS_ASSERTION(mNameSpaceID != kNameSpaceID_Unknown, "Must know namespace");
NS_ASSERTION(mAttrName, "Must have attr name");
}
virtual nsresult BindToTree(nsIDocument* aDocument, nsIContent* aParent,
nsIContent* aBindingParent,
- bool aCompileEventHandlers) MOZ_OVERRIDE;
+ bool aCompileEventHandlers);
virtual void UnbindFromTree(bool aDeep = true,
- bool aNullParent = true) MOZ_OVERRIDE;
+ bool aNullParent = true);
NS_DECL_NSIMUTATIONOBSERVER_ATTRIBUTECHANGED
NS_DECL_NSIMUTATIONOBSERVER_NODEWILLBEDESTROYED
virtual nsGenericDOMDataNode *CloneDataNode(mozilla::dom::NodeInfo *aNodeInfo,
- bool aCloneText) const MOZ_OVERRIDE
+ bool aCloneText) const
{
already_AddRefed<mozilla::dom::NodeInfo> ni =
nsRefPtr<mozilla::dom::NodeInfo>(aNodeInfo).forget();
nsAttributeTextNode *it = new nsAttributeTextNode(ni,
mNameSpaceID,
mAttrName);
if (it && aCloneText) {
it->mText = mText;
--- a/dom/base/nsTextNode.h
+++ b/dom/base/nsTextNode.h
@@ -52,17 +52,17 @@ public:
// nsIDOMCharacterData
NS_FORWARD_NSIDOMCHARACTERDATA(nsGenericDOMDataNode::)
using nsGenericDOMDataNode::SetData; // Prevent hiding overloaded virtual function.
// nsIDOMText
NS_FORWARD_NSIDOMTEXT(nsGenericDOMDataNode::)
// nsINode
- virtual bool IsNodeOfType(uint32_t aFlags) const MOZ_OVERRIDE;
+ virtual bool IsNodeOfType(uint32_t aFlags) const;
virtual nsGenericDOMDataNode* CloneDataNode(mozilla::dom::NodeInfo *aNodeInfo,
bool aCloneText) const MOZ_OVERRIDE;
virtual nsresult BindToTree(nsIDocument* aDocument, nsIContent* aParent,
nsIContent* aBindingParent,
bool aCompileEventHandlers) MOZ_OVERRIDE;
virtual void UnbindFromTree(bool aDeep = true,
--- a/dom/base/nsWindowMemoryReporter.h
+++ b/dom/base/nsWindowMemoryReporter.h
@@ -170,17 +170,17 @@ private:
~GhostWindowsReporter() {}
public:
NS_DECL_ISUPPORTS
static int64_t DistinguishedAmount();
NS_IMETHOD
CollectReports(nsIHandleReportCallback* aHandleReport, nsISupports* aData,
- bool aAnonymize) MOZ_OVERRIDE
+ bool aAnonymize)
{
return MOZ_COLLECT_REPORT(
"ghost-windows", KIND_OTHER, UNITS_COUNT, DistinguishedAmount(),
"The number of ghost windows present (the number of nodes underneath "
"explicit/window-objects/top(none)/ghost, modulo race conditions). A ghost "
"window is not shown in any tab, does not share a domain with any non-detached "
"windows, and has met these criteria for at least "
"memory.ghost_window_timeout_seconds, or has survived a round of "
--- a/dom/base/nsXMLHttpRequest.cpp
+++ b/dom/base/nsXMLHttpRequest.cpp
@@ -3421,17 +3421,17 @@ public:
: mXHR(xhr)
{
}
NS_DECL_CYCLE_COLLECTING_ISUPPORTS
NS_DECL_CYCLE_COLLECTION_CLASS(AsyncVerifyRedirectCallbackForwarder)
// nsIAsyncVerifyRedirectCallback implementation
- NS_IMETHOD OnRedirectVerifyCallback(nsresult result) MOZ_OVERRIDE
+ NS_IMETHOD OnRedirectVerifyCallback(nsresult result)
{
mXHR->OnRedirectVerifyCallback(result);
return NS_OK;
}
private:
~AsyncVerifyRedirectCallbackForwarder() {}
--- a/dom/base/nsXMLHttpRequest.h
+++ b/dom/base/nsXMLHttpRequest.h
@@ -138,17 +138,17 @@ public:
IMPL_EVENT_HANDLER(loadstart)
IMPL_EVENT_HANDLER(progress)
IMPL_EVENT_HANDLER(abort)
IMPL_EVENT_HANDLER(error)
IMPL_EVENT_HANDLER(load)
IMPL_EVENT_HANDLER(timeout)
IMPL_EVENT_HANDLER(loadend)
- virtual void DisconnectFromOwner() MOZ_OVERRIDE;
+ virtual void DisconnectFromOwner();
};
class nsXMLHttpRequestUpload MOZ_FINAL : public nsXHREventTarget,
public nsIXMLHttpRequestUpload
{
public:
explicit nsXMLHttpRequestUpload(mozilla::DOMEventTargetHelper* aOwner)
: nsXHREventTarget(aOwner)
@@ -284,17 +284,17 @@ public:
// nsIInterfaceRequestor
NS_DECL_NSIINTERFACEREQUESTOR
// nsITimerCallback
NS_DECL_NSITIMERCALLBACK
// nsISizeOfEventTarget
virtual size_t
- SizeOfEventTargetIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const MOZ_OVERRIDE;
+ SizeOfEventTargetIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
NS_REALLY_FORWARD_NSIDOMEVENTTARGET(nsXHREventTarget)
#ifdef DEBUG
void StaticAssertions();
#endif
// event handler