--- a/accessible/generic/ARIAGridAccessible.cpp
+++ b/accessible/generic/ARIAGridAccessible.cpp
@@ -29,17 +29,17 @@ using namespace mozilla::a11y;
 ARIAGridAccessible::
   ARIAGridAccessible(nsIContent* aContent, DocAccessible* aDoc) :
   AccessibleWrap(aContent, aDoc)
 {
   mGenericTypes |= eTable;
 }
 
 role
-ARIAGridAccessible::NativeRole()
+ARIAGridAccessible::NativeRole() const
 {
   a11y::role r = GetAccService()->MarkupRole(mContent);
   return r != roles::NOTHING ? r : roles::TABLE;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Table
 
@@ -545,17 +545,17 @@ ARIAGridAccessible::SetARIASelected(Acce
 ARIARowAccessible::
   ARIARowAccessible(nsIContent* aContent, DocAccessible* aDoc) :
   AccessibleWrap(aContent, aDoc)
 {
   mGenericTypes |= eTableRow;
 }
 
 role
-ARIARowAccessible::NativeRole()
+ARIARowAccessible::NativeRole() const
 {
   a11y::role r = GetAccService()->MarkupRole(mContent);
   return r != roles::NOTHING ? r : roles::ROW;
 }
 
 GroupPos
 ARIARowAccessible::GroupPosition()
 {
@@ -582,17 +582,17 @@ ARIARowAccessible::GroupPosition()
 ARIAGridCellAccessible::
   ARIAGridCellAccessible(nsIContent* aContent, DocAccessible* aDoc) :
   HyperTextAccessibleWrap(aContent, aDoc)
 {
   mGenericTypes |= eTableCell;
 }
 
 role
-ARIAGridCellAccessible::NativeRole()
+ARIAGridCellAccessible::NativeRole() const
 {
   a11y::role r = GetAccService()->MarkupRole(mContent);
   return r != roles::NOTHING ? r : roles::CELL;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // TableCell
 

--- a/accessible/generic/ARIAGridAccessible.h
+++ b/accessible/generic/ARIAGridAccessible.h
@@ -20,17 +20,17 @@ class ARIAGridAccessible : public Access
                            public TableAccessible
 {
 public:
   ARIAGridAccessible(nsIContent* aContent, DocAccessible* aDoc);
 
   NS_INLINE_DECL_REFCOUNTING_INHERITED(ARIAGridAccessible, AccessibleWrap)
 
   // Accessible
-  virtual a11y::role NativeRole() override;
+  virtual a11y::role NativeRole() const override;
   virtual TableAccessible* AsTable() override { return this; }
 
   // TableAccessible
   virtual uint32_t ColCount() const override;
   virtual uint32_t RowCount() override;
   virtual Accessible* CellAt(uint32_t aRowIndex, uint32_t aColumnIndex) override;
   virtual bool IsColSelected(uint32_t aColIdx) override;
   virtual bool IsRowSelected(uint32_t aRowIdx) override;
@@ -80,17 +80,17 @@ protected:
 class ARIARowAccessible : public AccessibleWrap
 {
 public:
   ARIARowAccessible(nsIContent* aContent, DocAccessible* aDoc);
 
   NS_INLINE_DECL_REFCOUNTING_INHERITED(ARIARowAccessible, AccessibleWrap)
 
   // Accessible
-  virtual a11y::role NativeRole() override;
+  virtual a11y::role NativeRole() const override;
   virtual mozilla::a11y::GroupPos GroupPosition() override;
 
 protected:
   virtual ~ARIARowAccessible() {}
 };
 
 
 /**
@@ -101,17 +101,17 @@ class ARIAGridCellAccessible : public Hy
 {
 public:
   ARIAGridCellAccessible(nsIContent* aContent, DocAccessible* aDoc);
 
   NS_INLINE_DECL_REFCOUNTING_INHERITED(ARIAGridCellAccessible,
                                        HyperTextAccessibleWrap)
 
   // Accessible
-  virtual a11y::role NativeRole() override;
+  virtual a11y::role NativeRole() const override;
   virtual TableCellAccessible* AsTableCell() override { return this; }
   virtual void ApplyARIAState(uint64_t* aState) const override;
   virtual already_AddRefed<nsIPersistentProperties> NativeAttributes() override;
   virtual mozilla::a11y::GroupPos GroupPosition() override;
 
 protected:
   virtual ~ARIAGridCellAccessible() {}
 

--- a/accessible/generic/Accessible.cpp
+++ b/accessible/generic/Accessible.cpp
@@ -316,17 +316,17 @@ Accessible::TranslateString(const nsStri
   nsAutoString xsValue;
   nsresult rv =
     stringBundle->GetStringFromName(NS_ConvertUTF16toUTF8(aKey).get(), xsValue);
   if (NS_SUCCEEDED(rv))
     aStringOut.Assign(xsValue);
 }
 
 uint64_t
-Accessible::VisibilityState()
+Accessible::VisibilityState() const
 {
   nsIFrame* frame = GetFrame();
   if (!frame)
     return states::INVISIBLE;
 
   // Walk the parent frame chain to see if there's invisible parent or the frame
   // is in background tab.
   if (!frame->StyleVisibility()->IsVisible())
@@ -1509,17 +1509,17 @@ nsAtom*
 Accessible::LandmarkRole() const
 {
   const nsRoleMapEntry* roleMapEntry = ARIARoleMap();
   return roleMapEntry && roleMapEntry->IsOfType(eLandmark) ?
     *(roleMapEntry->roleAtom) : nullptr;
 }
 
 role
-Accessible::NativeRole()
+Accessible::NativeRole() const
 {
   return roles::NOTHING;
 }
 
 uint8_t
 Accessible::ActionCount()
 {
   return GetActionRule() == eNoAction ? 0 : 1;

--- a/accessible/generic/Accessible.h
+++ b/accessible/generic/Accessible.h
@@ -246,17 +246,17 @@ public:
    * Return a landmark role if applied.
    */
   virtual nsAtom* LandmarkRole() const;
 
   /**
    * Returns enumerated accessible role from native markup (see constants in
    * Role.h). Doesn't take into account ARIA roles.
    */
-  virtual mozilla::a11y::role NativeRole();
+  virtual mozilla::a11y::role NativeRole() const;
 
   /**
    * Return all states of accessible (including ARIA states).
    */
   virtual uint64_t State();
 
   /**
    * Return interactive states present on the accessible
@@ -303,17 +303,17 @@ public:
   /**
    * Return native link states present on the accessible.
    */
   virtual uint64_t NativeLinkState() const;
 
   /**
    * Return bit set of invisible and offscreen states.
    */
-  uint64_t VisibilityState();
+  uint64_t VisibilityState() const;
 
   /**
    * Return true if native unavailable state present.
    */
   virtual bool NativelyUnavailable() const;
 
   /**
    * Return object attributes for the accessible.

--- a/accessible/generic/ApplicationAccessible.cpp
+++ b/accessible/generic/ApplicationAccessible.cpp
@@ -137,17 +137,17 @@ ApplicationAccessible::Shutdown()
 }
 
 void
 ApplicationAccessible::ApplyARIAState(uint64_t* aState) const
 {
 }
 
 role
-ApplicationAccessible::NativeRole()
+ApplicationAccessible::NativeRole() const
 {
   return roles::APP_ROOT;
 }
 
 uint64_t
 ApplicationAccessible::NativeState()
 {
   return 0;

--- a/accessible/generic/ApplicationAccessible.h
+++ b/accessible/generic/ApplicationAccessible.h
@@ -39,17 +39,17 @@ public:
   virtual nsIntRect Bounds() const override;
   virtual nsRect BoundsInAppUnits() const override;
   virtual already_AddRefed<nsIPersistentProperties> NativeAttributes() override;
   virtual GroupPos GroupPosition() override;
   virtual ENameValueFlag Name(nsString& aName) override;
   virtual void ApplyARIAState(uint64_t* aState) const override;
   virtual void Description(nsString& aDescription) override;
   virtual void Value(nsString& aValue) override;
-  virtual mozilla::a11y::role NativeRole() override;
+  virtual mozilla::a11y::role NativeRole() const override;
   virtual uint64_t State() override;
   virtual uint64_t NativeState() override;
   virtual Relation RelationByType(RelationType aType) override;
 
   virtual Accessible* ChildAtPoint(int32_t aX, int32_t aY,
                                    EWhichChildAtPoint aWhichChild) override;
   virtual Accessible* FocusedChild() override;
 

--- a/accessible/generic/BaseAccessibles.h
+++ b/accessible/generic/BaseAccessibles.h
@@ -94,17 +94,17 @@ class EnumRoleAccessible : public Access
 public:
   EnumRoleAccessible(nsIContent* aContent, DocAccessible* aDoc) :
     AccessibleWrap(aContent, aDoc) { }
 
   NS_IMETHOD QueryInterface(REFNSIID aIID, void** aPtr) override
     { return Accessible::QueryInterface(aIID, aPtr); }
 
   // Accessible
-  virtual a11y::role NativeRole() override { return R; }
+  virtual a11y::role NativeRole() const override { return R; }
 
 protected:
   virtual ~EnumRoleAccessible() { }
 };
 
 
 /**
  * A wrapper accessible around native accessible to connect it with

--- a/accessible/generic/DocAccessible.cpp
+++ b/accessible/generic/DocAccessible.cpp
@@ -188,17 +188,17 @@ DocAccessible::Name(nsString& aName)
     URL(aName);
   }
 
   return eNameOK;
 }
 
 // Accessible public method
 role
-DocAccessible::NativeRole()
+DocAccessible::NativeRole() const
 {
   nsCOMPtr<nsIDocShell> docShell = nsCoreUtils::GetDocShellFor(mDocumentNode);
   if (docShell) {
     nsCOMPtr<nsIDocShellTreeItem> sameTypeRoot;
     docShell->GetSameTypeRootTreeItem(getter_AddRefs(sameTypeRoot));
     int32_t itemType = docShell->ItemType();
     if (sameTypeRoot == docShell) {
       // Root of content or chrome tree

--- a/accessible/generic/DocAccessible.h
+++ b/accessible/generic/DocAccessible.h
@@ -67,17 +67,17 @@ public:
   virtual void Shutdown() override;
   virtual nsIFrame* GetFrame() const override;
   virtual nsINode* GetNode() const override { return mDocumentNode; }
   nsIDocument* DocumentNode() const { return mDocumentNode; }
 
   virtual mozilla::a11y::ENameValueFlag Name(nsString& aName) override;
   virtual void Description(nsString& aDescription) override;
   virtual Accessible* FocusedChild() override;
-  virtual mozilla::a11y::role NativeRole() override;
+  virtual mozilla::a11y::role NativeRole() const override;
   virtual uint64_t NativeState() override;
   virtual uint64_t NativeInteractiveState() const override;
   virtual bool NativelyUnavailable() const override;
   virtual void ApplyARIAState(uint64_t* aState) const override;
   virtual already_AddRefed<nsIPersistentProperties> Attributes() override;
 
   virtual void TakeFocus() override;
 

--- a/accessible/generic/FormControlAccessible.cpp
+++ b/accessible/generic/FormControlAccessible.cpp
@@ -20,17 +20,17 @@ using namespace mozilla::a11y;
 template class mozilla::a11y::ProgressMeterAccessible<1>;
 template class mozilla::a11y::ProgressMeterAccessible<100>;
 
 ////////////////////////////////////////////////////////////////////////////////
 // Accessible
 
 template<int Max>
 role
-ProgressMeterAccessible<Max>::NativeRole()
+ProgressMeterAccessible<Max>::NativeRole() const
 {
   return roles::PROGRESSBAR;
 }
 
 template<int Max>
 uint64_t
 ProgressMeterAccessible<Max>::NativeState()
 {
@@ -171,17 +171,17 @@ RadioButtonAccessible::DoAction(uint8_t 
   if (aIndex != eAction_Click)
     return false;
 
   DoCommand();
   return true;
 }
 
 role
-RadioButtonAccessible::NativeRole()
+RadioButtonAccessible::NativeRole() const
 {
   return roles::RADIOBUTTON;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RadioButtonAccessible: Widgets
 
 bool

--- a/accessible/generic/FormControlAccessible.h
+++ b/accessible/generic/FormControlAccessible.h
@@ -24,17 +24,17 @@ public:
     // Ignore 'ValueChange' DOM event in lieu of @value attribute change
     // notifications.
     mStateFlags |= eHasNumericValue | eIgnoreDOMUIEvent;
     mType = eProgressType;
   }
 
   // Accessible
   virtual void Value(nsString& aValue) override;
-  virtual mozilla::a11y::role NativeRole() override;
+  virtual mozilla::a11y::role NativeRole() const override;
   virtual uint64_t NativeState() override;
 
   // Value
   virtual double MaxValue() const override;
   virtual double MinValue() const override;
   virtual double CurValue() const override;
   virtual double Step() const override;
   virtual bool SetCurValue(double aValue) override;
@@ -51,17 +51,17 @@ protected:
   */
 class RadioButtonAccessible : public LeafAccessible
 {
 
 public:
   RadioButtonAccessible(nsIContent* aContent, DocAccessible* aDoc);
 
   // Accessible
-  virtual mozilla::a11y::role NativeRole() override;
+  virtual mozilla::a11y::role NativeRole() const override;
 
   // ActionAccessible
   virtual uint8_t ActionCount() override;
   virtual void ActionNameAt(uint8_t aIndex, nsAString& aName) override;
   virtual bool DoAction(uint8_t aIndex) override;
 
   enum { eAction_Click = 0 };
 

--- a/accessible/generic/HyperTextAccessible.cpp
+++ b/accessible/generic/HyperTextAccessible.cpp
@@ -52,17 +52,17 @@ HyperTextAccessible::
   HyperTextAccessible(nsIContent* aNode, DocAccessible* aDoc) :
   AccessibleWrap(aNode, aDoc)
 {
   mType = eHyperTextType;
   mGenericTypes |= eHyperText;
 }
 
 role
-HyperTextAccessible::NativeRole()
+HyperTextAccessible::NativeRole() const
 {
   a11y::role r = GetAccService()->MarkupRole(mContent);
   if (r != roles::NOTHING)
     return r;
 
   nsIFrame* frame = GetFrame();
   if (frame && frame->IsInlineFrame())
     return roles::TEXT;

--- a/accessible/generic/HyperTextAccessible.h
+++ b/accessible/generic/HyperTextAccessible.h
@@ -52,17 +52,17 @@ public:
   HyperTextAccessible(nsIContent* aContent, DocAccessible* aDoc);
 
   NS_INLINE_DECL_REFCOUNTING_INHERITED(HyperTextAccessible, AccessibleWrap)
 
   // Accessible
   virtual nsAtom* LandmarkRole() const override;
   virtual int32_t GetLevelInternal() override;
   virtual already_AddRefed<nsIPersistentProperties> NativeAttributes() override;
-  virtual mozilla::a11y::role NativeRole() override;
+  virtual mozilla::a11y::role NativeRole() const override;
   virtual uint64_t NativeState() override;
 
   virtual void Shutdown() override;
   virtual bool RemoveChild(Accessible* aAccessible) override;
   virtual bool InsertChildAt(uint32_t aIndex, Accessible* aChild) override;
   virtual Relation RelationByType(RelationType aType) override;
 
   // HyperTextAccessible (static helper method)

--- a/accessible/generic/ImageAccessible.cpp
+++ b/accessible/generic/ImageAccessible.cpp
@@ -85,17 +85,17 @@ ImageAccessible::NativeName(nsString& aN
   // No accessible name but empty 'alt' attribute is present. If further name
   // computation algorithm doesn't provide non empty name then it means
   // an empty 'alt' attribute was used to indicate a decorative image (see
   // Accessible::Name() method for details).
   return hasAltAttrib ? eNoNameOnPurpose : eNameOK;
 }
 
 role
-ImageAccessible::NativeRole()
+ImageAccessible::NativeRole() const
 {
   return roles::GRAPHIC;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Accessible
 
 uint8_t

--- a/accessible/generic/ImageAccessible.h
+++ b/accessible/generic/ImageAccessible.h
@@ -17,17 +17,17 @@ namespace a11y {
  * - support basic state
  */
 class ImageAccessible : public LinkableAccessible
 {
 public:
   ImageAccessible(nsIContent* aContent, DocAccessible* aDoc);
 
   // Accessible
-  virtual a11y::role NativeRole() override;
+  virtual a11y::role NativeRole() const override;
   virtual uint64_t NativeState() override;
   virtual already_AddRefed<nsIPersistentProperties> NativeAttributes() override;
 
   // ActionAccessible
   virtual uint8_t ActionCount() override;
   virtual void ActionNameAt(uint8_t aIndex, nsAString& aName) override;
   virtual bool DoAction(uint8_t aIndex) override;
 

--- a/accessible/generic/OuterDocAccessible.cpp
+++ b/accessible/generic/OuterDocAccessible.cpp
@@ -49,17 +49,17 @@ OuterDocAccessible::
 OuterDocAccessible::~OuterDocAccessible()
 {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Accessible public (DON'T add methods here)
 
 role
-OuterDocAccessible::NativeRole()
+OuterDocAccessible::NativeRole() const
 {
   return roles::INTERNAL_FRAME;
 }
 
 Accessible*
 OuterDocAccessible::ChildAtPoint(int32_t aX, int32_t aY,
                                  EWhichChildAtPoint aWhichChild)
 {

--- a/accessible/generic/OuterDocAccessible.h
+++ b/accessible/generic/OuterDocAccessible.h
@@ -27,17 +27,17 @@ public:
   OuterDocAccessible(nsIContent* aContent, DocAccessible* aDoc);
 
   NS_INLINE_DECL_REFCOUNTING_INHERITED(OuterDocAccessible, AccessibleWrap)
 
   DocAccessibleParent* RemoteChildDoc() const;
 
   // Accessible
   virtual void Shutdown() override;
-  virtual mozilla::a11y::role NativeRole() override;
+  virtual mozilla::a11y::role NativeRole() const override;
   virtual Accessible* ChildAtPoint(int32_t aX, int32_t aY,
                                    EWhichChildAtPoint aWhichChild) override;
 
   virtual bool InsertChildAt(uint32_t aIdx, Accessible* aChild) override;
   virtual bool RemoveChild(Accessible* aAccessible) override;
   virtual bool IsAcceptableChild(nsIContent* aEl) const override;
 
 #if defined(XP_WIN)

--- a/accessible/generic/RootAccessible.cpp
+++ b/accessible/generic/RootAccessible.cpp
@@ -83,17 +83,17 @@ RootAccessible::Name(nsString& aName)
       return eNameOK;
   }
 
   mDocumentNode->GetTitle(aName);
   return eNameOK;
 }
 
 role
-RootAccessible::NativeRole()
+RootAccessible::NativeRole() const
 {
   // If it's a <dialog> or <wizard>, use roles::DIALOG instead
   dom::Element* rootElm = mDocumentNode->GetRootElement();
   if (rootElm && rootElm->IsAnyOfXULElements(nsGkAtoms::dialog,
                                              nsGkAtoms::wizard))
     return roles::DIALOG;
 
   return DocAccessibleWrap::NativeRole();

--- a/accessible/generic/RootAccessible.h
+++ b/accessible/generic/RootAccessible.h
@@ -26,17 +26,17 @@ public:
 
   // nsIDOMEventListener
   NS_DECL_NSIDOMEVENTLISTENER
 
   // Accessible
   virtual void Shutdown() override;
   virtual mozilla::a11y::ENameValueFlag Name(nsString& aName) override;
   virtual Relation RelationByType(RelationType aType) override;
-  virtual mozilla::a11y::role NativeRole() override;
+  virtual mozilla::a11y::role NativeRole() const override;
   virtual uint64_t NativeState() override;
 
   // RootAccessible
 
   /**
    * Notify that the sub document presshell was activated.
    */
   virtual void DocumentActivated(DocAccessible* aDocument);

--- a/accessible/generic/TextLeafAccessible.cpp
+++ b/accessible/generic/TextLeafAccessible.cpp
@@ -24,17 +24,17 @@ TextLeafAccessible::
   mStateFlags |= eNoKidsFromDOM;
 }
 
 TextLeafAccessible::~TextLeafAccessible()
 {
 }
 
 role
-TextLeafAccessible::NativeRole()
+TextLeafAccessible::NativeRole() const
 {
   nsIFrame* frame = GetFrame();
   if (frame && frame->IsGeneratedContentFrame())
     return roles::STATICTEXT;
 
   return roles::TEXT_LEAF;
 }
 

--- a/accessible/generic/TextLeafAccessible.h
+++ b/accessible/generic/TextLeafAccessible.h
@@ -16,17 +16,17 @@ namespace a11y {
  */
 class TextLeafAccessible : public LinkableAccessible
 {
 public:
   TextLeafAccessible(nsIContent* aContent, DocAccessible* aDoc);
   virtual ~TextLeafAccessible();
 
   // Accessible
-  virtual mozilla::a11y::role NativeRole() override;
+  virtual mozilla::a11y::role NativeRole() const override;
   virtual void AppendTextTo(nsAString& aText, uint32_t aStartOffset = 0,
                             uint32_t aLength = UINT32_MAX) override;
   virtual ENameValueFlag Name(nsString& aName) override;
 
   // TextLeafAccessible
   void SetText(const nsAString& aText) { mText = aText; }
   const nsString& Text() const { return mText; }
 

--- a/accessible/html/HTMLCanvasAccessible.cpp
+++ b/accessible/html/HTMLCanvasAccessible.cpp
@@ -11,12 +11,12 @@ using namespace mozilla::a11y;
 
 HTMLCanvasAccessible::
   HTMLCanvasAccessible(nsIContent* aContent, DocAccessible* aDoc) :
   HyperTextAccessibleWrap(aContent, aDoc)
 {
 }
 
 role
-HTMLCanvasAccessible::NativeRole()
+HTMLCanvasAccessible::NativeRole() const
 {
   return roles::CANVAS;
 }

--- a/accessible/html/HTMLCanvasAccessible.h
+++ b/accessible/html/HTMLCanvasAccessible.h
@@ -19,17 +19,17 @@ class HTMLCanvasAccessible : public Hype
 public:
   HTMLCanvasAccessible(nsIContent* aContent, DocAccessible* aDoc);
 
   // nsISupports
   NS_INLINE_DECL_REFCOUNTING_INHERITED(HTMLCanvasAccessible,
                                        HyperTextAccessibleWrap)
 
   // Accessible
-  virtual a11y::role NativeRole() override;
+  virtual a11y::role NativeRole() const override;
 
 protected:
   virtual ~HTMLCanvasAccessible() { }
 };
 
 } // namespace a11y
 } // namespace mozilla
 

--- a/accessible/html/HTMLElementAccessibles.cpp
+++ b/accessible/html/HTMLElementAccessibles.cpp
@@ -19,27 +19,27 @@
 
 using namespace mozilla::a11y;
 
 ////////////////////////////////////////////////////////////////////////////////
 // HTMLHRAccessible
 ////////////////////////////////////////////////////////////////////////////////
 
 role
-HTMLHRAccessible::NativeRole()
+HTMLHRAccessible::NativeRole() const
 {
   return roles::SEPARATOR;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // HTMLBRAccessible
 ////////////////////////////////////////////////////////////////////////////////
 
 role
-HTMLBRAccessible::NativeRole()
+HTMLBRAccessible::NativeRole() const
 {
   return roles::WHITESPACE;
 }
 
 uint64_t
 HTMLBRAccessible::NativeState()
 {
   return states::READONLY;
@@ -200,17 +200,17 @@ HTMLSummaryAccessible::IsWidget() const
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // HTMLHeaderOrFooterAccessible
 ////////////////////////////////////////////////////////////////////////////////
 
 role
-HTMLHeaderOrFooterAccessible::NativeRole()
+HTMLHeaderOrFooterAccessible::NativeRole() const
 {
   // Only map header and footer if they are direct descendants of the body tag.
   // If other sectioning or sectioning root elements, they become sections.
   nsIContent* parent = mContent->GetParent();
   while (parent) {
     if (parent->IsAnyOfHTMLElements(nsGkAtoms::article, nsGkAtoms::aside,
                              nsGkAtoms::nav, nsGkAtoms::section,
                              nsGkAtoms::blockquote, nsGkAtoms::details,

--- a/accessible/html/HTMLElementAccessibles.h
+++ b/accessible/html/HTMLElementAccessibles.h
@@ -17,34 +17,34 @@ namespace a11y {
 class HTMLHRAccessible : public LeafAccessible
 {
 public:
 
   HTMLHRAccessible(nsIContent* aContent, DocAccessible* aDoc) :
     LeafAccessible(aContent, aDoc) {}
 
   // Accessible
-  virtual a11y::role NativeRole() override;
+  virtual a11y::role NativeRole() const override;
 };
 
 /**
  * Used for HTML br element.
  */
 class HTMLBRAccessible : public LeafAccessible
 {
 public:
   HTMLBRAccessible(nsIContent* aContent, DocAccessible* aDoc) :
     LeafAccessible(aContent, aDoc)
   {
     mType = eHTMLBRType;
     mGenericTypes |= eText;
   }
 
   // Accessible
-  virtual a11y::role NativeRole() override;
+  virtual a11y::role NativeRole() const override;
   virtual uint64_t NativeState() override;
 
 protected:
   // Accessible
   virtual ENameValueFlag NativeName(nsString& aName) override;
 };
 
 /**
@@ -126,17 +126,17 @@ public:
   HTMLHeaderOrFooterAccessible(nsIContent* aContent, DocAccessible* aDoc) :
     HyperTextAccessibleWrap(aContent, aDoc) {}
 
   NS_INLINE_DECL_REFCOUNTING_INHERITED(HTMLHeaderOrFooterAccessible,
                                        HyperTextAccessibleWrap)
 
   // Accessible
   virtual nsAtom* LandmarkRole() const override;
-  virtual a11y::role NativeRole() override;
+  virtual a11y::role NativeRole() const override;
 
 protected:
   virtual ~HTMLHeaderOrFooterAccessible() {}
 };
 
 } // namespace a11y
 } // namespace mozilla
 

--- a/accessible/html/HTMLFormControlAccessible.cpp
+++ b/accessible/html/HTMLFormControlAccessible.cpp
@@ -35,17 +35,17 @@ using namespace mozilla;
 using namespace mozilla::dom;
 using namespace mozilla::a11y;
 
 ////////////////////////////////////////////////////////////////////////////////
 // HTMLCheckboxAccessible
 ////////////////////////////////////////////////////////////////////////////////
 
 role
-HTMLCheckboxAccessible::NativeRole()
+HTMLCheckboxAccessible::NativeRole() const
 {
   return roles::CHECKBUTTON;
 }
 
 uint8_t
 HTMLCheckboxAccessible::ActionCount()
 {
   return 1;
@@ -229,17 +229,17 @@ HTMLButtonAccessible::NativeState()
   EventStates elmState = mContent->AsElement()->State();
   if (elmState.HasState(NS_EVENT_STATE_DEFAULT))
     state |= states::DEFAULT;
 
   return state;
 }
 
 role
-HTMLButtonAccessible::NativeRole()
+HTMLButtonAccessible::NativeRole() const
 {
   return roles::PUSHBUTTON;
 }
 
 ENameValueFlag
 HTMLButtonAccessible::NativeName(nsString& aName)
 {
   // No need to check @value attribute for buttons since this attribute results
@@ -284,17 +284,17 @@ HTMLTextFieldAccessible::
 {
   mType = mContent->AsElement()->AttrValueIs(kNameSpaceID_None, nsGkAtoms::type,
                             nsGkAtoms::password, eIgnoreCase) ?
             eHTMLTextPasswordFieldType :
             eHTMLTextFieldType;
 }
 
 role
-HTMLTextFieldAccessible::NativeRole()
+HTMLTextFieldAccessible::NativeRole() const
 {
   if (mType == eHTMLTextPasswordFieldType) {
     return roles::PASSWORD_TEXT;
   }
 
   return roles::ENTRY;
 }
 
@@ -498,17 +498,17 @@ HTMLTextFieldAccessible::ContainerWidget
 HTMLFileInputAccessible::
 HTMLFileInputAccessible(nsIContent* aContent, DocAccessible* aDoc) :
   HyperTextAccessibleWrap(aContent, aDoc)
 {
   mType = eHTMLFileInputType;
 }
 
 role
-HTMLFileInputAccessible::NativeRole()
+HTMLFileInputAccessible::NativeRole() const
 {
   // JAWS wants a text container, others don't mind. No specific role in
   // AT APIs.
   return roles::TEXT_CONTAINER;
 }
 
 nsresult
 HTMLFileInputAccessible::HandleAccEvent(AccEvent* aEvent)
@@ -538,17 +538,17 @@ HTMLFileInputAccessible::HandleAccEvent(
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // HTMLSpinnerAccessible
 ////////////////////////////////////////////////////////////////////////////////
 
 role
-HTMLSpinnerAccessible::NativeRole()
+HTMLSpinnerAccessible::NativeRole() const
 {
   return roles::SPINBUTTON;
 }
 
 void
 HTMLSpinnerAccessible::Value(nsString& aValue)
 {
   AccessibleWrap::Value(aValue);
@@ -610,17 +610,17 @@ HTMLSpinnerAccessible::SetCurValue(doubl
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // HTMLRangeAccessible
 ////////////////////////////////////////////////////////////////////////////////
 
 role
-HTMLRangeAccessible::NativeRole()
+HTMLRangeAccessible::NativeRole() const
 {
   return roles::SLIDER;
 }
 
 bool
 HTMLRangeAccessible::IsWidget() const
 {
   return true;
@@ -694,17 +694,17 @@ HTMLRangeAccessible::SetCurValue(double 
 
 HTMLGroupboxAccessible::
   HTMLGroupboxAccessible(nsIContent* aContent, DocAccessible* aDoc) :
   HyperTextAccessibleWrap(aContent, aDoc)
 {
 }
 
 role
-HTMLGroupboxAccessible::NativeRole()
+HTMLGroupboxAccessible::NativeRole() const
 {
   return roles::GROUPING;
 }
 
 nsIContent*
 HTMLGroupboxAccessible::GetLegend() const
 {
   for (nsIContent* legendContent = mContent->GetFirstChild(); legendContent;

--- a/accessible/html/HTMLFormControlAccessible.h
+++ b/accessible/html/HTMLFormControlAccessible.h
@@ -31,17 +31,17 @@ public:
     LeafAccessible(aContent, aDoc)
   {
     // Ignore "CheckboxStateChange" DOM event in lieu of document observer
     // state change notification.
     mStateFlags |= eIgnoreDOMUIEvent;
   }
 
   // Accessible
-  virtual mozilla::a11y::role NativeRole() override;
+  virtual mozilla::a11y::role NativeRole() const override;
   virtual uint64_t NativeState() override;
 
   // ActionAccessible
   virtual uint8_t ActionCount() override;
   virtual void ActionNameAt(uint8_t aIndex, nsAString& aName) override;
   virtual bool DoAction(uint8_t aIndex) override;
 
   // Widgets
@@ -79,17 +79,17 @@ class HTMLButtonAccessible : public Hype
 {
 
 public:
   enum { eAction_Click = 0 };
 
   HTMLButtonAccessible(nsIContent* aContent, DocAccessible* aDoc);
 
   // Accessible
-  virtual mozilla::a11y::role NativeRole() override;
+  virtual mozilla::a11y::role NativeRole() const override;
   virtual uint64_t State() override;
   virtual uint64_t NativeState() override;
 
   // ActionAccessible
   virtual uint8_t ActionCount() override;
   virtual void ActionNameAt(uint8_t aIndex, nsAString& aName) override;
   virtual bool DoAction(uint8_t aIndex) override;
 
@@ -118,17 +118,17 @@ public:
                                        HyperTextAccessibleWrap)
 
   // HyperTextAccessible
   virtual already_AddRefed<TextEditor> GetEditor() const override;
 
   // Accessible
   virtual void Value(nsString& aValue) override;
   virtual void ApplyARIAState(uint64_t* aState) const override;
-  virtual mozilla::a11y::role NativeRole() override;
+  virtual mozilla::a11y::role NativeRole() const override;
   virtual uint64_t NativeState() override;
   virtual already_AddRefed<nsIPersistentProperties> NativeAttributes() override;
 
   // ActionAccessible
   virtual uint8_t ActionCount() override;
   virtual void ActionNameAt(uint8_t aIndex, nsAString& aName) override;
   virtual bool DoAction(uint8_t aIndex) override;
 
@@ -153,17 +153,17 @@ protected:
  * Accessible for input@type="file" element.
  */
 class HTMLFileInputAccessible : public HyperTextAccessibleWrap
 {
 public:
   HTMLFileInputAccessible(nsIContent* aContent, DocAccessible* aDoc);
 
   // Accessible
-  virtual mozilla::a11y::role NativeRole() override;
+  virtual mozilla::a11y::role NativeRole() const override;
   virtual nsresult HandleAccEvent(AccEvent* aAccEvent) override;
 };
 
 
 /**
  * Used for HTML input@type="number".
  */
 class HTMLSpinnerAccessible : public AccessibleWrap
@@ -171,17 +171,17 @@ class HTMLSpinnerAccessible : public Acc
 public:
   HTMLSpinnerAccessible(nsIContent* aContent, DocAccessible* aDoc) :
     AccessibleWrap(aContent, aDoc)
   {
     mStateFlags |= eHasNumericValue;
 }
 
   // Accessible
-  virtual mozilla::a11y::role NativeRole() override;
+  virtual mozilla::a11y::role NativeRole() const override;
   virtual void Value(nsString& aValue) override;
 
   virtual double MaxValue() const override;
   virtual double MinValue() const override;
   virtual double CurValue() const override;
   virtual double Step() const override;
   virtual bool SetCurValue(double aValue) override;
 };
@@ -196,17 +196,17 @@ public:
   HTMLRangeAccessible(nsIContent* aContent, DocAccessible* aDoc) :
     LeafAccessible(aContent, aDoc)
   {
     mStateFlags |= eHasNumericValue;
   }
 
   // Accessible
   virtual void Value(nsString& aValue) override;
-  virtual mozilla::a11y::role NativeRole() override;
+  virtual mozilla::a11y::role NativeRole() const override;
 
   // Value
   virtual double MaxValue() const override;
   virtual double MinValue() const override;
   virtual double CurValue() const override;
   virtual double Step() const override;
   virtual bool SetCurValue(double aValue) override;
 
@@ -219,17 +219,17 @@ public:
  * Accessible for HTML fieldset element.
  */
 class HTMLGroupboxAccessible : public HyperTextAccessibleWrap
 {
 public:
   HTMLGroupboxAccessible(nsIContent* aContent, DocAccessible* aDoc);
 
   // Accessible
-  virtual mozilla::a11y::role NativeRole() override;
+  virtual mozilla::a11y::role NativeRole() const override;
   virtual Relation RelationByType(RelationType aType) override;
 
 protected:
   // Accessible
   virtual ENameValueFlag NativeName(nsString& aName) override;
 
   // HTMLGroupboxAccessible
   nsIContent* GetLegend() const;

--- a/accessible/html/HTMLImageMapAccessible.cpp
+++ b/accessible/html/HTMLImageMapAccessible.cpp
@@ -31,17 +31,17 @@ HTMLImageMapAccessible::
 
   UpdateChildAreas(false);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // HTMLImageMapAccessible: Accessible public
 
 role
-HTMLImageMapAccessible::NativeRole()
+HTMLImageMapAccessible::NativeRole() const
 {
   return roles::IMAGE_MAP;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // HTMLImageMapAccessible: HyperLinkAccessible
 
 uint32_t

--- a/accessible/html/HTMLImageMapAccessible.h
+++ b/accessible/html/HTMLImageMapAccessible.h
@@ -20,17 +20,17 @@ class HTMLImageMapAccessible final : pub
 public:
   HTMLImageMapAccessible(nsIContent* aContent, DocAccessible* aDoc);
 
   // nsISupports and cycle collector
   NS_INLINE_DECL_REFCOUNTING_INHERITED(HTMLImageMapAccessible,
                                        ImageAccessibleWrap)
 
   // Accessible
-  virtual a11y::role NativeRole() override;
+  virtual a11y::role NativeRole() const override;
 
   // HyperLinkAccessible
   virtual uint32_t AnchorCount() override;
   virtual Accessible* AnchorAt(uint32_t aAnchorIndex) override;
   virtual already_AddRefed<nsIURI> AnchorURIAt(uint32_t aAnchorIndex) override;
 
   /**
    * Update area children of the image map.

--- a/accessible/html/HTMLLinkAccessible.cpp
+++ b/accessible/html/HTMLLinkAccessible.cpp
@@ -26,17 +26,17 @@ HTMLLinkAccessible::
   HyperTextAccessibleWrap(aContent, aDoc)
 {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsIAccessible
 
 role
-HTMLLinkAccessible::NativeRole()
+HTMLLinkAccessible::NativeRole() const
 {
   return roles::LINK;
 }
 
 uint64_t
 HTMLLinkAccessible::NativeState()
 {
   return HyperTextAccessibleWrap::NativeState() & ~states::READONLY;

--- a/accessible/html/HTMLLinkAccessible.h
+++ b/accessible/html/HTMLLinkAccessible.h
@@ -16,17 +16,17 @@ class HTMLLinkAccessible : public HyperT
 public:
   HTMLLinkAccessible(nsIContent* aContent, DocAccessible* aDoc);
 
   NS_INLINE_DECL_REFCOUNTING_INHERITED(HTMLLinkAccessible,
                                        HyperTextAccessibleWrap)
 
   // Accessible
   virtual void Value(nsString& aValue) override;
-  virtual a11y::role NativeRole() override;
+  virtual a11y::role NativeRole() const override;
   virtual uint64_t NativeState() override;
   virtual uint64_t NativeLinkState() const override;
   virtual uint64_t NativeInteractiveState() const override;
 
   // ActionAccessible
   virtual uint8_t ActionCount() override;
   virtual void ActionNameAt(uint8_t aIndex, nsAString& aName) override;
   virtual bool DoAction(uint8_t aIndex) override;

--- a/accessible/html/HTMLListAccessible.cpp
+++ b/accessible/html/HTMLListAccessible.cpp
@@ -17,17 +17,17 @@
 using namespace mozilla;
 using namespace mozilla::a11y;
 
 ////////////////////////////////////////////////////////////////////////////////
 // HTMLListAccessible
 ////////////////////////////////////////////////////////////////////////////////
 
 role
-HTMLListAccessible::NativeRole()
+HTMLListAccessible::NativeRole() const
 {
   a11y::role r = GetAccService()->MarkupRole(mContent);
   return r != roles::NOTHING ? r : roles::LIST;
 }
 
 uint64_t
 HTMLListAccessible::NativeState()
 {
@@ -57,17 +57,17 @@ void
 HTMLLIAccessible::Shutdown()
 {
   mBullet = nullptr;
 
   HyperTextAccessibleWrap::Shutdown();
 }
 
 role
-HTMLLIAccessible::NativeRole()
+HTMLLIAccessible::NativeRole() const
 {
   a11y::role r = GetAccService()->MarkupRole(mContent);
   return r != roles::NOTHING ? r : roles::LISTITEM;
 }
 
 uint64_t
 HTMLLIAccessible::NativeState()
 {
@@ -156,17 +156,17 @@ HTMLListBulletAccessible::Name(nsString 
   if (blockFrame) {
     blockFrame->GetSpokenBulletText(aName);
   }
 
   return eNameOK;
 }
 
 role
-HTMLListBulletAccessible::NativeRole()
+HTMLListBulletAccessible::NativeRole() const
 {
   return roles::STATICTEXT;
 }
 
 uint64_t
 HTMLListBulletAccessible::NativeState()
 {
   return LeafAccessible::NativeState() | states::READONLY;

--- a/accessible/html/HTMLListAccessible.h
+++ b/accessible/html/HTMLListAccessible.h
@@ -24,17 +24,17 @@ public:
   HTMLListAccessible(nsIContent* aContent, DocAccessible* aDoc) :
     HyperTextAccessibleWrap(aContent, aDoc) { mGenericTypes |= eList; }
 
   // nsISupports
   NS_INLINE_DECL_REFCOUNTING_INHERITED(HTMLListAccessible,
                                        HyperTextAccessibleWrap)
 
   // Accessible
-  virtual a11y::role NativeRole() override;
+  virtual a11y::role NativeRole() const override;
   virtual uint64_t NativeState() override;
 
 protected:
   virtual ~HTMLListAccessible() { }
 };
 
 
 /**
@@ -47,17 +47,17 @@ public:
 
   // nsISupports
   NS_INLINE_DECL_REFCOUNTING_INHERITED(HTMLLIAccessible,
                                        HyperTextAccessibleWrap)
 
   // Accessible
   virtual void Shutdown() override;
   virtual nsRect BoundsInAppUnits() const override;
-  virtual a11y::role NativeRole() override;
+  virtual a11y::role NativeRole() const override;
   virtual uint64_t NativeState() override;
 
   virtual bool InsertChildAt(uint32_t aIndex, Accessible* aChild) override;
 
   // HTMLLIAccessible
   HTMLListBulletAccessible* Bullet() const { return mBullet; }
   void UpdateBullet(bool aHasBullet);
 
@@ -76,17 +76,17 @@ class HTMLListBulletAccessible : public 
 {
 public:
   HTMLListBulletAccessible(nsIContent* aContent, DocAccessible* aDoc);
   virtual ~HTMLListBulletAccessible() { }
 
   // Accessible
   virtual nsIFrame* GetFrame() const override;
   virtual ENameValueFlag Name(nsString& aName) override;
-  virtual a11y::role NativeRole() override;
+  virtual a11y::role NativeRole() const override;
   virtual uint64_t NativeState() override;
   virtual void AppendTextTo(nsAString& aText, uint32_t aStartOffset = 0,
                             uint32_t aLength = UINT32_MAX) override;
 
   // HTMLListBulletAccessible
 
   /**
    * Return true if the bullet is inside of list item element boundaries.

--- a/accessible/html/HTMLSelectAccessible.cpp
+++ b/accessible/html/HTMLSelectAccessible.cpp
@@ -44,17 +44,17 @@ HTMLSelectListAccessible::NativeState()
   uint64_t state = AccessibleWrap::NativeState();
   if (mContent->AsElement()->HasAttr(kNameSpaceID_None, nsGkAtoms::multiple))
     state |= states::MULTISELECTABLE | states::EXTSELECTABLE;
 
   return state;
 }
 
 role
-HTMLSelectListAccessible::NativeRole()
+HTMLSelectListAccessible::NativeRole() const
 {
   return roles::LISTBOX;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // HTMLSelectListAccessible: SelectAccessible
 
 bool
@@ -134,17 +134,17 @@ HTMLSelectOptionAccessible::
   HyperTextAccessibleWrap(aContent, aDoc)
 {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // HTMLSelectOptionAccessible: Accessible public
 
 role
-HTMLSelectOptionAccessible::NativeRole()
+HTMLSelectOptionAccessible::NativeRole() const
 {
   if (GetCombobox())
     return roles::COMBOBOX_OPTION;
 
   return roles::OPTION;
 }
 
 ENameValueFlag
@@ -301,17 +301,17 @@ HTMLSelectOptionAccessible::ContainerWid
   return parent && parent->IsListControl() ? parent : nullptr;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // HTMLSelectOptGroupAccessible
 ////////////////////////////////////////////////////////////////////////////////
 
 role
-HTMLSelectOptGroupAccessible::NativeRole()
+HTMLSelectOptGroupAccessible::NativeRole() const
 {
   return roles::GROUPING;
 }
 
 uint64_t
 HTMLSelectOptGroupAccessible::NativeInteractiveState() const
 {
   return NativelyUnavailable() ? states::UNAVAILABLE : 0;
@@ -363,17 +363,17 @@ HTMLComboboxAccessible::
     }
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // HTMLComboboxAccessible: Accessible
 
 role
-HTMLComboboxAccessible::NativeRole()
+HTMLComboboxAccessible::NativeRole() const
 {
   return roles::COMBOBOX;
 }
 
 bool
 HTMLComboboxAccessible::RemoveChild(Accessible* aChild)
 {
   MOZ_ASSERT(aChild == mListAccessible);
@@ -557,17 +557,17 @@ HTMLComboboxListAccessible::GetFrame() c
   if (comboBox) {
     return comboBox->GetDropDown();
   }
 
   return nullptr;
 }
 
 role
-HTMLComboboxListAccessible::NativeRole()
+HTMLComboboxListAccessible::NativeRole() const
 {
   return roles::COMBOBOX_LIST;
 }
 
 uint64_t
 HTMLComboboxListAccessible::NativeState()
 {
   // As a HTMLComboboxListAccessible we can have the following states:

--- a/accessible/html/HTMLSelectAccessible.h
+++ b/accessible/html/HTMLSelectAccessible.h
@@ -32,17 +32,17 @@ namespace a11y {
 class HTMLSelectListAccessible : public AccessibleWrap
 {
 public:
 
   HTMLSelectListAccessible(nsIContent* aContent, DocAccessible* aDoc);
   virtual ~HTMLSelectListAccessible() {}
 
   // Accessible
-  virtual a11y::role NativeRole() override;
+  virtual a11y::role NativeRole() const override;
   virtual uint64_t NativeState() override;
   virtual bool IsAcceptableChild(nsIContent* aEl) const override;
 
   // SelectAccessible
   virtual bool SelectAll() override;
   virtual bool UnselectAll() override;
 
   // Widgets
@@ -60,17 +60,17 @@ class HTMLSelectOptionAccessible : publi
 {
 public:
   enum { eAction_Select = 0 };
 
   HTMLSelectOptionAccessible(nsIContent* aContent, DocAccessible* aDoc);
   virtual ~HTMLSelectOptionAccessible() {}
 
   // Accessible
-  virtual a11y::role NativeRole() override;
+  virtual a11y::role NativeRole() const override;
   virtual uint64_t NativeState() override;
   virtual uint64_t NativeInteractiveState() const override;
 
   virtual int32_t GetLevelInternal() override;
   virtual nsRect RelativeBounds(nsIFrame** aBoundingFrame) const override;
   virtual void SetSelected(bool aSelect) override;
 
   // ActionAccessible
@@ -130,17 +130,17 @@ class HTMLSelectOptGroupAccessible : pub
 public:
 
   HTMLSelectOptGroupAccessible(nsIContent* aContent, DocAccessible* aDoc) :
     HTMLSelectOptionAccessible(aContent, aDoc)
     { mType = eHTMLOptGroupType; }
   virtual ~HTMLSelectOptGroupAccessible() {}
 
   // Accessible
-  virtual a11y::role NativeRole() override;
+  virtual a11y::role NativeRole() const override;
   virtual uint64_t NativeInteractiveState() const override;
   virtual bool IsAcceptableChild(nsIContent* aEl) const override;
 
   // ActionAccessible
   virtual uint8_t ActionCount() override;
   virtual void ActionNameAt(uint8_t aIndex, nsAString& aName) override;
   virtual bool DoAction(uint8_t aIndex) override;
 };
@@ -161,17 +161,17 @@ public:
 
   HTMLComboboxAccessible(nsIContent* aContent, DocAccessible* aDoc);
   virtual ~HTMLComboboxAccessible() {}
 
   // Accessible
   virtual void Shutdown() override;
   virtual void Description(nsString& aDescription) override;
   virtual void Value(nsString& aValue) override;
-  virtual a11y::role NativeRole() override;
+  virtual a11y::role NativeRole() const override;
   virtual uint64_t NativeState() override;
   virtual bool RemoveChild(Accessible* aChild) override;
   virtual bool IsAcceptableChild(nsIContent* aEl) const override;
 
   // ActionAccessible
   virtual uint8_t ActionCount() override;
   virtual void ActionNameAt(uint8_t aIndex, nsAString& aName) override;
   virtual bool DoAction(uint8_t aIndex) override;
@@ -203,17 +203,17 @@ class HTMLComboboxListAccessible : publi
 public:
 
   HTMLComboboxListAccessible(Accessible* aParent, nsIContent* aContent,
                              DocAccessible* aDoc);
   virtual ~HTMLComboboxListAccessible() {}
 
   // Accessible
   virtual nsIFrame* GetFrame() const override;
-  virtual a11y::role NativeRole() override;
+  virtual a11y::role NativeRole() const override;
   virtual uint64_t NativeState() override;
   virtual nsRect RelativeBounds(nsIFrame** aBoundingFrame) const override;
   virtual bool IsAcceptableChild(nsIContent* aEl) const override;
 
   // Widgets
   virtual bool IsActiveWidget() const override;
   virtual bool AreItemsOperable() const override;
 };

--- a/accessible/html/HTMLTableAccessible.cpp
+++ b/accessible/html/HTMLTableAccessible.cpp
@@ -48,17 +48,17 @@ HTMLTableCellAccessible::
   mType = eHTMLTableCellType;
   mGenericTypes |= eTableCell;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // HTMLTableCellAccessible: Accessible implementation
 
 role
-HTMLTableCellAccessible::NativeRole()
+HTMLTableCellAccessible::NativeRole() const
 {
   if (mContent->IsMathMLElement(nsGkAtoms::mtd_)) {
     return roles::MATHML_CELL;
   }
   return roles::CELL;
 }
 
 uint64_t
@@ -299,17 +299,17 @@ HTMLTableHeaderCellAccessible::
   HTMLTableCellAccessible(aContent, aDoc)
 {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // HTMLTableHeaderCellAccessible: Accessible implementation
 
 role
-HTMLTableHeaderCellAccessible::NativeRole()
+HTMLTableHeaderCellAccessible::NativeRole() const
 {
   // Check value of @scope attribute.
   static Element::AttrValuesArray scopeValues[] =
     { &nsGkAtoms::col, &nsGkAtoms::colgroup,
       &nsGkAtoms::row, &nsGkAtoms::rowgroup, nullptr };
   int32_t valueIdx =
     mContent->AsElement()->FindAttrValueIn(kNameSpaceID_None, nsGkAtoms::scope,
                                            scopeValues, eCaseMatters);
@@ -348,17 +348,17 @@ HTMLTableHeaderCellAccessible::NativeRol
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // HTMLTableRowAccessible
 ////////////////////////////////////////////////////////////////////////////////
 
 role
-HTMLTableRowAccessible::NativeRole()
+HTMLTableRowAccessible::NativeRole() const
 {
   if (mContent->IsMathMLElement(nsGkAtoms::mtr_)) {
     return roles::MATHML_TABLE_ROW;
   } else if (mContent->IsMathMLElement(nsGkAtoms::mlabeledtr_)) {
     return roles::MATHML_LABELED_ROW;
   }
   return roles::ROW;
 }
@@ -390,17 +390,17 @@ HTMLTableAccessible::InsertChildAt(uint3
   // Move caption accessible so that it's the first child. Check for the first
   // caption only, because nsAccessibilityService ensures we don't create
   // accessibles for the other captions, since only the first is actually
   // visible.
   return Accessible::InsertChildAt(aChild->IsHTMLCaption() ? 0 : aIndex, aChild);
 }
 
 role
-HTMLTableAccessible::NativeRole()
+HTMLTableAccessible::NativeRole() const
 {
   if (mContent->IsMathMLElement(nsGkAtoms::mtable_)) {
     return roles::MATHML_TABLE;
   }
   return roles::TABLE;
 }
 
 uint64_t
@@ -1109,12 +1109,12 @@ HTMLCaptionAccessible::RelationByType(Re
   Relation rel = HyperTextAccessible::RelationByType(aType);
   if (aType == RelationType::LABEL_FOR)
     rel.AppendTarget(Parent());
 
   return rel;
 }
 
 role
-HTMLCaptionAccessible::NativeRole()
+HTMLCaptionAccessible::NativeRole() const
 {
   return roles::CAPTION;
 }

--- a/accessible/html/HTMLTableAccessible.h
+++ b/accessible/html/HTMLTableAccessible.h
@@ -29,17 +29,17 @@ public:
   HTMLTableCellAccessible(nsIContent* aContent, DocAccessible* aDoc);
 
   // nsISupports
   NS_INLINE_DECL_REFCOUNTING_INHERITED(HTMLTableCellAccessible,
                                        HyperTextAccessibleWrap)
 
   // Accessible
   virtual TableCellAccessible* AsTableCell() override { return this; }
-  virtual a11y::role NativeRole() override;
+  virtual a11y::role NativeRole() const override;
   virtual uint64_t NativeState() override;
   virtual uint64_t NativeInteractiveState() const override;
   virtual already_AddRefed<nsIPersistentProperties> NativeAttributes() override;
   virtual mozilla::a11y::GroupPos GroupPosition() override;
 
   // TableCellAccessible
   virtual TableAccessible* Table() const override;
   virtual uint32_t ColIdx() const override;
@@ -74,17 +74,17 @@ protected:
  * HTML table row/column header accessible (html:th or html:td@scope).
  */
 class HTMLTableHeaderCellAccessible : public HTMLTableCellAccessible
 {
 public:
   HTMLTableHeaderCellAccessible(nsIContent* aContent, DocAccessible* aDoc);
 
   // Accessible
-  virtual a11y::role NativeRole() override;
+  virtual a11y::role NativeRole() const override;
 };
 
 
 /**
  * HTML table row accessible (html:tr).
  */
 class HTMLTableRowAccessible : public AccessibleWrap
 {
@@ -94,17 +94,17 @@ public:
   {
     mType = eHTMLTableRowType;
     mGenericTypes |= eTableRow;
   }
 
   NS_INLINE_DECL_REFCOUNTING_INHERITED(HTMLTableRowAccessible, AccessibleWrap)
 
   // Accessible
-  virtual a11y::role NativeRole() override;
+  virtual a11y::role NativeRole() const override;
   virtual mozilla::a11y::GroupPos GroupPosition() override;
 
 protected:
   virtual ~HTMLTableRowAccessible() { }
 };
 
 
 /**
@@ -157,17 +157,17 @@ public:
   virtual void UnselectCol(uint32_t aColIdx) override;
   virtual void UnselectRow(uint32_t aRowIdx) override;
   virtual bool IsProbablyLayoutTable() override;
   virtual Accessible* AsAccessible() override { return this; }
 
   // Accessible
   virtual TableAccessible* AsTable() override { return this; }
   virtual void Description(nsString& aDescription) override;
-  virtual a11y::role NativeRole() override;
+  virtual a11y::role NativeRole() const override;
   virtual uint64_t NativeState() override;
   virtual already_AddRefed<nsIPersistentProperties> NativeAttributes() override;
   virtual Relation RelationByType(RelationType aRelationType) override;
 
   virtual bool InsertChildAt(uint32_t aIndex, Accessible* aChild) override;
 
 protected:
   virtual ~HTMLTableAccessible() {}
@@ -218,17 +218,17 @@ protected:
  */
 class HTMLCaptionAccessible : public HyperTextAccessibleWrap
 {
 public:
   HTMLCaptionAccessible(nsIContent* aContent, DocAccessible* aDoc) :
     HyperTextAccessibleWrap(aContent, aDoc) { mType = eHTMLCaptionType; }
 
   // Accessible
-  virtual a11y::role NativeRole() override;
+  virtual a11y::role NativeRole() const override;
   virtual Relation RelationByType(RelationType aRelationType) override;
 
 protected:
   virtual ~HTMLCaptionAccessible() { }
 };
 
 } // namespace a11y
 } // namespace mozilla

--- a/accessible/windows/msaa/HTMLWin32ObjectAccessible.cpp
+++ b/accessible/windows/msaa/HTMLWin32ObjectAccessible.cpp
@@ -34,17 +34,17 @@ HTMLWin32ObjectOwnerAccessible::
 void
 HTMLWin32ObjectOwnerAccessible::Shutdown()
 {
   AccessibleWrap::Shutdown();
   mNativeAccessible = nullptr;
 }
 
 role
-HTMLWin32ObjectOwnerAccessible::NativeRole()
+HTMLWin32ObjectOwnerAccessible::NativeRole() const
 {
   return roles::EMBEDDED_OBJECT;
 }
 
 bool
 HTMLWin32ObjectOwnerAccessible::NativelyUnavailable() const
 {
   // XXX: No HWND means this is windowless plugin which is not accessible in

--- a/accessible/windows/msaa/HTMLWin32ObjectAccessible.h
+++ b/accessible/windows/msaa/HTMLWin32ObjectAccessible.h
@@ -27,17 +27,17 @@ public:
   // Mozilla tree, and returns null for previous and next sibling. This would
   // have the effect of cutting off all content after the plugin.
   HTMLWin32ObjectOwnerAccessible(nsIContent* aContent,
                                  DocAccessible* aDoc, void* aHwnd);
   virtual ~HTMLWin32ObjectOwnerAccessible() {}
 
   // Accessible
   virtual void Shutdown();
-  virtual mozilla::a11y::role NativeRole();
+  virtual mozilla::a11y::role NativeRole() const override;
   virtual bool NativelyUnavailable() const;
 
 protected:
   void* mHwnd;
   RefPtr<Accessible> mNativeAccessible;
 };
 
 /**

--- a/accessible/xul/XULAlertAccessible.cpp
+++ b/accessible/xul/XULAlertAccessible.cpp
@@ -22,17 +22,17 @@ XULAlertAccessible::
   mGenericTypes |= eAlert;
 }
 
 XULAlertAccessible::~XULAlertAccessible()
 {
 }
 
 role
-XULAlertAccessible::NativeRole()
+XULAlertAccessible::NativeRole() const
 {
   return roles::ALERT;
 }
 
 uint64_t
 XULAlertAccessible::NativeState()
 {
   return Accessible::NativeState() | states::ALERT;

--- a/accessible/xul/XULAlertAccessible.h
+++ b/accessible/xul/XULAlertAccessible.h
@@ -19,17 +19,17 @@ class XULAlertAccessible : public Access
 {
 public:
   XULAlertAccessible(nsIContent* aContent, DocAccessible* aDoc);
 
   NS_INLINE_DECL_REFCOUNTING_INHERITED(XULAlertAccessible, AccessibleWrap)
 
   // Accessible
   virtual mozilla::a11y::ENameValueFlag Name(nsString& aName) override;
-  virtual a11y::role NativeRole() override;
+  virtual a11y::role NativeRole() const override;
   virtual uint64_t NativeState() override;
 
   // Widgets
   virtual bool IsWidget() const override;
   virtual Accessible* ContainerWidget() const override;
 
 protected:
   ~XULAlertAccessible();

--- a/accessible/xul/XULColorPickerAccessible.cpp
+++ b/accessible/xul/XULColorPickerAccessible.cpp
@@ -32,17 +32,17 @@ void
 XULColorPickerTileAccessible::Value(nsString& aValue)
 {
   aValue.Truncate();
 
   mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::color, aValue);
 }
 
 role
-XULColorPickerTileAccessible::NativeRole()
+XULColorPickerTileAccessible::NativeRole() const
 {
   return roles::PUSHBUTTON;
 }
 
 uint64_t
 XULColorPickerTileAccessible::NativeState()
 {
   uint64_t state = AccessibleWrap::NativeState();
@@ -91,17 +91,17 @@ XULColorPickerAccessible::
 uint64_t
 XULColorPickerAccessible::NativeState()
 {
   uint64_t state = AccessibleWrap::NativeState();
   return state | states::HASPOPUP;
 }
 
 role
-XULColorPickerAccessible::NativeRole()
+XULColorPickerAccessible::NativeRole() const
 {
   return roles::BUTTONDROPDOWNGRID;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // XULColorPickerAccessible: Widgets
 
 bool

--- a/accessible/xul/XULColorPickerAccessible.h
+++ b/accessible/xul/XULColorPickerAccessible.h
@@ -17,17 +17,17 @@ namespace a11y {
 class XULColorPickerTileAccessible : public AccessibleWrap
 {
 public:
   XULColorPickerTileAccessible(nsIContent* aContent,
                                DocAccessible* aDoc);
 
   // Accessible
   virtual void Value(nsString& aValue) override;
-  virtual a11y::role NativeRole() override;
+  virtual a11y::role NativeRole() const override;
   virtual uint64_t NativeState() override;
   virtual uint64_t NativeInteractiveState() const override;
 
   // Widgets
   virtual Accessible* ContainerWidget() const override;
 };
 
 
@@ -35,17 +35,17 @@ public:
  * Used for colorpicker button (xul:colorpicker@type="button").
  */
 class XULColorPickerAccessible : public XULColorPickerTileAccessible
 {
 public:
   XULColorPickerAccessible(nsIContent* aContent, DocAccessible* aDoc);
 
   // Accessible
-  virtual a11y::role NativeRole() override;
+  virtual a11y::role NativeRole() const override;
   virtual uint64_t NativeState() override;
 
   // Widgets
   virtual bool IsWidget() const override;
   virtual bool IsActiveWidget() const override;
   virtual bool AreItemsOperable() const override;
 
   virtual bool IsAcceptableChild(nsIContent* aEl) const override;

--- a/accessible/xul/XULComboboxAccessible.cpp
+++ b/accessible/xul/XULComboboxAccessible.cpp
@@ -39,17 +39,17 @@ XULComboboxAccessible::
       !mContent->AsElement()->AttrValueIs(kNameSpaceID_None,
                                           nsGkAtoms::editable, nsGkAtoms::_true,
                                           eIgnoreCase)) {
     mStateFlags |= eNoXBLKids;
   }
 }
 
 role
-XULComboboxAccessible::NativeRole()
+XULComboboxAccessible::NativeRole() const
 {
   return IsAutoComplete() ? roles::AUTOCOMPLETE : roles::COMBOBOX;
 }
 
 uint64_t
 XULComboboxAccessible::NativeState()
 {
   // As a nsComboboxAccessible we can have the following states:

--- a/accessible/xul/XULComboboxAccessible.h
+++ b/accessible/xul/XULComboboxAccessible.h
@@ -19,17 +19,17 @@ class XULComboboxAccessible : public Acc
 public:
   enum { eAction_Click = 0 };
 
   XULComboboxAccessible(nsIContent* aContent, DocAccessible* aDoc);
 
   // Accessible
   virtual void Description(nsString& aDescription) override;
   virtual void Value(nsString& aValue) override;
-  virtual a11y::role NativeRole() override;
+  virtual a11y::role NativeRole() const override;
   virtual uint64_t NativeState() override;
 
   // ActionAccessible
   virtual uint8_t ActionCount() override;
   virtual void ActionNameAt(uint8_t aIndex, nsAString& aName) override;
   virtual bool DoAction(uint8_t aIndex) override;
 
   // Widgets

--- a/accessible/xul/XULElementAccessibles.cpp
+++ b/accessible/xul/XULElementAccessibles.cpp
@@ -68,17 +68,17 @@ XULLabelAccessible::NativeName(nsString&
   // from the accessible text interface or from the children
   if (mValueTextLeaf)
     return mValueTextLeaf->Name(aName);
 
   return Accessible::NativeName(aName);
 }
 
 role
-XULLabelAccessible::NativeRole()
+XULLabelAccessible::NativeRole() const
 {
   return roles::LABEL;
 }
 
 uint64_t
 XULLabelAccessible::NativeState()
 {
   // Labels and description have read only state
@@ -122,17 +122,17 @@ XULLabelAccessible::UpdateLabelValue(con
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // XULLabelTextLeafAccessible
 ////////////////////////////////////////////////////////////////////////////////
 
 role
-XULLabelTextLeafAccessible::NativeRole()
+XULLabelTextLeafAccessible::NativeRole() const
 {
   return roles::TEXT_LEAF;
 }
 
 uint64_t
 XULLabelTextLeafAccessible::NativeState()
 {
   return TextLeafAccessibleWrap::NativeState() | states::READONLY;
@@ -151,17 +151,17 @@ XULTooltipAccessible::
 
 uint64_t
 XULTooltipAccessible::NativeState()
 {
   return LeafAccessible::NativeState() | states::READONLY;
 }
 
 role
-XULTooltipAccessible::NativeRole()
+XULTooltipAccessible::NativeRole() const
 {
   return roles::TOOLTIP;
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // XULLinkAccessible
 ////////////////////////////////////////////////////////////////////////////////
@@ -194,17 +194,17 @@ XULLinkAccessible::NativeName(nsString& 
   if (!aName.IsEmpty())
     return eNameOK;
 
   nsTextEquivUtils::GetNameFromSubtree(this, aName);
   return aName.IsEmpty() ? eNameOK : eNameFromSubtree;
 }
 
 role
-XULLinkAccessible::NativeRole()
+XULLinkAccessible::NativeRole() const
 {
   return roles::LINK;
 }
 
 
 uint64_t
 XULLinkAccessible::NativeLinkState() const
 {

--- a/accessible/xul/XULElementAccessibles.h
+++ b/accessible/xul/XULElementAccessibles.h
@@ -19,17 +19,17 @@ class XULLabelTextLeafAccessible;
  */
 class XULLabelAccessible : public HyperTextAccessibleWrap
 {
 public:
   XULLabelAccessible(nsIContent* aContent, DocAccessible* aDoc);
 
   // Accessible
   virtual void Shutdown() override;
-  virtual a11y::role NativeRole() override;
+  virtual a11y::role NativeRole() const override;
   virtual uint64_t NativeState() override;
   virtual Relation RelationByType(RelationType aType) override;
 
   void UpdateLabelValue(const nsString& aValue);
 
 protected:
   // Accessible
   virtual ENameValueFlag NativeName(nsString& aName) override;
@@ -54,44 +54,44 @@ class XULLabelTextLeafAccessible final :
 public:
   XULLabelTextLeafAccessible(nsIContent* aContent, DocAccessible* aDoc) :
     TextLeafAccessibleWrap(aContent, aDoc)
   { mStateFlags |= eSharedNode; }
 
   virtual ~XULLabelTextLeafAccessible() { }
 
   // Accessible
-  virtual a11y::role NativeRole() override;
+  virtual a11y::role NativeRole() const override;
   virtual uint64_t NativeState() override;
 };
 
 
 /**
  * Used for XUL tooltip element.
  */
 class XULTooltipAccessible : public LeafAccessible
 {
 
 public:
   XULTooltipAccessible(nsIContent* aContent, DocAccessible* aDoc);
 
   // Accessible
-  virtual a11y::role NativeRole() override;
+  virtual a11y::role NativeRole() const override;
   virtual uint64_t NativeState() override;
 };
 
 class XULLinkAccessible : public XULLabelAccessible
 {
 
 public:
   XULLinkAccessible(nsIContent* aContent, DocAccessible* aDoc);
 
   // Accessible
   virtual void Value(nsString& aValue) override;
-  virtual a11y::role NativeRole() override;
+  virtual a11y::role NativeRole() const override;
   virtual uint64_t NativeLinkState() const override;
 
   // ActionAccessible
   virtual uint8_t ActionCount() override;
   virtual void ActionNameAt(uint8_t aIndex, nsAString& aName) override;
   virtual bool DoAction(uint8_t aIndex) override;
 
   // HyperLinkAccessible

--- a/accessible/xul/XULFormControlAccessible.cpp
+++ b/accessible/xul/XULFormControlAccessible.cpp
@@ -77,17 +77,17 @@ XULButtonAccessible::DoAction(uint8_t aI
   DoCommand();
   return true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // XULButtonAccessible: Accessible
 
 role
-XULButtonAccessible::NativeRole()
+XULButtonAccessible::NativeRole() const
 {
   return roles::PUSHBUTTON;
 }
 
 uint64_t
 XULButtonAccessible::NativeState()
 {
   // Possible states: focused, focusable, unavailable(disabled).
@@ -259,17 +259,17 @@ XULDropmarkerAccessible::DoAction(uint8_
   if (index == eAction_Click) {
     DropmarkerOpen(true); // Reverse the open attribute
     return true;
   }
   return false;
 }
 
 role
-XULDropmarkerAccessible::NativeRole()
+XULDropmarkerAccessible::NativeRole() const
 {
   return roles::PUSHBUTTON;
 }
 
 uint64_t
 XULDropmarkerAccessible::NativeState()
 {
   return DropmarkerOpen(false) ? states::PRESSED : 0;
@@ -281,17 +281,17 @@ XULDropmarkerAccessible::NativeState()
 
 XULCheckboxAccessible::
   XULCheckboxAccessible(nsIContent* aContent, DocAccessible* aDoc) :
   LeafAccessible(aContent, aDoc)
 {
 }
 
 role
-XULCheckboxAccessible::NativeRole()
+XULCheckboxAccessible::NativeRole() const
 {
   return roles::CHECKBUTTON;
 }
 
 uint8_t
 XULCheckboxAccessible::ActionCount()
 {
   return 1;
@@ -347,17 +347,17 @@ XULCheckboxAccessible::NativeState()
 
 XULGroupboxAccessible::
   XULGroupboxAccessible(nsIContent* aContent, DocAccessible* aDoc) :
   AccessibleWrap(aContent, aDoc)
 {
 }
 
 role
-XULGroupboxAccessible::NativeRole()
+XULGroupboxAccessible::NativeRole() const
 {
   return roles::GROUPING;
 }
 
 ENameValueFlag
 XULGroupboxAccessible::NativeName(nsString& aName)
 {
   // XXX: we use the first related accessible only.
@@ -457,17 +457,17 @@ XULRadioButtonAccessible::ContainerWidge
 
 XULRadioGroupAccessible::
   XULRadioGroupAccessible(nsIContent* aContent, DocAccessible* aDoc) :
   XULSelectControlAccessible(aContent, aDoc)
 {
 }
 
 role
-XULRadioGroupAccessible::NativeRole()
+XULRadioGroupAccessible::NativeRole() const
 {
   return roles::RADIO_GROUP;
 }
 
 uint64_t
 XULRadioGroupAccessible::NativeInteractiveState() const
 {
   // The radio group is not focusable. Sometimes the focus controller will
@@ -504,17 +504,17 @@ XULRadioGroupAccessible::AreItemsOperabl
 
 XULStatusBarAccessible::
   XULStatusBarAccessible(nsIContent* aContent, DocAccessible* aDoc) :
   AccessibleWrap(aContent, aDoc)
 {
 }
 
 role
-XULStatusBarAccessible::NativeRole()
+XULStatusBarAccessible::NativeRole() const
 {
   return roles::STATUSBAR;
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // XULToolbarButtonAccessible
 ////////////////////////////////////////////////////////////////////////////////
@@ -573,17 +573,17 @@ XULToolbarButtonAccessible::IsSeparator(
 
 XULToolbarAccessible::
   XULToolbarAccessible(nsIContent* aContent, DocAccessible* aDoc) :
   AccessibleWrap(aContent, aDoc)
 {
 }
 
 role
-XULToolbarAccessible::NativeRole()
+XULToolbarAccessible::NativeRole() const
 {
   return roles::TOOLBAR;
 }
 
 ENameValueFlag
 XULToolbarAccessible::NativeName(nsString& aName)
 {
   if (mContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::toolbarname, aName))
@@ -599,17 +599,17 @@ XULToolbarAccessible::NativeName(nsStrin
 
 XULToolbarSeparatorAccessible::
   XULToolbarSeparatorAccessible(nsIContent* aContent, DocAccessible* aDoc) :
   LeafAccessible(aContent, aDoc)
 {
 }
 
 role
-XULToolbarSeparatorAccessible::NativeRole()
+XULToolbarSeparatorAccessible::NativeRole() const
 {
   return roles::SEPARATOR;
 }
 
 uint64_t
 XULToolbarSeparatorAccessible::NativeState()
 {
   return 0;

--- a/accessible/xul/XULFormControlAccessible.h
+++ b/accessible/xul/XULFormControlAccessible.h
@@ -31,17 +31,17 @@ class XULButtonAccessible : public Acces
 public:
   enum { eAction_Click = 0 };
   XULButtonAccessible(nsIContent* aContent, DocAccessible* aDoc);
 
   // nsISupports
   NS_INLINE_DECL_REFCOUNTING_INHERITED(XULButtonAccessible, AccessibleWrap)
 
   // Accessible
-  virtual mozilla::a11y::role NativeRole() override;
+  virtual mozilla::a11y::role NativeRole() const override;
   virtual uint64_t NativeState() override;
 
   // ActionAccessible
   virtual uint8_t ActionCount() override;
   virtual void ActionNameAt(uint8_t aIndex, nsAString& aName) override;
   virtual bool DoAction(uint8_t aIndex) override;
 
   // Widgets
@@ -65,17 +65,17 @@ protected:
  */
 class XULCheckboxAccessible : public LeafAccessible
 {
 public:
   enum { eAction_Click = 0 };
   XULCheckboxAccessible(nsIContent* aContent, DocAccessible* aDoc);
 
   // Accessible
-  virtual mozilla::a11y::role NativeRole() override;
+  virtual mozilla::a11y::role NativeRole() const override;
   virtual uint64_t NativeState() override;
 
   // ActionAccessible
   virtual uint8_t ActionCount() override;
   virtual void ActionNameAt(uint8_t aIndex, nsAString& aName) override;
   virtual bool DoAction(uint8_t aIndex) override;
 };
 
@@ -84,17 +84,17 @@ public:
  */
 class XULDropmarkerAccessible : public LeafAccessible
 {
 public:
   enum { eAction_Click = 0 };
   XULDropmarkerAccessible(nsIContent* aContent, DocAccessible* aDoc);
 
   // Accessible
-  virtual mozilla::a11y::role NativeRole() override;
+  virtual mozilla::a11y::role NativeRole() const override;
   virtual uint64_t NativeState() override;
 
   // ActionAccessible
   virtual uint8_t ActionCount() override;
   virtual void ActionNameAt(uint8_t aIndex, nsAString& aName) override;
   virtual bool DoAction(uint8_t aIndex) override;
 
 private:
@@ -105,17 +105,17 @@ private:
  * Used for XUL groupbox element.
  */
 class XULGroupboxAccessible final : public AccessibleWrap
 {
 public:
   XULGroupboxAccessible(nsIContent* aContent, DocAccessible* aDoc);
 
   // Accessible
-  virtual mozilla::a11y::role NativeRole() override;
+  virtual mozilla::a11y::role NativeRole() const override;
   virtual Relation RelationByType(RelationType aType) override;
 
 protected:
   // Accessible
   virtual ENameValueFlag NativeName(nsString& aName) override;
 };
 
 /**
@@ -139,17 +139,17 @@ public:
  * Used for XUL radiogroup element.
  */
 class XULRadioGroupAccessible : public XULSelectControlAccessible
 {
 public:
   XULRadioGroupAccessible(nsIContent* aContent, DocAccessible* aDoc);
 
   // Accessible
-  virtual mozilla::a11y::role NativeRole() override;
+  virtual mozilla::a11y::role NativeRole() const override;
   virtual uint64_t NativeInteractiveState() const override;
 
   // Widgets
   virtual bool IsWidget() const override;
   virtual bool IsActiveWidget() const override;
   virtual bool AreItemsOperable() const override;
 };
 
@@ -157,17 +157,17 @@ public:
  * Used for XUL statusbar element.
  */
 class XULStatusBarAccessible : public AccessibleWrap
 {
 public:
   XULStatusBarAccessible(nsIContent* aContent, DocAccessible* aDoc);
 
   // Accessible
-  virtual mozilla::a11y::role NativeRole() override;
+  virtual mozilla::a11y::role NativeRole() const override;
 };
 
 /**
  * Used for XUL toolbarbutton element.
  */
 class XULToolbarButtonAccessible : public XULButtonAccessible
 {
 public:
@@ -185,34 +185,34 @@ public:
  * Used for XUL toolbar element.
  */
 class XULToolbarAccessible : public AccessibleWrap
 {
 public:
   XULToolbarAccessible(nsIContent* aContent, DocAccessible* aDoc);
 
   // Accessible
-  virtual mozilla::a11y::role NativeRole() override;
+  virtual mozilla::a11y::role NativeRole() const override;
 
 protected:
   // Accessible
   virtual ENameValueFlag NativeName(nsString& aName) override;
 };
 
 /**
  * Used for XUL toolbarseparator element.
  */
 class XULToolbarSeparatorAccessible : public LeafAccessible
 {
 public:
   XULToolbarSeparatorAccessible(nsIContent* aContent,
                                 DocAccessible* aDoc);
 
   // Accessible
-  virtual mozilla::a11y::role NativeRole() override;
+  virtual mozilla::a11y::role NativeRole() const override;
   virtual uint64_t NativeState() override;
 };
 
 } // namespace a11y
 } // namespace mozilla
 
 #endif
 

--- a/accessible/xul/XULListboxAccessible.cpp
+++ b/accessible/xul/XULListboxAccessible.cpp
@@ -30,17 +30,17 @@ using namespace mozilla::a11y;
 
 XULColumAccessible::
   XULColumAccessible(nsIContent* aContent, DocAccessible* aDoc) :
   AccessibleWrap(aContent, aDoc)
 {
 }
 
 role
-XULColumAccessible::NativeRole()
+XULColumAccessible::NativeRole() const
 {
   return roles::LIST;
 }
 
 uint64_t
 XULColumAccessible::NativeState()
 {
   return states::READONLY;
@@ -53,17 +53,17 @@ XULColumAccessible::NativeState()
 
 XULColumnItemAccessible::
   XULColumnItemAccessible(nsIContent* aContent, DocAccessible* aDoc) :
   LeafAccessible(aContent, aDoc)
 {
 }
 
 role
-XULColumnItemAccessible::NativeRole()
+XULColumnItemAccessible::NativeRole() const
 {
   return roles::COLUMNHEADER;
 }
 
 uint64_t
 XULColumnItemAccessible::NativeState()
 {
   return states::READONLY;
@@ -147,17 +147,17 @@ XULListboxAccessible::Value(nsString& aV
     nsCOMPtr<nsIDOMXULSelectControlItemElement> selectedItem;
     select->GetSelectedItem(getter_AddRefs(selectedItem));
     if (selectedItem)
       selectedItem->GetLabel(aValue);
   }
 }
 
 role
-XULListboxAccessible::NativeRole()
+XULListboxAccessible::NativeRole() const
 {
   // A richlistbox is used with the new autocomplete URL bar, and has a parent
   // popup <panel>.
   if (mContent->GetParent() && mContent->GetParent()->IsXULElement(nsGkAtoms::panel))
     return roles::COMBOBOX_LIST;
 
   return IsMulticolumn() ? roles::TABLE : roles::LISTBOX;
 }
@@ -587,17 +587,17 @@ XULListitemAccessible::NativeName(nsStri
       return eNameOK;
     }
   }
 
   return Accessible::NativeName(aName);
 }
 
 role
-XULListitemAccessible::NativeRole()
+XULListitemAccessible::NativeRole() const
 {
   Accessible* list = GetListAccessible();
   if (!list) {
     NS_ERROR("No list accessible for listitem accessible!");
     return roles::NOTHING;
   }
 
   if (list->Role() == roles::TABLE)
@@ -779,17 +779,17 @@ XULListCellAccessible::Selected()
 
   return table->IsRowSelected(RowIdx());
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // XULListCellAccessible. Accessible implementation
 
 role
-XULListCellAccessible::NativeRole()
+XULListCellAccessible::NativeRole() const
 {
   return roles::CELL;
 }
 
 already_AddRefed<nsIPersistentProperties>
 XULListCellAccessible::NativeAttributes()
 {
   nsCOMPtr<nsIPersistentProperties> attributes =

--- a/accessible/xul/XULListboxAccessible.h
+++ b/accessible/xul/XULListboxAccessible.h
@@ -22,31 +22,31 @@ namespace a11y {
  * (xul:treecols and xul:listcols).
  */
 class XULColumAccessible : public AccessibleWrap
 {
 public:
   XULColumAccessible(nsIContent* aContent, DocAccessible* aDoc);
 
   // Accessible
-  virtual a11y::role NativeRole() override;
+  virtual a11y::role NativeRole() const override;
   virtual uint64_t NativeState() override;
 };
 
 /**
  * XULColumnItemAccessible are accessibles for list and tree column elements
  * (xul:listcol and xul:treecol).
  */
 class XULColumnItemAccessible : public LeafAccessible
 {
 public:
   XULColumnItemAccessible(nsIContent* aContent, DocAccessible* aDoc);
 
   // Accessible
-  virtual a11y::role NativeRole() override;
+  virtual a11y::role NativeRole() const override;
   virtual uint64_t NativeState() override;
 
   // ActionAccessible
   virtual uint8_t ActionCount() override;
   virtual void ActionNameAt(uint8_t aIndex, nsAString& aName) override;
   virtual bool DoAction(uint8_t aIndex) override;
 
   enum { eAction_Click = 0 };
@@ -77,17 +77,17 @@ public:
   virtual void SelectedRowIndices(nsTArray<uint32_t>* aRows) override;
   virtual void SelectRow(uint32_t aRowIdx) override;
   virtual void UnselectRow(uint32_t aRowIdx) override;
   virtual Accessible* AsAccessible() override { return this; }
 
   // Accessible
   virtual void Value(nsString& aValue) override;
   virtual TableAccessible* AsTable() override { return this; }
-  virtual a11y::role NativeRole() override;
+  virtual a11y::role NativeRole() const override;
   virtual uint64_t NativeState() override;
 
   // Widgets
   virtual bool IsWidget() const override;
   virtual bool IsActiveWidget() const override;
   virtual bool AreItemsOperable() const override;
 
   virtual Accessible* ContainerWidget() const override;
@@ -108,17 +108,17 @@ public:
 
   NS_INLINE_DECL_REFCOUNTING_INHERITED(XULListitemAccessible,
                                        XULMenuitemAccessible)
 
   XULListitemAccessible(nsIContent* aContent, DocAccessible* aDoc);
 
   // Accessible
   virtual void Description(nsString& aDesc) override;
-  virtual a11y::role NativeRole() override;
+  virtual a11y::role NativeRole() const override;
   virtual uint64_t NativeState() override;
   virtual uint64_t NativeInteractiveState() const override;
 
   // Actions
   virtual void ActionNameAt(uint8_t index, nsAString& aName) override;
 
   // Widgets
   virtual Accessible* ContainerWidget() const override;
@@ -151,17 +151,17 @@ public:
 
   // nsISupports
   NS_INLINE_DECL_REFCOUNTING_INHERITED(XULListCellAccessible,
                                        HyperTextAccessibleWrap)
 
   // Accessible
   virtual TableCellAccessible* AsTableCell() override { return this; }
   virtual already_AddRefed<nsIPersistentProperties> NativeAttributes() override;
-  virtual a11y::role NativeRole() override;
+  virtual a11y::role NativeRole() const override;
 
   // TableCellAccessible
   virtual TableAccessible* Table() const override;
   virtual uint32_t ColIdx() const override;
   virtual uint32_t RowIdx() const override;
   virtual void ColHeaderCells(nsTArray<Accessible*>* aHeaderCells) override;
   virtual bool Selected() override;
 

--- a/accessible/xul/XULMenuAccessible.cpp
+++ b/accessible/xul/XULMenuAccessible.cpp
@@ -237,17 +237,17 @@ XULMenuitemAccessible::KeyboardShortcut(
   if (modifiersStr.Find("accel") != -1) {
     modifierMask |= KeyBinding::AccelModifier();
   }
 
   return KeyBinding(key, modifierMask);
 }
 
 role
-XULMenuitemAccessible::NativeRole()
+XULMenuitemAccessible::NativeRole() const
 {
   nsCOMPtr<nsIDOMXULContainerElement> xulContainer(do_QueryInterface(mContent));
   if (xulContainer)
     return roles::PARENT_MENUITEM;
 
   if (mParent && mParent->Role() == roles::COMBOBOX_LIST)
     return roles::COMBOBOX_OPTION;
 
@@ -363,17 +363,17 @@ XULMenuSeparatorAccessible::NativeState(
 
 ENameValueFlag
 XULMenuSeparatorAccessible::NativeName(nsString& aName)
 {
   return eNameOK;
 }
 
 role
-XULMenuSeparatorAccessible::NativeRole()
+XULMenuSeparatorAccessible::NativeRole() const
 {
   return roles::SEPARATOR;
 }
 
 bool
 XULMenuSeparatorAccessible::DoAction(uint8_t index)
 {
   return false;
@@ -449,17 +449,17 @@ XULMenupopupAccessible::NativeName(nsStr
     }
     content = content->GetFlattenedTreeParent();
   }
 
   return eNameOK;
 }
 
 role
-XULMenupopupAccessible::NativeRole()
+XULMenupopupAccessible::NativeRole() const
 {
   // If accessible is not bound to the tree (this happens while children are
   // cached) return general role.
   if (mParent) {
     if (mParent->IsCombobox() || mParent->IsAutoComplete())
       return roles::COMBOBOX_LIST;
 
     if (mParent->Role() == roles::PUSHBUTTON) {
@@ -546,17 +546,17 @@ XULMenubarAccessible::
 ENameValueFlag
 XULMenubarAccessible::NativeName(nsString& aName)
 {
   aName.AssignLiteral("Application");
   return eNameOK;
 }
 
 role
-XULMenubarAccessible::NativeRole()
+XULMenubarAccessible::NativeRole() const
 {
   return roles::MENUBAR;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // XULMenubarAccessible: Widgets
 
 bool

--- a/accessible/xul/XULMenuAccessible.h
+++ b/accessible/xul/XULMenuAccessible.h
@@ -20,17 +20,17 @@ class XULMenuitemAccessible : public Acc
 {
 public:
   enum { eAction_Click = 0 };
 
   XULMenuitemAccessible(nsIContent* aContent, DocAccessible* aDoc);
 
   // Accessible
   virtual void Description(nsString& aDescription) override;
-  virtual a11y::role NativeRole() override;
+  virtual a11y::role NativeRole() const override;
   virtual uint64_t NativeState() override;
   virtual uint64_t NativeInteractiveState() const override;
   virtual int32_t GetLevelInternal() override;
 
   // ActionAccessible
   virtual uint8_t ActionCount() override;
   virtual void ActionNameAt(uint8_t aIndex, nsAString& aName) override;
   virtual bool DoAction(uint8_t aIndex) override;
@@ -51,17 +51,17 @@ protected:
  * Used for XUL menuseparator element.
  */
 class XULMenuSeparatorAccessible : public XULMenuitemAccessible
 {
 public:
   XULMenuSeparatorAccessible(nsIContent* aContent, DocAccessible* aDoc);
 
   // Accessible
-  virtual a11y::role NativeRole() override;
+  virtual a11y::role NativeRole() const override;
   virtual uint64_t NativeState() override;
 
   // ActionAccessible
   virtual uint8_t ActionCount() override;
   virtual void ActionNameAt(uint8_t aIndex, nsAString& aName) override;
   virtual bool DoAction(uint8_t aIndex) override;
 
 protected:
@@ -74,17 +74,17 @@ protected:
  * Used for XUL menupopup and panel.
  */
 class XULMenupopupAccessible : public XULSelectControlAccessible
 {
 public:
   XULMenupopupAccessible(nsIContent* aContent, DocAccessible* aDoc);
 
   // Accessible
-  virtual a11y::role NativeRole() override;
+  virtual a11y::role NativeRole() const override;
   virtual uint64_t NativeState() override;
 
   // Widgets
   virtual bool IsWidget() const override;
   virtual bool IsActiveWidget() const override;
   virtual bool AreItemsOperable() const override;
 
   virtual Accessible* ContainerWidget() const override;
@@ -98,17 +98,17 @@ protected:
  * Used for XUL menubar element.
  */
 class XULMenubarAccessible : public AccessibleWrap
 {
 public:
   XULMenubarAccessible(nsIContent* aContent, DocAccessible* aDoc);
 
   // Accessible
-  virtual a11y::role NativeRole() override;
+  virtual a11y::role NativeRole() const override;
 
   // Widget
   virtual bool IsActiveWidget() const override;
   virtual bool AreItemsOperable() const override;
   virtual Accessible* CurrentItem() override;
   virtual void SetCurrentItem(Accessible* aItem) override;
 
 protected:

--- a/accessible/xul/XULSliderAccessible.cpp
+++ b/accessible/xul/XULSliderAccessible.cpp
@@ -25,17 +25,17 @@ XULSliderAccessible::
   AccessibleWrap(aContent, aDoc)
 {
   mStateFlags |= eHasNumericValue | eNoXBLKids;
 }
 
 // Accessible
 
 role
-XULSliderAccessible::NativeRole()
+XULSliderAccessible::NativeRole() const
 {
   return roles::SLIDER;
 }
 
 uint64_t
 XULSliderAccessible::NativeInteractiveState() const
  {
   if (NativelyUnavailable())
@@ -202,15 +202,15 @@ XULThumbAccessible::
   AccessibleWrap(aContent, aDoc)
 {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // XULThumbAccessible: Accessible
 
 role
-XULThumbAccessible::NativeRole()
+XULThumbAccessible::NativeRole() const
 {
   return roles::INDICATOR;
 }
 
 }
 }

--- a/accessible/xul/XULSliderAccessible.h
+++ b/accessible/xul/XULSliderAccessible.h
@@ -16,17 +16,17 @@ namespace a11y {
  */
 class XULSliderAccessible : public AccessibleWrap
 {
 public:
   XULSliderAccessible(nsIContent* aContent, DocAccessible* aDoc);
 
   // Accessible
   virtual void Value(nsString& aValue) override;
-  virtual a11y::role NativeRole() override;
+  virtual a11y::role NativeRole() const override;
   virtual uint64_t NativeInteractiveState() const override;
   virtual bool NativelyUnavailable() const override;
 
   // Value
   virtual double MaxValue() const override;
   virtual double MinValue() const override;
   virtual double CurValue() const override;
   virtual double Step() const override;
@@ -58,16 +58,16 @@ private:
  * Used for slider's thumb element.
  */
 class XULThumbAccessible : public AccessibleWrap
 {
 public:
   XULThumbAccessible(nsIContent* aContent, DocAccessible* aDoc);
 
   // Accessible
-  virtual a11y::role NativeRole() override;
+  virtual a11y::role NativeRole() const override;
 };
 
 } // namespace a11y
 } // namespace mozilla
 
 #endif
 

--- a/accessible/xul/XULTabAccessible.cpp
+++ b/accessible/xul/XULTabAccessible.cpp
@@ -60,17 +60,17 @@ XULTabAccessible::DoAction(uint8_t index
   }
   return false;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // XULTabAccessible: Accessible
 
 role
-XULTabAccessible::NativeRole()
+XULTabAccessible::NativeRole() const
 {
   return roles::PAGETAB;
 }
 
 uint64_t
 XULTabAccessible::NativeState()
 {
   // Possible states: focused, focusable, unavailable(disabled), offscreen.
@@ -132,17 +132,17 @@ XULTabAccessible::RelationByType(Relatio
 
 XULTabsAccessible::
   XULTabsAccessible(nsIContent* aContent, DocAccessible* aDoc) :
   XULSelectControlAccessible(aContent, aDoc)
 {
 }
 
 role
-XULTabsAccessible::NativeRole()
+XULTabsAccessible::NativeRole() const
 {
   return roles::PAGETABLIST;
 }
 
 uint8_t
 XULTabsAccessible::ActionCount()
 {
   return 0;
@@ -162,33 +162,33 @@ XULTabsAccessible::NativeName(nsString& 
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // XULTabpanelsAccessible
 ////////////////////////////////////////////////////////////////////////////////
 
 role
-XULTabpanelsAccessible::NativeRole()
+XULTabpanelsAccessible::NativeRole() const
 {
   return roles::PANE;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // XULTabpanelAccessible
 ////////////////////////////////////////////////////////////////////////////////
 
 XULTabpanelAccessible::
   XULTabpanelAccessible(nsIContent* aContent, DocAccessible* aDoc) :
   AccessibleWrap(aContent, aDoc)
 {
 }
 
 role
-XULTabpanelAccessible::NativeRole()
+XULTabpanelAccessible::NativeRole() const
 {
   return roles::PROPERTYPAGE;
 }
 
 Relation
 XULTabpanelAccessible::RelationByType(RelationType aType)
 {
   Relation rel = AccessibleWrap::RelationByType(aType);

--- a/accessible/xul/XULTabAccessible.h
+++ b/accessible/xul/XULTabAccessible.h
@@ -20,17 +20,17 @@ namespace a11y {
 class XULTabAccessible : public HyperTextAccessibleWrap
 {
 public:
   enum { eAction_Switch = 0 };
 
   XULTabAccessible(nsIContent* aContent, DocAccessible* aDoc);
 
   // Accessible
-  virtual a11y::role NativeRole() override;
+  virtual a11y::role NativeRole() const override;
   virtual uint64_t NativeState() override;
   virtual uint64_t NativeInteractiveState() const override;
   virtual Relation RelationByType(RelationType aType) override;
 
   // ActionAccessible
   virtual uint8_t ActionCount() override;
   virtual void ActionNameAt(uint8_t aIndex, nsAString& aName) override;
   virtual bool DoAction(uint8_t aIndex) override;
@@ -42,17 +42,17 @@ public:
  */
 class XULTabsAccessible : public XULSelectControlAccessible
 {
 public:
   XULTabsAccessible(nsIContent* aContent, DocAccessible* aDoc);
 
   // Accessible
   virtual void Value(nsString& aValue) override;
-  virtual a11y::role NativeRole() override;
+  virtual a11y::role NativeRole() const override;
 
   // ActionAccessible
   virtual uint8_t ActionCount() override;
 
 protected:
   // Accessible
   virtual ENameValueFlag NativeName(nsString& aName) override;
 };
@@ -64,34 +64,34 @@ protected:
 class XULTabpanelsAccessible : public AccessibleWrap
 {
 public:
   XULTabpanelsAccessible(nsIContent* aContent, DocAccessible* aDoc) :
     AccessibleWrap(aContent, aDoc)
     { mType = eXULTabpanelsType; }
 
   // Accessible
-  virtual a11y::role NativeRole() override;
+  virtual a11y::role NativeRole() const override;
 };
 
 
 /**
  * A tabpanel object, child elements of xul:tabpanels element.
  *
  * XXX: we need to move the class logic into generic class since
  * for example we do not create instance of this class for XUL textbox used as
  * a tabpanel.
  */
 class XULTabpanelAccessible : public AccessibleWrap
 {
 public:
   XULTabpanelAccessible(nsIContent* aContent, DocAccessible* aDoc);
 
   // Accessible
-  virtual a11y::role NativeRole() override;
+  virtual a11y::role NativeRole() const override;
   virtual Relation RelationByType(RelationType aType) override;
 };
 
 } // namespace a11y
 } // namespace mozilla
 
 #endif
 

--- a/accessible/xul/XULTreeAccessible.cpp
+++ b/accessible/xul/XULTreeAccessible.cpp
@@ -148,17 +148,17 @@ XULTreeAccessible::Shutdown()
 
   mTree = nullptr;
   mTreeView = nullptr;
 
   AccessibleWrap::Shutdown();
 }
 
 role
-XULTreeAccessible::NativeRole()
+XULTreeAccessible::NativeRole() const
 {
   // No primary column means we're in a list. In fact, history and mail turn off
   // the primary flag when switching to a flat view.
 
   nsIContent* child = nsTreeUtils::GetDescendantChild(mContent, nsGkAtoms::treechildren);
   NS_ASSERTION(child, "tree without treechildren!");
   nsTreeBodyFrame* treeFrame = do_QueryFrame(child->GetPrimaryFrame());
   NS_ASSERTION(treeFrame, "xul tree accessible for tree without a frame!");
@@ -1113,17 +1113,17 @@ XULTreeItemAccessible::Name(nsString& aN
 void
 XULTreeItemAccessible::Shutdown()
 {
   mColumn = nullptr;
   XULTreeItemAccessibleBase::Shutdown();
 }
 
 role
-XULTreeItemAccessible::NativeRole()
+XULTreeItemAccessible::NativeRole() const
 {
   nsCOMPtr<nsITreeColumns> columns;
   mTree->GetColumns(getter_AddRefs(columns));
   if (!columns) {
     NS_ERROR("No tree columns object in the tree!");
     return roles::NOTHING;
   }
 

--- a/accessible/xul/XULTreeAccessible.h
+++ b/accessible/xul/XULTreeAccessible.h
@@ -36,17 +36,17 @@ public:
 
   // nsISupports and cycle collection
   NS_DECL_ISUPPORTS_INHERITED
   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(XULTreeAccessible, Accessible)
 
   // Accessible
   virtual void Shutdown() override;
   virtual void Value(nsString& aValue) override;
-  virtual a11y::role NativeRole() override;
+  virtual a11y::role NativeRole() const override;
   virtual uint64_t NativeState() override;
   virtual Accessible* ChildAtPoint(int32_t aX, int32_t aY,
                                    EWhichChildAtPoint aWhichChild) override;
 
   virtual Accessible* GetChildAt(uint32_t aIndex) const override;
   virtual uint32_t ChildCount() const override;
   virtual Relation RelationByType(RelationType aType) override;
 
@@ -230,17 +230,17 @@ public:
   // nsISupports and cycle collection
   NS_DECL_ISUPPORTS_INHERITED
   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(XULTreeItemAccessible,
                                            XULTreeItemAccessibleBase)
 
   // Accessible
   virtual void Shutdown() override;
   virtual ENameValueFlag Name(nsString& aName) override;
-  virtual a11y::role NativeRole() override;
+  virtual a11y::role NativeRole() const override;
 
   // XULTreeItemAccessibleBase
   virtual void RowInvalidated(int32_t aStartColIdx, int32_t aEndColIdx) override;
 
 protected:
   virtual ~XULTreeItemAccessible();
 
   // XULTreeItemAccessible

--- a/accessible/xul/XULTreeGridAccessible.cpp
+++ b/accessible/xul/XULTreeGridAccessible.cpp
@@ -204,17 +204,17 @@ XULTreeGridAccessible::UnselectRow(uint3
   if (selection)
     selection->ClearRange(aRowIdx, aRowIdx);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // XULTreeGridAccessible: Accessible implementation
 
 role
-XULTreeGridAccessible::NativeRole()
+XULTreeGridAccessible::NativeRole() const
 {
   nsCOMPtr<nsITreeColumns> treeColumns;
   mTree->GetColumns(getter_AddRefs(treeColumns));
   if (!treeColumns) {
     NS_ERROR("No treecolumns object for tree!");
     return roles::NOTHING;
   }
 
@@ -282,17 +282,17 @@ XULTreeGridRowAccessible::Shutdown()
   if (mDoc && !mDoc->IsDefunct()) {
     UnbindCacheEntriesFromDocument(mAccessibleCache);
   }
 
   XULTreeItemAccessibleBase::Shutdown();
 }
 
 role
-XULTreeGridRowAccessible::NativeRole()
+XULTreeGridRowAccessible::NativeRole() const
 {
   return roles::ROW;
 }
 
 ENameValueFlag
 XULTreeGridRowAccessible::Name(nsString& aName)
 {
   aName.Truncate();
@@ -677,17 +677,17 @@ XULTreeGridCellAccessible::NativeAttribu
   if (NS_SUCCEEDED(rv) && isCycler)
     nsAccUtils::SetAccAttr(attributes, nsGkAtoms::cycles,
                            NS_LITERAL_STRING("true"));
 
   return attributes.forget();
 }
 
 role
-XULTreeGridCellAccessible::NativeRole()
+XULTreeGridCellAccessible::NativeRole() const
 {
   return roles::GRID_CELL;
 }
 
 uint64_t
 XULTreeGridCellAccessible::NativeState()
 {
   if (!mTreeView)

--- a/accessible/xul/XULTreeGridAccessible.h
+++ b/accessible/xul/XULTreeGridAccessible.h
@@ -45,17 +45,17 @@ public:
   virtual void SelectedColIndices(nsTArray<uint32_t>* aCols) override;
   virtual void SelectedRowIndices(nsTArray<uint32_t>* aRows) override;
   virtual void SelectRow(uint32_t aRowIdx) override;
   virtual void UnselectRow(uint32_t aRowIdx) override;
   virtual Accessible* AsAccessible() override { return this; }
 
   // Accessible
   virtual TableAccessible* AsTable() override { return this; }
-  virtual a11y::role NativeRole() override;
+  virtual a11y::role NativeRole() const override;
 
 protected:
   virtual ~XULTreeGridAccessible();
 
   // XULTreeAccessible
   virtual already_AddRefed<Accessible>
     CreateTreeItemAccessible(int32_t aRow) const override;
 };
@@ -76,17 +76,17 @@ public:
 
   // nsISupports and cycle collection
   NS_DECL_ISUPPORTS_INHERITED
   NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(XULTreeGridRowAccessible,
                                            XULTreeItemAccessibleBase)
 
   // Accessible
   virtual void Shutdown() override;
-  virtual a11y::role NativeRole() override;
+  virtual a11y::role NativeRole() const override;
   virtual ENameValueFlag Name(nsString& aName) override;
   virtual Accessible* ChildAtPoint(int32_t aX, int32_t aY,
                                    EWhichChildAtPoint aWhichChild) override;
 
   virtual Accessible* GetChildAt(uint32_t aIndex) const override;
   virtual uint32_t ChildCount() const override;
 
   // XULTreeItemAccessibleBase
@@ -128,17 +128,17 @@ public:
   virtual TableCellAccessible* AsTableCell() override { return this; }
   virtual nsRect BoundsInAppUnits() const override;
   virtual nsIntRect BoundsInCSSPixels() const override;
   virtual ENameValueFlag Name(nsString& aName) override;
   virtual Accessible* FocusedChild() override;
   virtual already_AddRefed<nsIPersistentProperties> NativeAttributes() override;
   virtual int32_t IndexInParent() const override;
   virtual Relation RelationByType(RelationType aType) override;
-  virtual a11y::role NativeRole() override;
+  virtual a11y::role NativeRole() const override;
   virtual uint64_t NativeState() override;
   virtual uint64_t NativeInteractiveState() const override;
 
   // ActionAccessible
   virtual uint8_t ActionCount() override;
   virtual void ActionNameAt(uint8_t aIndex, nsAString& aName) override;
   virtual bool DoAction(uint8_t aIndex) override;
 

--- a/devtools/client/debugger/new/README.mozilla
+++ b/devtools/client/debugger/new/README.mozilla
@@ -1,13 +1,13 @@
 This is the debugger.html project output.
 See https://github.com/devtools-html/debugger.html
 
-Version 50
+Version 52
 
-Comparison: https://github.com/devtools-html/debugger.html/compare/release-49...release-50
+Comparison: https://github.com/devtools-html/debugger.html/compare/release-51...release-52
 
 Packages:
 - babel-plugin-transform-es2015-modules-commonjs @6.26.2
 - babel-preset-react @6.24.1
 - react @16.2.0
 - react-dom @16.2.0
 - webpack @3.11.0

--- a/devtools/client/debugger/new/dist/debugger.css
+++ b/devtools/client/debugger/new/dist/debugger.css
@@ -968,106 +968,103 @@ img.close::before {
 }
 
 .search-shadow.focused {
   box-shadow: var(--theme-focus-box-shadow-textbox);
 }
 
 .search-field {
   position: relative;
-
+  height: 27px;
   width: calc(100% - 1px);
   background-color: var(--theme-toolbar-background);
   border-bottom: 1px solid var(--theme-splitter-color);
-  padding: 5px 10px;
+  padding-right: 10px;
   display: flex;
   flex-shrink: 0;
 }
 
 .search-field.big {
+  padding: 5px 10px;
   height: 40px;
 }
 
 .search-field i {
   display: block;
   padding: 0;
   width: 16px;
 }
 
 .search-field i svg {
+  width: 16px;
+}
+
+.search-field.big i svg {
   width: 22px;
 }
 
-.search-field.big input {
-  line-height: 40px;
-}
-
 .search-field input {
-  position: relative;
-  margin-left: 30px;
   border: none;
   line-height: 30px;
   background-color: var(--theme-toolbar-background);
   color: var(--theme-body-color-active);
   width: calc(100% - 38px);
   flex: 1;
+}
+
+.search-field.big input {
+  position: relative;
+  margin-left: 30px;
   font-size: 14px;
+  line-height: 40px;
 }
 
 .search-field input:focus {
   outline: none;
 }
 
 .theme-dark .search-field input {
   color: var(--theme-body-color-inactive);
 }
 
 .search-field i.magnifying-glass,
 .search-field i.sad-face {
-  position: absolute;
-  top: 50%;
-  padding: 2px 0;
+  padding: 6px;
   width: 24px;
-  margin-top: -12px;
-}
-
-.search-field i.sad-face {
-  padding-top: 1px;
 }
 
 .search-field.big i.magnifying-glass,
 .search-field.big i.sad-face {
-  padding: 14px;
+  position: absolute;
   width: 40px;
-  margin-top: -20px;
 }
 
 .search-field .magnifying-glass path,
 .search-field .magnifying-glass ellipse {
   stroke: var(--theme-comment);
 }
 
 .search-field input::placeholder {
   color: var(--theme-toolbar-color);
 }
 
 .search-field input.empty {
   color: var(--theme-highlight-orange);
 }
 
-.search-field.big .summary {
-  line-height: 40px;
-}
-
 .search-field .summary {
   line-height: 27px;
   padding-right: 10px;
   color: var(--theme-body-color-inactive);
 }
 
+.search-field.big .summary {
+  line-height: 40px;
+}
+
 .search-field .search-nav-buttons {
   display: flex;
   user-select: none;
 }
 
 .search-field .search-nav-buttons .nav-btn {
   display: flex;
   height: 100%;
@@ -1864,17 +1861,17 @@ html .toggle-button.end.vertical svg {
 }
 
 .search-bar .search-field {
   padding-left: 7px;
   height: var(--editor-searchbar-height);
 }
 
 .search-field .close-btn {
-  margin-top: 12px;
+  align-self: center;
 }
 
 .search-bottom-bar * {
   -moz-user-select: none;
   user-select: none;
 }
 
 .search-bottom-bar {
@@ -2913,16 +2910,17 @@ debug-expression-error {
 }
 
 .breakpoints-list .breakpoint-heading,
 .breakpoints-list .breakpoint {
   font-size: 12px;
   color: var(--theme-content-color1);
   position: relative;
   transition: all 0.25s ease;
+  cursor: pointer;
 }
 
 .breakpoints-list .breakpoint-heading,
 .breakpoints-list .breakpoint,
 .breakpoints-exceptions {
   padding: 0.25em 1em;
 }
 
@@ -3082,17 +3080,17 @@ html[dir="rtl"] .breakpoints-list .break
   visibility: hidden;
 }
 
 .breakpoint:hover .close {
   visibility: visible;
 }
 
 .CodeMirror.cm-s-mozilla-breakpoint {
-  cursor: default;
+  cursor: pointer;
 }
 
 .CodeMirror.cm-s-mozilla-breakpoint .CodeMirror-lines {
   padding: 0;
 }
 
 .CodeMirror.cm-s-mozilla-breakpoint .CodeMirror-sizer {
   min-width: initial !important;

--- a/devtools/client/debugger/new/dist/parser-worker.js
+++ b/devtools/client/debugger/new/dist/parser-worker.js
@@ -24740,16 +24740,20 @@ const isReturn = node => t.isReturnState
 const isCall = node => t.isCallExpression(node) || t.isJSXElement(node);
 
 const inStepExpression = parent => t.isArrayExpression(parent) || t.isObjectProperty(parent) || t.isCallExpression(parent) || t.isJSXElement(parent);
 
 const inExpression = (parent, grandParent) => inStepExpression(parent) || t.isJSXAttribute(grandParent) || t.isTemplateLiteral(parent);
 
 const isExport = node => t.isExportNamedDeclaration(node) || t.isExportDefaultDeclaration(node);
 
+function getStartLine(node) {
+  return node.loc.start.line;
+}
+
 function getPausePoints(sourceId) {
   const state = {};
   (0, _ast.traverseAst)(sourceId, { enter: onEnter }, state);
   return state;
 }
 
 /* eslint-disable complexity */
 function onEnter(node, ancestors, state) {
@@ -24776,20 +24780,22 @@ function onEnter(node, ancestors, state)
     return;
   }
 
   if (t.isBlockStatement(node)) {
     return addEmptyPoint(state, startLocation);
   }
 
   if (isReturn(node)) {
-    // We do not want to pause at the return and the call e.g. return foo()
-    if (isCall(node.argument)) {
+    // We do not want to pause at the return if the
+    // argument is a call on the same line e.g. return foo()
+    if (isCall(node.argument) && getStartLine(node) == getStartLine(node.argument)) {
       return addEmptyPoint(state, startLocation);
     }
+
     return addStopPoint(state, startLocation);
   }
 
   if (isAssignment(node)) {
     // We only want to pause at literal assignments `var a = foo()`
     const value = node.right || node.init;
 
     if (isCall(value) || t.isFunction(parentNode)) {

--- a/devtools/client/debugger/new/src/actions/ast.js
+++ b/devtools/client/debugger/new/src/actions/ast.js
@@ -107,21 +107,22 @@ function setPausePoints(sourceId) {
     client
   }) => {
     const source = (0, _selectors.getSource)(getState(), sourceId);
 
     if (!_prefs.features.pausePoints || !source || !source.text || source.isWasm) {
       return;
     }
 
-    const pausePoints = await (0, _parser.getPausePoints)(source.id);
+    const pausePoints = await (0, _parser.getPausePoints)(sourceId);
 
-    if ((0, _devtoolsSourceMap.isGeneratedId)(source.id)) {
-      await client.setPausePoints(source.id, pausePoints);
+    if ((0, _devtoolsSourceMap.isGeneratedId)(sourceId)) {
+      await client.setPausePoints(sourceId, pausePoints);
     }
 
     dispatch({
       type: "SET_PAUSE_POINTS",
-      source: source.toJS(),
+      sourceText: source.text,
+      sourceId,
       pausePoints
     });
   };
 }
\ No newline at end of file

--- a/devtools/client/debugger/new/src/actions/pause/breakOnNext.js
+++ b/devtools/client/debugger/new/src/actions/pause/breakOnNext.js
@@ -13,19 +13,18 @@ exports.breakOnNext = breakOnNext;
  * Debugger breakOnNext command.
  * It's different from the comand action because we also want to
  * highlight the pause icon.
  *
  * @memberof actions/pause
  * @static
  */
 function breakOnNext() {
-  return ({
+  return async ({
     dispatch,
     client
   }) => {
-    client.breakOnNext();
+    await client.breakOnNext();
     return dispatch({
-      type: "BREAK_ON_NEXT",
-      value: true
+      type: "BREAK_ON_NEXT"
     });
   };
 }
\ No newline at end of file

--- a/devtools/client/debugger/new/src/actions/pause/index.js
+++ b/devtools/client/debugger/new/src/actions/pause/index.js
@@ -137,16 +137,25 @@ var _pauseOnExceptions = require("./paus
 
 Object.defineProperty(exports, "pauseOnExceptions", {
   enumerable: true,
   get: function () {
     return _pauseOnExceptions.pauseOnExceptions;
   }
 });
 
+var _selectComponent = require("./selectComponent");
+
+Object.defineProperty(exports, "selectComponent", {
+  enumerable: true,
+  get: function () {
+    return _selectComponent.selectComponent;
+  }
+});
+
 var _selectFrame = require("./selectFrame");
 
 Object.defineProperty(exports, "selectFrame", {
   enumerable: true,
   get: function () {
     return _selectFrame.selectFrame;
   }
 });

--- a/devtools/client/debugger/new/src/actions/pause/moz.build
+++ b/devtools/client/debugger/new/src/actions/pause/moz.build
@@ -14,12 +14,13 @@ DevToolsModules(
     'extra.js',
     'fetchScopes.js',
     'index.js',
     'mapFrames.js',
     'mapScopes.js',
     'paused.js',
     'pauseOnExceptions.js',
     'resumed.js',
+    'selectComponent.js',
     'selectFrame.js',
     'setPopupObjectProperties.js',
     'skipPausing.js',
 )

new file mode 100644
--- /dev/null
+++ b/devtools/client/debugger/new/src/actions/pause/selectComponent.js
@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.selectComponent = selectComponent;
+
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at <http://mozilla.org/MPL/2.0/>. */
+function selectComponent(componentIndex) {
+  return async ({
+    dispatch
+  }) => {
+    dispatch({
+      type: "SELECT_COMPONENT",
+      componentIndex
+    });
+  };
+}
\ No newline at end of file

--- a/devtools/client/debugger/new/src/actions/sources/select.js
+++ b/devtools/client/debugger/new/src/actions/sources/select.js
@@ -113,17 +113,17 @@ function selectLocation(location) {
 
     const activeSearch = (0, _selectors.getActiveSearch)(getState());
 
     if (activeSearch !== "file") {
       dispatch((0, _ui.closeActiveSearch)());
     }
 
     const source = sourceRecord.toJS();
-    dispatch((0, _tabs.addTab)(source, 0));
+    dispatch((0, _tabs.addTab)(source.url, 0));
     dispatch({
       type: "SELECT_SOURCE",
       source,
       location
     });
     await dispatch((0, _loadSourceText.loadSourceText)(sourceRecord));
     const selectedSource = (0, _selectors.getSelectedSource)(getState());
 

--- a/devtools/client/debugger/new/src/actions/sources/tabs.js
+++ b/devtools/client/debugger/new/src/actions/sources/tabs.js
@@ -17,20 +17,20 @@ var _selectors = require("../../selector
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at <http://mozilla.org/MPL/2.0/>. */
 
 /**
  * Redux actions for the sources state
  * @module actions/sources
  */
-function addTab(source, tabIndex) {
+function addTab(url, tabIndex) {
   return {
     type: "ADD_TAB",
-    source,
+    url,
     tabIndex
   };
 }
 
 function moveTab(url, tabIndex) {
   return {
     type: "MOVE_TAB",
     url,

--- a/devtools/client/debugger/new/src/components/QuickOpenModal.js
+++ b/devtools/client/debugger/new/src/components/QuickOpenModal.js
@@ -431,29 +431,32 @@ class QuickOpenModal extends _react.Comp
     }
 
     const newResults = results && results.slice(0, 100);
     const items = this.highlightMatching(query, newResults || []);
     const expanded = !!items && items.length > 0;
     return _react2.default.createElement(_Modal2.default, {
       "in": enabled,
       handleClose: this.closeModal
-    }, _react2.default.createElement(_SearchInput2.default, {
+    }, _react2.default.createElement(_SearchInput2.default, _extends({
       query: query,
       hasPrefix: true,
       count: this.getResultCount(),
       placeholder: L10N.getStr("sourceSearch.search"),
       summaryMsg: "",
       showErrorEmoji: this.shouldShowErrorEmoji(),
       onChange: this.onChange,
       onKeyDown: this.onKeyDown,
       handleClose: this.closeModal,
       expanded: expanded,
+      showClose: false,
       selectedItemId: expanded && items[selectedIndex] ? items[selectedIndex].id : ""
-    }), this.renderLoading(), newResults && _react2.default.createElement(_ResultList2.default, _extends({
+    }, this.isSourceSearch() ? {
+      size: "big"
+    } : {})), this.renderLoading(), newResults && _react2.default.createElement(_ResultList2.default, _extends({
       key: "results",
       items: items,
       selected: selectedIndex,
       selectItem: this.selectResultItem,
       ref: "resultList",
       expanded: expanded
     }, this.isSourceSearch() ? {
       size: "big"

--- a/devtools/client/debugger/new/src/components/SecondaryPanes/ReactComponentStack.js
+++ b/devtools/client/debugger/new/src/components/SecondaryPanes/ReactComponentStack.js
@@ -9,34 +9,51 @@ var _react = require("devtools/client/sh
 var _react2 = _interopRequireDefault(_react);
 
 var _reactRedux = require("devtools/client/shared/vendor/react-redux");
 
 var _actions = require("../../actions/index");
 
 var _actions2 = _interopRequireDefault(_actions);
 
+var _classnames = require("devtools/client/debugger/new/dist/vendors").vendored["classnames"];
+
+var _classnames2 = _interopRequireDefault(_classnames);
+
 var _selectors = require("../../selectors/index");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at <http://mozilla.org/MPL/2.0/>. */
 class ReactComponentStack extends _react.PureComponent {
+  onMouseDown(e, componentIndex) {
+    if (e.nativeEvent.which == 3) {
+      return;
+    }
+
+    this.props.selectComponent(componentIndex);
+  }
+
   render() {
     const {
       componentStack
     } = this.props.extra.react;
     return _react2.default.createElement("div", {
       className: "pane frames"
     }, _react2.default.createElement("ul", null, componentStack.slice().reverse().map((component, index) => _react2.default.createElement("li", {
-      key: index
+      className: (0, _classnames2.default)("frame", {
+        selected: this.props.selectedComponentIndex === index
+      }),
+      key: index,
+      onMouseDown: e => this.onMouseDown(e, index)
     }, component))));
   }
 
 }
 
 const mapStateToProps = state => ({
-  extra: (0, _selectors.getExtra)(state)
+  extra: (0, _selectors.getExtra)(state),
+  selectedComponentIndex: (0, _selectors.getSelectedComponentIndex)(state)
 });
 
 exports.default = (0, _reactRedux.connect)(mapStateToProps, _actions2.default)(ReactComponentStack);
\ No newline at end of file

--- a/devtools/client/debugger/new/src/components/moz.build
+++ b/devtools/client/debugger/new/src/components/moz.build
@@ -3,17 +3,16 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 DIRS += [
     'Editor',
     'PrimaryPanes',
     'SecondaryPanes',
     'shared',
-    'test',
 ]
 
 DevToolsModules(
     'App.js',
     'ProjectSearch.js',
     'QuickOpenModal.js',
     'ShortcutsModal.js',
     'WelcomeBox.js',

--- a/devtools/client/debugger/new/src/components/shared/SearchInput.js
+++ b/devtools/client/debugger/new/src/components/shared/SearchInput.js
@@ -136,17 +136,18 @@ class SearchInput extends _react.Compone
       onChange,
       onKeyDown,
       onKeyUp,
       placeholder,
       query,
       selectedItemId,
       showErrorEmoji,
       size,
-      summaryMsg
+      summaryMsg,
+      showClose
     } = this.props;
     const inputProps = {
       className: (0, _classnames2.default)({
         empty: showErrorEmoji
       }),
       onChange,
       onKeyDown,
       onKeyUp,
@@ -167,23 +168,24 @@ class SearchInput extends _react.Compone
     }, _react2.default.createElement("div", {
       className: (0, _classnames2.default)("search-field", size),
       role: "combobox",
       "aria-haspopup": "listbox",
       "aria-owns": "result-list",
       "aria-expanded": expanded
     }, this.renderSvg(), _react2.default.createElement("input", inputProps), summaryMsg && _react2.default.createElement("div", {
       className: "summary"
-    }, summaryMsg), this.renderNav(), _react2.default.createElement(_Close2.default, {
+    }, summaryMsg), this.renderNav(), showClose && _react2.default.createElement(_Close2.default, {
       handleClick: handleClose,
       buttonClass: size
     })));
   }
 
 }
 
 SearchInput.defaultProps = {
   expanded: false,
   hasPrefix: false,
   selectedItemId: "",
-  size: ""
+  size: "",
+  showClose: true
 };
 exports.default = SearchInput;
\ No newline at end of file

deleted file mode 100644
--- a/devtools/client/debugger/new/src/components/test/Outline.spec.js
+++ /dev/null
@@ -1,316 +0,0 @@
-"use strict";
-
-var _react = require("devtools/client/shared/vendor/react");
-
-var _react2 = _interopRequireDefault(_react);
-
-var _enzyme = require("enzyme/index");
-
-var _Outline = require("../../components/PrimaryPanes/Outline");
-
-var _Outline2 = _interopRequireDefault(_Outline);
-
-var _testHead = require("../../utils/test-head");
-
-var _devtoolsContextmenu = require("devtools/client/debugger/new/dist/vendors").vendored["devtools-contextmenu"];
-
-var _clipboard = require("../../utils/clipboard");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-jest.mock("devtools-contextmenu", () => ({
-  showMenu: jest.fn()
-}));
-jest.mock("../../utils/clipboard", () => ({
-  copyToTheClipboard: jest.fn()
-}));
-const sourceId = "id";
-const mockFunctionText = "mock function text";
-
-function generateDefaults(overrides) {
-  return _objectSpread({
-    selectLocation: jest.genMockFunction(),
-    selectedSource: {
-      get: () => sourceId
-    },
-    getFunctionText: jest.fn().mockReturnValue(mockFunctionText),
-    flashLineRange: jest.fn(),
-    isHidden: false,
-    symbols: {},
-    selectedLocation: {
-      sourceId: sourceId
-    },
-    onAlphabetizeClick: jest.fn()
-  }, overrides);
-}
-
-function render(overrides = {}) {
-  const props = generateDefaults(overrides);
-  const component = (0, _enzyme.shallow)(_react2.default.createElement(_Outline2.default.WrappedComponent, props));
-  const instance = component.instance();
-  return {
-    component,
-    props,
-    instance
-  };
-}
-
-describe("Outline", () => {
-  afterEach(() => {
-    _clipboard.copyToTheClipboard.mockClear();
-
-    _devtoolsContextmenu.showMenu.mockClear();
-  });
-  it("renders a list of functions when properties change", async () => {
-    const symbols = {
-      functions: [(0, _testHead.makeSymbolDeclaration)("my_example_function1", 21), (0, _testHead.makeSymbolDeclaration)("my_example_function2", 22)]
-    };
-    const {
-      component
-    } = render({
-      symbols
-    });
-    expect(component).toMatchSnapshot();
-  });
-  it("selects a line of code in the current file on click", async () => {
-    const startLine = 12;
-    const symbols = {
-      functions: [(0, _testHead.makeSymbolDeclaration)("my_example_function", startLine)]
-    };
-    const {
-      component,
-      props
-    } = render({
-      symbols
-    });
-    const {
-      selectLocation
-    } = props;
-    const listItem = component.find("li").first();
-    listItem.simulate("click");
-    expect(selectLocation).toHaveBeenCalledWith({
-      line: startLine,
-      sourceId
-    });
-  });
-  describe("renders outline", () => {
-    describe("renders loading", () => {
-      it("if symbols is not defined", () => {
-        const {
-          component
-        } = render({
-          symbols: null
-        });
-        expect(component).toMatchSnapshot();
-      });
-      it("if symbols are loading", () => {
-        const {
-          component
-        } = render({
-          symbols: {
-            loading: true
-          }
-        });
-        expect(component).toMatchSnapshot();
-      });
-    });
-    it("renders ignore anonymous functions", async () => {
-      const symbols = {
-        functions: [(0, _testHead.makeSymbolDeclaration)("my_example_function1", 21), (0, _testHead.makeSymbolDeclaration)("anonymous", 25)]
-      };
-      const {
-        component
-      } = render({
-        symbols
-      });
-      expect(component).toMatchSnapshot();
-    });
-    describe("renders placeholder", () => {
-      it("`No File Selected` if selectedSource is not defined", async () => {
-        const {
-          component
-        } = render({
-          selectedSource: null
-        });
-        expect(component).toMatchSnapshot();
-      });
-      it("`No functions` if all func are anonymous", async () => {
-        const symbols = {
-          functions: [(0, _testHead.makeSymbolDeclaration)("anonymous", 25), (0, _testHead.makeSymbolDeclaration)("anonymous", 30)]
-        };
-        const {
-          component
-        } = render({
-          symbols
-        });
-        expect(component).toMatchSnapshot();
-      });
-      it("`No functions` if symbols has no func", async () => {
-        const symbols = {
-          functions: []
-        };
-        const {
-          component
-        } = render({
-          symbols
-        });
-        expect(component).toMatchSnapshot();
-      });
-    });
-    it("sorts functions alphabetically by function name", async () => {
-      const symbols = {
-        functions: [(0, _testHead.makeSymbolDeclaration)("c_function", 25), (0, _testHead.makeSymbolDeclaration)("x_function", 30), (0, _testHead.makeSymbolDeclaration)("a_function", 70)]
-      };
-      const {
-        component
-      } = render({
-        symbols: symbols,
-        alphabetizeOutline: true
-      });
-      expect(component).toMatchSnapshot();
-    });
-    it("calls onAlphabetizeClick when sort button is clicked", async () => {
-      const symbols = {
-        functions: [(0, _testHead.makeSymbolDeclaration)("example_function", 25)]
-      };
-      const {
-        component,
-        props
-      } = render({
-        symbols
-      });
-      await component.find(".outline-footer").find("button").simulate("click", {});
-      expect(props.onAlphabetizeClick).toHaveBeenCalled();
-    });
-    it("renders functions by function class", async () => {
-      const symbols = {
-        functions: [(0, _testHead.makeSymbolDeclaration)("x_function", 25, 26, "x_klass"), (0, _testHead.makeSymbolDeclaration)("a2_function", 30, 31, "a_klass"), (0, _testHead.makeSymbolDeclaration)("a1_function", 70, 71, "a_klass")],
-        classes: [(0, _testHead.makeSymbolDeclaration)("x_klass", 24, 27), (0, _testHead.makeSymbolDeclaration)("a_klass", 29, 72)]
-      };
-      const {
-        component
-      } = render({
-        symbols: symbols
-      });
-      expect(component).toMatchSnapshot();
-    });
-    it("renders functions by function class, alphabetically", async () => {
-      const symbols = {
-        functions: [(0, _testHead.makeSymbolDeclaration)("x_function", 25, 26, "x_klass"), (0, _testHead.makeSymbolDeclaration)("a2_function", 30, 31, "a_klass"), (0, _testHead.makeSymbolDeclaration)("a1_function", 70, 71, "a_klass")],
-        classes: [(0, _testHead.makeSymbolDeclaration)("x_klass", 24, 27), (0, _testHead.makeSymbolDeclaration)("a_klass", 29, 72)]
-      };
-      const {
-        component
-      } = render({
-        symbols: symbols,
-        alphabetizeOutline: true
-      });
-      expect(component).toMatchSnapshot();
-    });
-    it("selects class on click on class headline", async () => {
-      const symbols = {
-        functions: [(0, _testHead.makeSymbolDeclaration)("x_function", 25, 26, "x_klass")],
-        classes: [(0, _testHead.makeSymbolDeclaration)("x_klass", 24, 27)]
-      };
-      const {
-        component,
-        props
-      } = render({
-        symbols: symbols
-      });
-      await component.find("h2").simulate("click", {});
-      expect(props.selectLocation).toHaveBeenCalledWith({
-        line: 24,
-        sourceId: sourceId
-      });
-    });
-    it("does not select an item if selectedSource is not defined", async () => {
-      const {
-        instance,
-        props
-      } = render({
-        selectedSource: null
-      });
-      await instance.selectItem({});
-      expect(props.selectLocation).not.toHaveBeenCalled();
-    });
-  });
-  describe("onContextMenu of Outline", () => {
-    it("is called onContextMenu for each item", async () => {
-      const event = {
-        event: "oncontextmenu"
-      };
-      const fn = (0, _testHead.makeSymbolDeclaration)("exmple_function", 2);
-      const symbols = {
-        functions: [fn]
-      };
-      const {
-        component,
-        instance
-      } = render({
-        symbols
-      });
-      instance.onContextMenu = jest.fn(() => {});
-      await component.find(".outline-list__element").simulate("contextmenu", event);
-      expect(instance.onContextMenu).toHaveBeenCalledWith(event, fn);
-    });
-    it("does not show menu with no selected source", async () => {
-      const mockEvent = {
-        preventDefault: jest.fn(),
-        stopPropagation: jest.fn()
-      };
-      const {
-        instance
-      } = render({
-        selectedSource: null
-      });
-      await instance.onContextMenu(mockEvent, {});
-      expect(mockEvent.preventDefault).toHaveBeenCalled();
-      expect(mockEvent.stopPropagation).toHaveBeenCalled();
-      expect(_devtoolsContextmenu.showMenu).not.toHaveBeenCalled();
-    });
-    it("shows menu to copy func, copies to clipboard on click", async () => {
-      const startLine = 12;
-      const endLine = 21;
-      const func = (0, _testHead.makeSymbolDeclaration)("my_example_function", startLine, endLine);
-      const symbols = {
-        functions: [func]
-      };
-      const mockEvent = {
-        preventDefault: jest.fn(),
-        stopPropagation: jest.fn()
-      };
-      const {
-        instance,
-        props
-      } = render({
-        symbols
-      });
-      await instance.onContextMenu(mockEvent, func);
-      expect(mockEvent.preventDefault).toHaveBeenCalled();
-      expect(mockEvent.stopPropagation).toHaveBeenCalled();
-      const expectedMenuOptions = [{
-        accesskey: "F",
-        click: expect.any(Function),
-        disabled: false,
-        id: "node-menu-copy-function",
-        label: "Copy function"
-      }];
-      expect(props.getFunctionText).toHaveBeenCalledWith(12);
-      expect(_devtoolsContextmenu.showMenu).toHaveBeenCalledWith(mockEvent, expectedMenuOptions);
-
-      _devtoolsContextmenu.showMenu.mock.calls[0][1][0].click();
-
-      expect(_clipboard.copyToTheClipboard).toHaveBeenCalledWith(mockFunctionText);
-      expect(props.flashLineRange).toHaveBeenCalledWith({
-        end: endLine,
-        sourceId: sourceId,
-        start: startLine
-      });
-    });
-  });
-});
\ No newline at end of file