Merge mozilla-central to mozilla-inbound. on a CLOSED TREE
authorAndreea Pavel <apavel@mozilla.com>
Wed, 01 May 2019 19:08:56 +0300
changeset 531098 a356546201973e425e25ba42f3ab73091b8cbc6d
parent 531097 c9918832d469c13bb49f895ca2f7562a3f7c19df (current diff)
parent 530924 e4210db75a7f22d639f59fe5955de6bf62582df9 (diff)
child 531099 2aa89383ecb54ec33d95f877ac7cfde429dfab7e
push id11265
push userffxbld-merge
push dateMon, 13 May 2019 10:53:39 +0000
treeherdermozilla-beta@77e0fe8dbdd3 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
milestone68.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Merge mozilla-central to mozilla-inbound. on a CLOSED TREE
devtools/client/inspector/rules/test/browser_rules_inactive_css_flexbox.js
devtools/client/inspector/rules/test/browser_rules_inactive_css_grid.js
devtools/client/themes/images/alerticon-unused.svg
devtools/server/actors/utils/inactive-property-helper.js
remote/test/browser/browser_runtime_executionContext.js
--- a/.clang-format
+++ b/.clang-format
@@ -22,8 +22,15 @@ NS_INTERFACE_MAP_END_.*|\
 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END_INHERITED|\
 NS_IMPL_CYCLE_COLLECTION_UNLINK_END_INHERITED|\
 NS_QUERYFRAME_TAIL.*$"
 
 SortIncludes: false
 IndentPPDirectives: AfterHash
 StatementMacros: [MARKUPMAP, ASSERT_TRUE, ASSERT_FALSE, TEST, CHECK]
 
+# The Google coding style states:
+# You should do this consistently within a single file, so, when modifying an
+# existing file, use the style in that file.
+# Let's be more prescriptive and default to the one used in the Mozilla
+# coding style
+DerivePointerAlignment: false
+PointerAlignment: Left
--- a/accessible/atk/UtilInterface.cpp
+++ b/accessible/atk/UtilInterface.cpp
@@ -19,54 +19,54 @@ using namespace mozilla::a11y;
 typedef AtkUtil MaiUtil;
 typedef AtkUtilClass MaiUtilClass;
 
 #define MAI_VERSION MOZILLA_VERSION
 #define MAI_NAME "Gecko"
 
 extern "C" {
 static guint (*gail_add_global_event_listener)(GSignalEmissionHook listener,
-                                               const gchar *event_type);
+                                               const gchar* event_type);
 static void (*gail_remove_global_event_listener)(guint remove_listener);
 static void (*gail_remove_key_event_listener)(guint remove_listener);
-static AtkObject *(*gail_get_root)();
+static AtkObject* (*gail_get_root)();
 }
 
 struct MaiUtilListenerInfo {
   gint key;
   guint signal_id;
   gulong hook_id;
   // For window create/destory/minimize/maximize/restore/activate/deactivate
   // events, we'll chain gail_util's add/remove_global_event_listener.
   // So we store the listenerid returned by gail's add_global_event_listener
   // in this structure to call gail's remove_global_event_listener later.
   guint gail_listenerid;
 };
 
-static GHashTable *sListener_list = nullptr;
+static GHashTable* sListener_list = nullptr;
 static gint sListener_idx = 1;
 
 extern "C" {
 static guint add_listener(GSignalEmissionHook listener,
-                          const gchar *object_type, const gchar *signal,
-                          const gchar *hook_data, guint gail_listenerid = 0) {
+                          const gchar* object_type, const gchar* signal,
+                          const gchar* hook_data, guint gail_listenerid = 0) {
   GType type;
   guint signal_id;
   gint rc = 0;
 
   type = g_type_from_name(object_type);
   if (type) {
     signal_id = g_signal_lookup(signal, type);
     if (signal_id > 0) {
-      MaiUtilListenerInfo *listener_info;
+      MaiUtilListenerInfo* listener_info;
 
       rc = sListener_idx;
 
       listener_info =
-          (MaiUtilListenerInfo *)g_malloc(sizeof(MaiUtilListenerInfo));
+          (MaiUtilListenerInfo*)g_malloc(sizeof(MaiUtilListenerInfo));
       listener_info->key = sListener_idx;
       listener_info->hook_id = g_signal_add_emission_hook(
           signal_id, 0, listener, g_strdup(hook_data), (GDestroyNotify)g_free);
       listener_info->signal_id = signal_id;
       listener_info->gail_listenerid = gail_listenerid;
 
       g_hash_table_insert(sListener_list, &(listener_info->key), listener_info);
       sListener_idx++;
@@ -75,19 +75,19 @@ static guint add_listener(GSignalEmissio
     }
   } else {
     g_warning("Invalid object type %s\n", object_type);
   }
   return rc;
 }
 
 static guint mai_util_add_global_event_listener(GSignalEmissionHook listener,
-                                                const gchar *event_type) {
+                                                const gchar* event_type) {
   guint rc = 0;
-  gchar **split_string;
+  gchar** split_string;
 
   split_string = g_strsplit(event_type, ":", 3);
 
   if (split_string) {
     if (!strcmp("window", split_string[0])) {
       guint gail_listenerid = 0;
       if (gail_add_global_event_listener) {
         // call gail's function to track gtk native window events
@@ -101,21 +101,21 @@ static guint mai_util_add_global_event_l
     }
     g_strfreev(split_string);
   }
   return rc;
 }
 
 static void mai_util_remove_global_event_listener(guint remove_listener) {
   if (remove_listener > 0) {
-    MaiUtilListenerInfo *listener_info;
+    MaiUtilListenerInfo* listener_info;
     gint tmp_idx = remove_listener;
 
     listener_info =
-        (MaiUtilListenerInfo *)g_hash_table_lookup(sListener_list, &tmp_idx);
+        (MaiUtilListenerInfo*)g_hash_table_lookup(sListener_list, &tmp_idx);
 
     if (listener_info != nullptr) {
       if (gail_remove_global_event_listener && listener_info->gail_listenerid) {
         gail_remove_global_event_listener(listener_info->gail_listenerid);
       }
 
       /* Hook id of 0 and signal id of 0 are invalid */
       if (listener_info->hook_id != 0 && listener_info->signal_id != 0) {
@@ -139,18 +139,18 @@ static void mai_util_remove_global_event
       g_warning("No listener with the specified listener id %d",
                 remove_listener);
     }
   } else {
     g_warning("Invalid listener_id %d", remove_listener);
   }
 }
 
-static AtkKeyEventStruct *atk_key_event_from_gdk_event_key(GdkEventKey *key) {
-  AtkKeyEventStruct *event = g_new0(AtkKeyEventStruct, 1);
+static AtkKeyEventStruct* atk_key_event_from_gdk_event_key(GdkEventKey* key) {
+  AtkKeyEventStruct* event = g_new0(AtkKeyEventStruct, 1);
   switch (key->type) {
     case GDK_KEY_PRESS:
       event->type = ATK_KEY_EVENT_PRESS;
       break;
     case GDK_KEY_RELEASE:
       event->type = ATK_KEY_EVENT_RELEASE;
       break;
     default:
@@ -168,48 +168,48 @@ static AtkKeyEventStruct *atk_key_event_
   }
   event->keycode = key->hardware_keycode;
   event->timestamp = key->time;
 
   return event;
 }
 
 struct MaiKeyEventInfo {
-  AtkKeyEventStruct *key_event;
+  AtkKeyEventStruct* key_event;
   gpointer func_data;
 };
 
 union AtkKeySnoopFuncPointer {
   AtkKeySnoopFunc func_ptr;
   gpointer data;
 };
 
 static gboolean notify_hf(gpointer key, gpointer value, gpointer data) {
-  MaiKeyEventInfo *info = (MaiKeyEventInfo *)data;
+  MaiKeyEventInfo* info = (MaiKeyEventInfo*)data;
   AtkKeySnoopFuncPointer atkKeySnoop;
   atkKeySnoop.data = value;
   return (atkKeySnoop.func_ptr)(info->key_event, info->func_data) ? TRUE
                                                                   : FALSE;
 }
 
 static void insert_hf(gpointer key, gpointer value, gpointer data) {
-  GHashTable *new_table = (GHashTable *)data;
+  GHashTable* new_table = (GHashTable*)data;
   g_hash_table_insert(new_table, key, value);
 }
 
-static GHashTable *sKey_listener_list = nullptr;
+static GHashTable* sKey_listener_list = nullptr;
 
-static gint mai_key_snooper(GtkWidget *the_widget, GdkEventKey *event,
+static gint mai_key_snooper(GtkWidget* the_widget, GdkEventKey* event,
                             gpointer func_data) {
   /* notify each AtkKeySnoopFunc in turn... */
 
-  MaiKeyEventInfo *info = g_new0(MaiKeyEventInfo, 1);
+  MaiKeyEventInfo* info = g_new0(MaiKeyEventInfo, 1);
   gint consumed = 0;
   if (sKey_listener_list) {
-    GHashTable *new_hash = g_hash_table_new(nullptr, nullptr);
+    GHashTable* new_hash = g_hash_table_new(nullptr, nullptr);
     g_hash_table_foreach(sKey_listener_list, insert_hf, new_hash);
     info->key_event = atk_key_event_from_gdk_event_key(event);
     info->func_data = func_data;
     consumed = g_hash_table_foreach_steal(new_hash, notify_hf, info);
     g_hash_table_destroy(new_hash);
     g_free(info->key_event);
   }
   g_free(info);
@@ -252,50 +252,50 @@ static void mai_util_remove_key_event_li
   }
 
   g_hash_table_remove(sKey_listener_list, GUINT_TO_POINTER(remove_listener));
   if (g_hash_table_size(sKey_listener_list) == 0) {
     gtk_key_snooper_remove(sKey_snooper_id);
   }
 }
 
-static AtkObject *mai_util_get_root() {
-  ApplicationAccessible *app = ApplicationAcc();
+static AtkObject* mai_util_get_root() {
+  ApplicationAccessible* app = ApplicationAcc();
   if (app) return app->GetAtkObject();
 
   // We've shutdown, try to use gail instead
   // (to avoid assert in spi_atk_tidy_windows())
   // XXX tbsaunde then why didn't we replace the gail atk_util impl?
   if (gail_get_root) return gail_get_root();
 
   return nullptr;
 }
 
-static const gchar *mai_util_get_toolkit_name() { return MAI_NAME; }
+static const gchar* mai_util_get_toolkit_name() { return MAI_NAME; }
 
-static const gchar *mai_util_get_toolkit_version() { return MAI_VERSION; }
+static const gchar* mai_util_get_toolkit_version() { return MAI_VERSION; }
 
 static void _listener_info_destroy(gpointer data) { g_free(data); }
 
-static void window_added(AtkObject *atk_obj, guint index, AtkObject *child) {
+static void window_added(AtkObject* atk_obj, guint index, AtkObject* child) {
   if (!IS_MAI_OBJECT(child)) return;
 
   static guint id = g_signal_lookup("create", MAI_TYPE_ATK_OBJECT);
   g_signal_emit(child, id, 0);
 }
 
-static void window_removed(AtkObject *atk_obj, guint index, AtkObject *child) {
+static void window_removed(AtkObject* atk_obj, guint index, AtkObject* child) {
   if (!IS_MAI_OBJECT(child)) return;
 
   static guint id = g_signal_lookup("destroy", MAI_TYPE_ATK_OBJECT);
   g_signal_emit(child, id, 0);
 }
 
-static void UtilInterfaceInit(MaiUtilClass *klass) {
-  AtkUtilClass *atk_class;
+static void UtilInterfaceInit(MaiUtilClass* klass) {
+  AtkUtilClass* atk_class;
   gpointer data;
 
   data = g_type_class_peek(ATK_TYPE_UTIL);
   atk_class = ATK_UTIL_CLASS(data);
 
   // save gail function pointer
   gail_add_global_event_listener = atk_class->add_global_event_listener;
   gail_remove_global_event_listener = atk_class->remove_global_event_listener;
@@ -309,17 +309,17 @@ static void UtilInterfaceInit(MaiUtilCla
   atk_class->remove_key_event_listener = mai_util_remove_key_event_listener;
   atk_class->get_root = mai_util_get_root;
   atk_class->get_toolkit_name = mai_util_get_toolkit_name;
   atk_class->get_toolkit_version = mai_util_get_toolkit_version;
 
   sListener_list = g_hash_table_new_full(g_int_hash, g_int_equal, nullptr,
                                          _listener_info_destroy);
   // Keep track of added/removed windows.
-  AtkObject *root = atk_get_root();
+  AtkObject* root = atk_get_root();
   g_signal_connect(root, "children-changed::add", (GCallback)window_added,
                    nullptr);
   g_signal_connect(root, "children-changed::remove", (GCallback)window_removed,
                    nullptr);
 }
 }
 
 GType mai_util_get_type() {
--- a/accessible/atk/nsMaiHyperlink.cpp
+++ b/accessible/atk/nsMaiHyperlink.cpp
@@ -33,44 +33,44 @@ using namespace mozilla::a11y;
 
 struct MaiAtkHyperlink {
   AtkHyperlink parent;
 
   /*
    * The MaiHyperlink whose properties and features are exported via this
    * hyperlink instance.
    */
-  MaiHyperlink *maiHyperlink;
+  MaiHyperlink* maiHyperlink;
 };
 
 struct MaiAtkHyperlinkClass {
   AtkHyperlinkClass parent_class;
 };
 
 GType mai_atk_hyperlink_get_type(void);
 
 G_BEGIN_DECLS
 /* callbacks for AtkHyperlink */
-static void classInitCB(AtkHyperlinkClass *aClass);
-static void finalizeCB(GObject *aObj);
+static void classInitCB(AtkHyperlinkClass* aClass);
+static void finalizeCB(GObject* aObj);
 
 /* callbacks for AtkHyperlink virtual functions */
-static gchar *getUriCB(AtkHyperlink *aLink, gint aLinkIndex);
-static AtkObject *getObjectCB(AtkHyperlink *aLink, gint aLinkIndex);
-static gint getEndIndexCB(AtkHyperlink *aLink);
-static gint getStartIndexCB(AtkHyperlink *aLink);
-static gboolean isValidCB(AtkHyperlink *aLink);
-static gint getAnchorCountCB(AtkHyperlink *aLink);
+static gchar* getUriCB(AtkHyperlink* aLink, gint aLinkIndex);
+static AtkObject* getObjectCB(AtkHyperlink* aLink, gint aLinkIndex);
+static gint getEndIndexCB(AtkHyperlink* aLink);
+static gint getStartIndexCB(AtkHyperlink* aLink);
+static gboolean isValidCB(AtkHyperlink* aLink);
+static gint getAnchorCountCB(AtkHyperlink* aLink);
 G_END_DECLS
 
 static gpointer parent_class = nullptr;
 
-static MaiHyperlink *GetMaiHyperlink(AtkHyperlink *aHyperlink) {
+static MaiHyperlink* GetMaiHyperlink(AtkHyperlink* aHyperlink) {
   NS_ENSURE_TRUE(MAI_IS_ATK_HYPERLINK(aHyperlink), nullptr);
-  MaiHyperlink *maiHyperlink = MAI_ATK_HYPERLINK(aHyperlink)->maiHyperlink;
+  MaiHyperlink* maiHyperlink = MAI_ATK_HYPERLINK(aHyperlink)->maiHyperlink;
   NS_ENSURE_TRUE(maiHyperlink != nullptr, nullptr);
   NS_ENSURE_TRUE(maiHyperlink->GetAtkHyperlink() == aHyperlink, nullptr);
   return maiHyperlink;
 }
 
 GType mai_atk_hyperlink_get_type(void) {
   static GType type = 0;
 
@@ -91,136 +91,136 @@ GType mai_atk_hyperlink_get_type(void) {
     type = g_type_register_static(ATK_TYPE_HYPERLINK, "MaiAtkHyperlink", &tinfo,
                                   GTypeFlags(0));
   }
   return type;
 }
 
 MaiHyperlink::MaiHyperlink(AccessibleOrProxy aHyperLink)
     : mHyperlink(aHyperLink), mMaiAtkHyperlink(nullptr) {
-  mMaiAtkHyperlink = reinterpret_cast<AtkHyperlink *>(
+  mMaiAtkHyperlink = reinterpret_cast<AtkHyperlink*>(
       g_object_new(mai_atk_hyperlink_get_type(), nullptr));
   NS_ASSERTION(mMaiAtkHyperlink, "OUT OF MEMORY");
   if (!mMaiAtkHyperlink) return;
 
   MAI_ATK_HYPERLINK(mMaiAtkHyperlink)->maiHyperlink = this;
 }
 
 MaiHyperlink::~MaiHyperlink() {
   if (mMaiAtkHyperlink) {
     MAI_ATK_HYPERLINK(mMaiAtkHyperlink)->maiHyperlink = nullptr;
     g_object_unref(mMaiAtkHyperlink);
   }
 }
 
 /* static functions for ATK callbacks */
 
-void classInitCB(AtkHyperlinkClass *aClass) {
-  GObjectClass *gobject_class = G_OBJECT_CLASS(aClass);
+void classInitCB(AtkHyperlinkClass* aClass) {
+  GObjectClass* gobject_class = G_OBJECT_CLASS(aClass);
 
   parent_class = g_type_class_peek_parent(aClass);
 
   aClass->get_uri = getUriCB;
   aClass->get_object = getObjectCB;
   aClass->get_end_index = getEndIndexCB;
   aClass->get_start_index = getStartIndexCB;
   aClass->is_valid = isValidCB;
   aClass->get_n_anchors = getAnchorCountCB;
 
   gobject_class->finalize = finalizeCB;
 }
 
-void finalizeCB(GObject *aObj) {
+void finalizeCB(GObject* aObj) {
   NS_ASSERTION(MAI_IS_ATK_HYPERLINK(aObj), "Invalid MaiAtkHyperlink");
   if (!MAI_IS_ATK_HYPERLINK(aObj)) return;
 
-  MaiAtkHyperlink *maiAtkHyperlink = MAI_ATK_HYPERLINK(aObj);
+  MaiAtkHyperlink* maiAtkHyperlink = MAI_ATK_HYPERLINK(aObj);
   maiAtkHyperlink->maiHyperlink = nullptr;
 
   /* call parent finalize function */
   if (G_OBJECT_CLASS(parent_class)->finalize)
     G_OBJECT_CLASS(parent_class)->finalize(aObj);
 }
 
-gchar *getUriCB(AtkHyperlink *aLink, gint aLinkIndex) {
-  MaiHyperlink *maiLink = GetMaiHyperlink(aLink);
+gchar* getUriCB(AtkHyperlink* aLink, gint aLinkIndex) {
+  MaiHyperlink* maiLink = GetMaiHyperlink(aLink);
   if (!maiLink) return nullptr;
 
   nsAutoCString cautoStr;
-  if (Accessible *hyperlink = maiLink->GetAccHyperlink()) {
+  if (Accessible* hyperlink = maiLink->GetAccHyperlink()) {
     nsCOMPtr<nsIURI> uri = hyperlink->AnchorURIAt(aLinkIndex);
     if (!uri) return nullptr;
 
     nsresult rv = uri->GetSpec(cautoStr);
     NS_ENSURE_SUCCESS(rv, nullptr);
 
     return g_strdup(cautoStr.get());
   }
 
   bool valid;
   maiLink->Proxy()->AnchorURIAt(aLinkIndex, cautoStr, &valid);
   if (!valid) return nullptr;
 
   return g_strdup(cautoStr.get());
 }
 
-AtkObject *getObjectCB(AtkHyperlink *aLink, gint aLinkIndex) {
-  MaiHyperlink *maiLink = GetMaiHyperlink(aLink);
+AtkObject* getObjectCB(AtkHyperlink* aLink, gint aLinkIndex) {
+  MaiHyperlink* maiLink = GetMaiHyperlink(aLink);
   if (!maiLink) {
     return nullptr;
   }
 
-  if (Accessible *hyperlink = maiLink->GetAccHyperlink()) {
-    Accessible *anchor = hyperlink->AnchorAt(aLinkIndex);
+  if (Accessible* hyperlink = maiLink->GetAccHyperlink()) {
+    Accessible* anchor = hyperlink->AnchorAt(aLinkIndex);
     NS_ENSURE_TRUE(anchor, nullptr);
 
     return AccessibleWrap::GetAtkObject(anchor);
   }
 
-  ProxyAccessible *anchor = maiLink->Proxy()->AnchorAt(aLinkIndex);
+  ProxyAccessible* anchor = maiLink->Proxy()->AnchorAt(aLinkIndex);
   return anchor ? GetWrapperFor(anchor) : nullptr;
 }
 
-gint getEndIndexCB(AtkHyperlink *aLink) {
-  MaiHyperlink *maiLink = GetMaiHyperlink(aLink);
+gint getEndIndexCB(AtkHyperlink* aLink) {
+  MaiHyperlink* maiLink = GetMaiHyperlink(aLink);
   if (!maiLink) return false;
 
-  if (Accessible *hyperlink = maiLink->GetAccHyperlink())
+  if (Accessible* hyperlink = maiLink->GetAccHyperlink())
     return static_cast<gint>(hyperlink->EndOffset());
 
   bool valid = false;
   uint32_t endIdx = maiLink->Proxy()->EndOffset(&valid);
   return valid ? static_cast<gint>(endIdx) : -1;
 }
 
-gint getStartIndexCB(AtkHyperlink *aLink) {
-  MaiHyperlink *maiLink = GetMaiHyperlink(aLink);
+gint getStartIndexCB(AtkHyperlink* aLink) {
+  MaiHyperlink* maiLink = GetMaiHyperlink(aLink);
   if (!maiLink) return -1;
 
-  if (Accessible *hyperlink = maiLink->GetAccHyperlink())
+  if (Accessible* hyperlink = maiLink->GetAccHyperlink())
     return static_cast<gint>(hyperlink->StartOffset());
 
   bool valid = false;
   uint32_t startIdx = maiLink->Proxy()->StartOffset(&valid);
   return valid ? static_cast<gint>(startIdx) : -1;
 }
 
-gboolean isValidCB(AtkHyperlink *aLink) {
-  MaiHyperlink *maiLink = GetMaiHyperlink(aLink);
+gboolean isValidCB(AtkHyperlink* aLink) {
+  MaiHyperlink* maiLink = GetMaiHyperlink(aLink);
   if (!maiLink) return false;
 
-  if (Accessible *hyperlink = maiLink->GetAccHyperlink())
+  if (Accessible* hyperlink = maiLink->GetAccHyperlink())
     return static_cast<gboolean>(hyperlink->IsLinkValid());
 
   return static_cast<gboolean>(maiLink->Proxy()->IsLinkValid());
 }
 
-gint getAnchorCountCB(AtkHyperlink *aLink) {
-  MaiHyperlink *maiLink = GetMaiHyperlink(aLink);
+gint getAnchorCountCB(AtkHyperlink* aLink) {
+  MaiHyperlink* maiLink = GetMaiHyperlink(aLink);
   if (!maiLink) return -1;
 
-  if (Accessible *hyperlink = maiLink->GetAccHyperlink())
+  if (Accessible* hyperlink = maiLink->GetAccHyperlink())
     return static_cast<gint>(hyperlink->AnchorCount());
 
   bool valid = false;
   uint32_t anchorCount = maiLink->Proxy()->AnchorCount(&valid);
   return valid ? static_cast<gint>(anchorCount) : -1;
 }
--- a/accessible/base/nsCoreUtils.cpp
+++ b/accessible/base/nsCoreUtils.cpp
@@ -38,41 +38,41 @@
 #include "mozilla/dom/Selection.h"
 
 using namespace mozilla;
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsCoreUtils
 ////////////////////////////////////////////////////////////////////////////////
 
-bool nsCoreUtils::IsLabelWithControl(nsIContent *aContent) {
-  dom::HTMLLabelElement *label = dom::HTMLLabelElement::FromNode(aContent);
+bool nsCoreUtils::IsLabelWithControl(nsIContent* aContent) {
+  dom::HTMLLabelElement* label = dom::HTMLLabelElement::FromNode(aContent);
   if (label && label->GetControl()) return true;
 
   return false;
 }
 
-bool nsCoreUtils::HasClickListener(nsIContent *aContent) {
+bool nsCoreUtils::HasClickListener(nsIContent* aContent) {
   NS_ENSURE_TRUE(aContent, false);
-  EventListenerManager *listenerManager =
+  EventListenerManager* listenerManager =
       aContent->GetExistingListenerManager();
 
   return listenerManager &&
          (listenerManager->HasListenersFor(nsGkAtoms::onclick) ||
           listenerManager->HasListenersFor(nsGkAtoms::onmousedown) ||
           listenerManager->HasListenersFor(nsGkAtoms::onmouseup));
 }
 
-void nsCoreUtils::DispatchClickEvent(XULTreeElement *aTree, int32_t aRowIndex,
-                                     nsTreeColumn *aColumn,
-                                     const nsAString &aPseudoElt) {
+void nsCoreUtils::DispatchClickEvent(XULTreeElement* aTree, int32_t aRowIndex,
+                                     nsTreeColumn* aColumn,
+                                     const nsAString& aPseudoElt) {
   RefPtr<dom::Element> tcElm = aTree->GetTreeBody();
   if (!tcElm) return;
 
-  Document *document = tcElm->GetUncomposedDoc();
+  Document* document = tcElm->GetUncomposedDoc();
   if (!document) return;
 
   RefPtr<PresShell> presShell = document->GetPresShell();
   if (!presShell) {
     return;
   }
 
   // Ensure row is visible.
@@ -87,17 +87,17 @@ void nsCoreUtils::DispatchClickEvent(XUL
   }
 
   RefPtr<DOMRect> treeBodyRect = tcElm->GetBoundingClientRect();
   int32_t tcX = (int32_t)treeBodyRect->X();
   int32_t tcY = (int32_t)treeBodyRect->Y();
 
   // Dispatch mouse events.
   AutoWeakFrame tcFrame = tcElm->GetPrimaryFrame();
-  nsIFrame *rootFrame = presShell->GetRootFrame();
+  nsIFrame* rootFrame = presShell->GetRootFrame();
 
   nsPoint offset;
   nsCOMPtr<nsIWidget> rootWidget =
       rootFrame->GetView()->GetNearestWidget(&offset);
 
   RefPtr<nsPresContext> presContext = presShell->GetPresContext();
 
   int32_t cnvdX = presContext->CSSPixelsToDevPixels(tcX + int32_t(rect.x) + 1) +
@@ -109,38 +109,38 @@ void nsCoreUtils::DispatchClickEvent(XUL
   DispatchMouseEvent(eMouseDown, cnvdX, cnvdY, tcElm, tcFrame, presShell,
                      rootWidget);
 
   DispatchMouseEvent(eMouseUp, cnvdX, cnvdY, tcElm, tcFrame, presShell,
                      rootWidget);
 }
 
 void nsCoreUtils::DispatchMouseEvent(EventMessage aMessage, int32_t aX,
-                                     int32_t aY, nsIContent *aContent,
-                                     nsIFrame *aFrame, PresShell *aPresShell,
-                                     nsIWidget *aRootWidget) {
+                                     int32_t aY, nsIContent* aContent,
+                                     nsIFrame* aFrame, PresShell* aPresShell,
+                                     nsIWidget* aRootWidget) {
   WidgetMouseEvent event(true, aMessage, aRootWidget, WidgetMouseEvent::eReal,
                          WidgetMouseEvent::eNormal);
 
   event.mRefPoint = LayoutDeviceIntPoint(aX, aY);
 
   event.mClickCount = 1;
   event.mButton = MouseButton::eLeft;
   event.mTime = PR_IntervalNow();
   event.mInputSource = dom::MouseEvent_Binding::MOZ_SOURCE_UNKNOWN;
 
   nsEventStatus status = nsEventStatus_eIgnore;
   aPresShell->HandleEventWithTarget(&event, aFrame, aContent, &status);
 }
 
 void nsCoreUtils::DispatchTouchEvent(EventMessage aMessage, int32_t aX,
-                                     int32_t aY, nsIContent *aContent,
-                                     nsIFrame *aFrame, PresShell *aPresShell,
-                                     nsIWidget *aRootWidget) {
-  nsIDocShell *docShell = nullptr;
+                                     int32_t aY, nsIContent* aContent,
+                                     nsIFrame* aFrame, PresShell* aPresShell,
+                                     nsIWidget* aRootWidget) {
+  nsIDocShell* docShell = nullptr;
   if (aPresShell->GetDocument()) {
     docShell = aPresShell->GetDocument()->GetDocShell();
   }
   if (!dom::TouchEvent::PrefEnabled(docShell)) {
     return;
   }
 
   WidgetTouchEvent event(true, aMessage, aRootWidget);
@@ -151,85 +151,85 @@ void nsCoreUtils::DispatchTouchEvent(Eve
   RefPtr<dom::Touch> t = new dom::Touch(-1, LayoutDeviceIntPoint(aX, aY),
                                         LayoutDeviceIntPoint(1, 1), 0.0f, 1.0f);
   t->SetTouchTarget(aContent);
   event.mTouches.AppendElement(t);
   nsEventStatus status = nsEventStatus_eIgnore;
   aPresShell->HandleEventWithTarget(&event, aFrame, aContent, &status);
 }
 
-uint32_t nsCoreUtils::GetAccessKeyFor(nsIContent *aContent) {
+uint32_t nsCoreUtils::GetAccessKeyFor(nsIContent* aContent) {
   // Accesskeys are registered by @accesskey attribute only. At first check
   // whether it is presented on the given element to avoid the slow
   // EventStateManager::GetRegisteredAccessKey() method.
   if (!aContent->IsElement() ||
       !aContent->AsElement()->HasAttr(kNameSpaceID_None, nsGkAtoms::accesskey))
     return 0;
 
-  nsPresContext *presContext = aContent->OwnerDoc()->GetPresContext();
+  nsPresContext* presContext = aContent->OwnerDoc()->GetPresContext();
   if (!presContext) return 0;
 
-  EventStateManager *esm = presContext->EventStateManager();
+  EventStateManager* esm = presContext->EventStateManager();
   if (!esm) return 0;
 
   return esm->GetRegisteredAccessKey(aContent->AsElement());
 }
 
-nsIContent *nsCoreUtils::GetDOMElementFor(nsIContent *aContent) {
+nsIContent* nsCoreUtils::GetDOMElementFor(nsIContent* aContent) {
   if (aContent->IsElement()) return aContent;
 
   if (aContent->IsText()) return aContent->GetFlattenedTreeParent();
 
   return nullptr;
 }
 
-nsINode *nsCoreUtils::GetDOMNodeFromDOMPoint(nsINode *aNode, uint32_t aOffset) {
+nsINode* nsCoreUtils::GetDOMNodeFromDOMPoint(nsINode* aNode, uint32_t aOffset) {
   if (aNode && aNode->IsElement()) {
     uint32_t childCount = aNode->GetChildCount();
     NS_ASSERTION(aOffset <= childCount, "Wrong offset of the DOM point!");
 
     // The offset can be after last child of container node that means DOM point
     // is placed immediately after the last child. In this case use the DOM node
     // from the given DOM point is used as result node.
     if (aOffset != childCount) return aNode->GetChildAt_Deprecated(aOffset);
   }
 
   return aNode;
 }
 
-bool nsCoreUtils::IsAncestorOf(nsINode *aPossibleAncestorNode,
-                               nsINode *aPossibleDescendantNode,
-                               nsINode *aRootNode) {
+bool nsCoreUtils::IsAncestorOf(nsINode* aPossibleAncestorNode,
+                               nsINode* aPossibleDescendantNode,
+                               nsINode* aRootNode) {
   NS_ENSURE_TRUE(aPossibleAncestorNode && aPossibleDescendantNode, false);
 
-  nsINode *parentNode = aPossibleDescendantNode;
+  nsINode* parentNode = aPossibleDescendantNode;
   while ((parentNode = parentNode->GetParentNode()) &&
          parentNode != aRootNode) {
     if (parentNode == aPossibleAncestorNode) return true;
   }
 
   return false;
 }
 
-nsresult nsCoreUtils::ScrollSubstringTo(nsIFrame *aFrame, nsRange *aRange,
+nsresult nsCoreUtils::ScrollSubstringTo(nsIFrame* aFrame, nsRange* aRange,
                                         uint32_t aScrollType) {
   ScrollAxis vertical, horizontal;
   ConvertScrollTypeToPercents(aScrollType, &vertical, &horizontal);
 
   return ScrollSubstringTo(aFrame, aRange, vertical, horizontal);
 }
 
-nsresult nsCoreUtils::ScrollSubstringTo(nsIFrame *aFrame, nsRange *aRange,
+nsresult nsCoreUtils::ScrollSubstringTo(nsIFrame* aFrame, nsRange* aRange,
                                         ScrollAxis aVertical,
                                         ScrollAxis aHorizontal) {
   if (!aFrame || !aRange) {
     return NS_ERROR_FAILURE;
   }
 
-  nsPresContext *presContext = aFrame->PresContext();
+  nsPresContext* presContext = aFrame->PresContext();
 
   nsCOMPtr<nsISelectionController> selCon;
   aFrame->GetSelectionController(presContext, getter_AddRefs(selCon));
   NS_ENSURE_TRUE(selCon, NS_ERROR_FAILURE);
 
   RefPtr<dom::Selection> selection =
       selCon->GetSelection(nsISelectionController::SELECTION_ACCESSIBILITY);
 
@@ -240,36 +240,36 @@ nsresult nsCoreUtils::ScrollSubstringTo(
                             aVertical, aHorizontal,
                             Selection::SCROLL_SYNCHRONOUS);
 
   selection->CollapseToStart(IgnoreErrors());
 
   return NS_OK;
 }
 
-void nsCoreUtils::ScrollFrameToPoint(nsIFrame *aScrollableFrame,
-                                     nsIFrame *aFrame,
-                                     const nsIntPoint &aPoint) {
-  nsIScrollableFrame *scrollableFrame = do_QueryFrame(aScrollableFrame);
+void nsCoreUtils::ScrollFrameToPoint(nsIFrame* aScrollableFrame,
+                                     nsIFrame* aFrame,
+                                     const nsIntPoint& aPoint) {
+  nsIScrollableFrame* scrollableFrame = do_QueryFrame(aScrollableFrame);
   if (!scrollableFrame) return;
 
   nsPoint point =
       ToAppUnits(aPoint, aFrame->PresContext()->AppUnitsPerDevPixel());
   nsRect frameRect = aFrame->GetScreenRectInAppUnits();
   nsPoint deltaPoint = point - frameRect.TopLeft();
 
   nsPoint scrollPoint = scrollableFrame->GetScrollPosition();
   scrollPoint -= deltaPoint;
 
   scrollableFrame->ScrollTo(scrollPoint, ScrollMode::Instant);
 }
 
 void nsCoreUtils::ConvertScrollTypeToPercents(uint32_t aScrollType,
-                                              ScrollAxis *aVertical,
-                                              ScrollAxis *aHorizontal) {
+                                              ScrollAxis* aVertical,
+                                              ScrollAxis* aHorizontal) {
   WhereToScroll whereY, whereX;
   WhenToScroll whenY, whenX;
   switch (aScrollType) {
     case nsIAccessibleScrollType::SCROLL_TYPE_TOP_LEFT:
       whereY = kScrollToTop;
       whenY = WhenToScroll::Always;
       whereX = kScrollToLeft;
       whenX = WhenToScroll::Always;
@@ -309,94 +309,94 @@ void nsCoreUtils::ConvertScrollTypeToPer
       whenY = WhenToScroll::IfNotFullyVisible;
       whereX = kScrollMinimum;
       whenX = WhenToScroll::IfNotFullyVisible;
   }
   *aVertical = ScrollAxis(whereY, whenY);
   *aHorizontal = ScrollAxis(whereX, whenX);
 }
 
-nsIntPoint nsCoreUtils::GetScreenCoordsForWindow(nsINode *aNode) {
+nsIntPoint nsCoreUtils::GetScreenCoordsForWindow(nsINode* aNode) {
   nsIntPoint coords(0, 0);
   nsCOMPtr<nsIDocShellTreeItem> treeItem(GetDocShellFor(aNode));
   if (!treeItem) return coords;
 
   nsCOMPtr<nsIDocShellTreeOwner> treeOwner;
   treeItem->GetTreeOwner(getter_AddRefs(treeOwner));
   if (!treeOwner) return coords;
 
   nsCOMPtr<nsIBaseWindow> baseWindow = do_QueryInterface(treeOwner);
   if (baseWindow)
     baseWindow->GetPosition(&coords.x, &coords.y);  // in device pixels
 
   return coords;
 }
 
-already_AddRefed<nsIDocShell> nsCoreUtils::GetDocShellFor(nsINode *aNode) {
+already_AddRefed<nsIDocShell> nsCoreUtils::GetDocShellFor(nsINode* aNode) {
   if (!aNode) return nullptr;
 
   nsCOMPtr<nsIDocShell> docShell = aNode->OwnerDoc()->GetDocShell();
   return docShell.forget();
 }
 
-bool nsCoreUtils::IsRootDocument(Document *aDocument) {
+bool nsCoreUtils::IsRootDocument(Document* aDocument) {
   nsCOMPtr<nsIDocShellTreeItem> docShellTreeItem = aDocument->GetDocShell();
   NS_ASSERTION(docShellTreeItem, "No document shell for document!");
 
   nsCOMPtr<nsIDocShellTreeItem> parentTreeItem;
   docShellTreeItem->GetParent(getter_AddRefs(parentTreeItem));
 
   return !parentTreeItem;
 }
 
-bool nsCoreUtils::IsContentDocument(Document *aDocument) {
+bool nsCoreUtils::IsContentDocument(Document* aDocument) {
   nsCOMPtr<nsIDocShellTreeItem> docShellTreeItem = aDocument->GetDocShell();
   NS_ASSERTION(docShellTreeItem, "No document shell tree item for document!");
 
   return (docShellTreeItem->ItemType() == nsIDocShellTreeItem::typeContent);
 }
 
-bool nsCoreUtils::IsTabDocument(Document *aDocumentNode) {
+bool nsCoreUtils::IsTabDocument(Document* aDocumentNode) {
   nsCOMPtr<nsIDocShellTreeItem> treeItem(aDocumentNode->GetDocShell());
 
   nsCOMPtr<nsIDocShellTreeItem> parentTreeItem;
   treeItem->GetParent(getter_AddRefs(parentTreeItem));
 
   // Tab document running in own process doesn't have parent.
   if (XRE_IsContentProcess()) return !parentTreeItem;
 
   // Parent of docshell for tab document running in chrome process is root.
   nsCOMPtr<nsIDocShellTreeItem> rootTreeItem;
   treeItem->GetRootTreeItem(getter_AddRefs(rootTreeItem));
 
   return parentTreeItem == rootTreeItem;
 }
 
-bool nsCoreUtils::IsErrorPage(Document *aDocument) {
-  nsIURI *uri = aDocument->GetDocumentURI();
+bool nsCoreUtils::IsErrorPage(Document* aDocument) {
+  nsIURI* uri = aDocument->GetDocumentURI();
   bool isAboutScheme = false;
   uri->SchemeIs("about", &isAboutScheme);
   if (!isAboutScheme) return false;
 
   nsAutoCString path;
   uri->GetPathQueryRef(path);
 
   NS_NAMED_LITERAL_CSTRING(neterror, "neterror");
   NS_NAMED_LITERAL_CSTRING(certerror, "certerror");
 
   return StringBeginsWith(path, neterror) || StringBeginsWith(path, certerror);
 }
 
-bool nsCoreUtils::GetID(nsIContent *aContent, nsAString &aID) {
+bool nsCoreUtils::GetID(nsIContent* aContent, nsAString& aID) {
   return aContent->IsElement() &&
          aContent->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::id, aID);
 }
 
-bool nsCoreUtils::GetUIntAttr(nsIContent *aContent, nsAtom *aAttr,
-                              int32_t *aUInt) {
+bool nsCoreUtils::GetUIntAttr(nsIContent* aContent, nsAtom* aAttr,
+                              int32_t* aUInt) {
   nsAutoString value;
   if (!aContent->IsElement()) {
     return false;
   }
   aContent->AsElement()->GetAttr(kNameSpaceID_None, aAttr, value);
   if (!value.IsEmpty()) {
     nsresult error = NS_OK;
     int32_t integer = value.ToInteger(&error);
@@ -404,121 +404,121 @@ bool nsCoreUtils::GetUIntAttr(nsIContent
       *aUInt = integer;
       return true;
     }
   }
 
   return false;
 }
 
-void nsCoreUtils::GetLanguageFor(nsIContent *aContent, nsIContent *aRootContent,
-                                 nsAString &aLanguage) {
+void nsCoreUtils::GetLanguageFor(nsIContent* aContent, nsIContent* aRootContent,
+                                 nsAString& aLanguage) {
   aLanguage.Truncate();
 
-  nsIContent *walkUp = aContent;
+  nsIContent* walkUp = aContent;
   while (walkUp && walkUp != aRootContent &&
          (!walkUp->IsElement() ||
           !walkUp->AsElement()->GetAttr(kNameSpaceID_None, nsGkAtoms::lang,
                                         aLanguage)))
     walkUp = walkUp->GetParent();
 }
 
-XULTreeElement *nsCoreUtils::GetTree(nsIContent *aContent) {
+XULTreeElement* nsCoreUtils::GetTree(nsIContent* aContent) {
   // Find DOMNode's parents recursively until reach the <tree> tag
-  nsIContent *currentContent = aContent;
+  nsIContent* currentContent = aContent;
   while (currentContent) {
     if (currentContent->NodeInfo()->Equals(nsGkAtoms::tree, kNameSpaceID_XUL)) {
       return XULTreeElement::FromNode(currentContent);
     }
     currentContent = currentContent->GetFlattenedTreeParent();
   }
 
   return nullptr;
 }
 
 already_AddRefed<nsTreeColumn> nsCoreUtils::GetFirstSensibleColumn(
-    XULTreeElement *aTree) {
+    XULTreeElement* aTree) {
   RefPtr<nsTreeColumns> cols = aTree->GetColumns();
   if (!cols) return nullptr;
 
   RefPtr<nsTreeColumn> column = cols->GetFirstColumn();
   if (column && IsColumnHidden(column)) return GetNextSensibleColumn(column);
 
   return column.forget();
 }
 
-uint32_t nsCoreUtils::GetSensibleColumnCount(XULTreeElement *aTree) {
+uint32_t nsCoreUtils::GetSensibleColumnCount(XULTreeElement* aTree) {
   uint32_t count = 0;
 
   RefPtr<nsTreeColumns> cols = aTree->GetColumns();
   if (!cols) return count;
 
-  nsTreeColumn *column = cols->GetFirstColumn();
+  nsTreeColumn* column = cols->GetFirstColumn();
 
   while (column) {
     if (!IsColumnHidden(column)) count++;
 
     column = column->GetNext();
   }
 
   return count;
 }
 
 already_AddRefed<nsTreeColumn> nsCoreUtils::GetSensibleColumnAt(
-    XULTreeElement *aTree, uint32_t aIndex) {
+    XULTreeElement* aTree, uint32_t aIndex) {
   uint32_t idx = aIndex;
 
   nsCOMPtr<nsTreeColumn> column = GetFirstSensibleColumn(aTree);
   while (column) {
     if (idx == 0) return column.forget();
 
     idx--;
     column = GetNextSensibleColumn(column);
   }
 
   return nullptr;
 }
 
 already_AddRefed<nsTreeColumn> nsCoreUtils::GetNextSensibleColumn(
-    nsTreeColumn *aColumn) {
+    nsTreeColumn* aColumn) {
   RefPtr<nsTreeColumn> nextColumn = aColumn->GetNext();
 
   while (nextColumn && IsColumnHidden(nextColumn)) {
     nextColumn = nextColumn->GetNext();
   }
 
   return nextColumn.forget();
 }
 
 already_AddRefed<nsTreeColumn> nsCoreUtils::GetPreviousSensibleColumn(
-    nsTreeColumn *aColumn) {
+    nsTreeColumn* aColumn) {
   RefPtr<nsTreeColumn> prevColumn = aColumn->GetPrevious();
 
   while (prevColumn && IsColumnHidden(prevColumn)) {
     prevColumn = prevColumn->GetPrevious();
   }
 
   return prevColumn.forget();
 }
 
-bool nsCoreUtils::IsColumnHidden(nsTreeColumn *aColumn) {
-  Element *element = aColumn->Element();
+bool nsCoreUtils::IsColumnHidden(nsTreeColumn* aColumn) {
+  Element* element = aColumn->Element();
   return element->AttrValueIs(kNameSpaceID_None, nsGkAtoms::hidden,
                               nsGkAtoms::_true, eCaseMatters);
 }
 
-void nsCoreUtils::ScrollTo(PresShell *aPresShell, nsIContent *aContent,
+void nsCoreUtils::ScrollTo(PresShell* aPresShell, nsIContent* aContent,
                            uint32_t aScrollType) {
   ScrollAxis vertical, horizontal;
   ConvertScrollTypeToPercents(aScrollType, &vertical, &horizontal);
   aPresShell->ScrollContentIntoView(aContent, vertical, horizontal,
                                     ScrollFlags::ScrollOverflowHidden);
 }
 
-bool nsCoreUtils::IsWhitespaceString(const nsAString &aString) {
+bool nsCoreUtils::IsWhitespaceString(const nsAString& aString) {
   nsAString::const_char_iterator iterBegin, iterEnd;
 
   aString.BeginReading(iterBegin);
   aString.EndReading(iterEnd);
 
   while (iterBegin != iterEnd && IsWhitespace(*iterBegin)) ++iterBegin;
 
   return iterBegin == iterEnd;
--- a/accessible/base/nsCoreUtils.h
+++ b/accessible/base/nsCoreUtils.h
@@ -34,282 +34,282 @@ class XULTreeElement;
 class nsCoreUtils {
  public:
   typedef mozilla::PresShell PresShell;
   typedef mozilla::dom::Document Document;
 
   /**
    * Return true if the given node is a label of a control.
    */
-  static bool IsLabelWithControl(nsIContent *aContent);
+  static bool IsLabelWithControl(nsIContent* aContent);
 
   /**
    * Return true if the given node has registered click, mousedown or mouseup
    * event listeners.
    */
-  static bool HasClickListener(nsIContent *aContent);
+  static bool HasClickListener(nsIContent* aContent);
 
   /**
    * Dispatch click event to XUL tree cell.
    *
    * @param  aTree        [in] tree
    * @param  aRowIndex    [in] row index
    * @param  aColumn      [in] column object
    * @param  aPseudoElm   [in] pseudo element inside the cell, see
    *                       XULTreeElement for available values
    */
   MOZ_CAN_RUN_SCRIPT
-  static void DispatchClickEvent(mozilla::dom::XULTreeElement *aTree,
-                                 int32_t aRowIndex, nsTreeColumn *aColumn,
-                                 const nsAString &aPseudoElt = EmptyString());
+  static void DispatchClickEvent(mozilla::dom::XULTreeElement* aTree,
+                                 int32_t aRowIndex, nsTreeColumn* aColumn,
+                                 const nsAString& aPseudoElt = EmptyString());
 
   /**
    * Send mouse event to the given element.
    *
    * @param aMessage     [in] an event message (see EventForwards.h)
    * @param aX           [in] x coordinate in dev pixels
    * @param aY           [in] y coordinate in dev pixels
    * @param aContent     [in] the element
    * @param aFrame       [in] frame of the element
    * @param aPresShell   [in] the presshell for the element
    * @param aRootWidget  [in] the root widget of the element
    */
   MOZ_CAN_RUN_SCRIPT
   static void DispatchMouseEvent(mozilla::EventMessage aMessage, int32_t aX,
-                                 int32_t aY, nsIContent *aContent,
-                                 nsIFrame *aFrame, PresShell *aPresShell,
-                                 nsIWidget *aRootWidget);
+                                 int32_t aY, nsIContent* aContent,
+                                 nsIFrame* aFrame, PresShell* aPresShell,
+                                 nsIWidget* aRootWidget);
 
   /**
    * Send a touch event with a single touch point to the given element.
    *
    * @param aMessage     [in] an event message (see EventForwards.h)
    * @param aX           [in] x coordinate in dev pixels
    * @param aY           [in] y coordinate in dev pixels
    * @param aContent     [in] the element
    * @param aFrame       [in] frame of the element
    * @param aPresShell   [in] the presshell for the element
    * @param aRootWidget  [in] the root widget of the element
    */
   MOZ_CAN_RUN_SCRIPT
   static void DispatchTouchEvent(mozilla::EventMessage aMessage, int32_t aX,
-                                 int32_t aY, nsIContent *aContent,
-                                 nsIFrame *aFrame, PresShell *aPresShell,
-                                 nsIWidget *aRootWidget);
+                                 int32_t aY, nsIContent* aContent,
+                                 nsIFrame* aFrame, PresShell* aPresShell,
+                                 nsIWidget* aRootWidget);
 
   /**
    * Return an accesskey registered on the given element by
    * EventStateManager or 0 if there is no registered accesskey.
    *
    * @param aContent - the given element.
    */
-  static uint32_t GetAccessKeyFor(nsIContent *aContent);
+  static uint32_t GetAccessKeyFor(nsIContent* aContent);
 
   /**
    * Return DOM element related with the given node, i.e.
    * a) itself if it is DOM element
    * b) parent element if it is text node
    * c) otherwise nullptr
    *
    * @param aNode  [in] the given DOM node
    */
-  static nsIContent *GetDOMElementFor(nsIContent *aContent);
+  static nsIContent* GetDOMElementFor(nsIContent* aContent);
 
   /**
    * Return DOM node for the given DOM point.
    */
-  static nsINode *GetDOMNodeFromDOMPoint(nsINode *aNode, uint32_t aOffset);
+  static nsINode* GetDOMNodeFromDOMPoint(nsINode* aNode, uint32_t aOffset);
 
   /**
    * Is the first passed in node an ancestor of the second?
    * Note: A node is not considered to be the ancestor of itself.
    *
    * @param  aPossibleAncestorNode   [in] node to test for ancestor-ness of
    *                                   aPossibleDescendantNode
    * @param  aPossibleDescendantNode [in] node to test for descendant-ness of
    *                                   aPossibleAncestorNode
    * @param  aRootNode               [in, optional] the root node that search
    *                                   search should be performed within
    * @return true                     if aPossibleAncestorNode is an ancestor of
    *                                   aPossibleDescendantNode
    */
-  static bool IsAncestorOf(nsINode *aPossibleAncestorNode,
-                           nsINode *aPossibleDescendantNode,
-                           nsINode *aRootNode = nullptr);
+  static bool IsAncestorOf(nsINode* aPossibleAncestorNode,
+                           nsINode* aPossibleDescendantNode,
+                           nsINode* aRootNode = nullptr);
 
   /**
    * Helper method to scroll range into view, used for implementation of
    * nsIAccessibleText::scrollSubstringTo().
    *
    * @param aFrame        the frame for accessible the range belongs to.
    * @param aRange    the range to scroll to
    * @param aScrollType   the place a range should be scrolled to
    */
-  static nsresult ScrollSubstringTo(nsIFrame *aFrame, nsRange *aRange,
+  static nsresult ScrollSubstringTo(nsIFrame* aFrame, nsRange* aRange,
                                     uint32_t aScrollType);
 
   /** Helper method to scroll range into view, used for implementation of
    * nsIAccessibleText::scrollSubstringTo[Point]().
    *
    * @param aFrame        the frame for accessible the range belongs to.
    * @param aRange    the range to scroll to
    * @param aVertical     how to align vertically, specified in percents, and
    * when.
    * @param aHorizontal     how to align horizontally, specified in percents,
    * and when.
    */
-  static nsresult ScrollSubstringTo(nsIFrame *aFrame, nsRange *aRange,
+  static nsresult ScrollSubstringTo(nsIFrame* aFrame, nsRange* aRange,
                                     mozilla::ScrollAxis aVertical,
                                     mozilla::ScrollAxis aHorizontal);
 
   /**
    * Scrolls the given frame to the point, used for implememntation of
    * nsIAccessible::scrollToPoint and nsIAccessibleText::scrollSubstringToPoint.
    *
    * @param aScrollableFrame  the scrollable frame
    * @param aFrame            the frame to scroll
    * @param aPoint            the point scroll to
    */
-  static void ScrollFrameToPoint(nsIFrame *aScrollableFrame, nsIFrame *aFrame,
-                                 const nsIntPoint &aPoint);
+  static void ScrollFrameToPoint(nsIFrame* aScrollableFrame, nsIFrame* aFrame,
+                                 const nsIntPoint& aPoint);
 
   /**
    * Converts scroll type constant defined in nsIAccessibleScrollType to
    * vertical and horizontal parameters.
    */
   static void ConvertScrollTypeToPercents(uint32_t aScrollType,
-                                          mozilla::ScrollAxis *aVertical,
-                                          mozilla::ScrollAxis *aHorizontal);
+                                          mozilla::ScrollAxis* aVertical,
+                                          mozilla::ScrollAxis* aHorizontal);
 
   /**
    * Returns coordinates in device pixels relative screen for the top level
    * window.
    *
    * @param aNode  the DOM node hosted in the window.
    */
-  static nsIntPoint GetScreenCoordsForWindow(nsINode *aNode);
+  static nsIntPoint GetScreenCoordsForWindow(nsINode* aNode);
 
   /**
    * Return document shell for the given DOM node.
    */
-  static already_AddRefed<nsIDocShell> GetDocShellFor(nsINode *aNode);
+  static already_AddRefed<nsIDocShell> GetDocShellFor(nsINode* aNode);
 
   /**
    * Return true if the given document is root document.
    */
-  static bool IsRootDocument(Document *aDocument);
+  static bool IsRootDocument(Document* aDocument);
 
   /**
    * Return true if the given document is content document (not chrome).
    */
-  static bool IsContentDocument(Document *aDocument);
+  static bool IsContentDocument(Document* aDocument);
 
   /**
    * Return true if the given document node is for tab document accessible.
    */
-  static bool IsTabDocument(Document *aDocumentNode);
+  static bool IsTabDocument(Document* aDocumentNode);
 
   /**
    * Return true if the given document is an error page.
    */
-  static bool IsErrorPage(Document *aDocument);
+  static bool IsErrorPage(Document* aDocument);
 
   /**
    * Return presShell for the document containing the given DOM node.
    */
-  static PresShell *GetPresShellFor(nsINode *aNode) {
+  static PresShell* GetPresShellFor(nsINode* aNode) {
     return aNode->OwnerDoc()->GetPresShell();
   }
 
   /**
    * Get the ID for an element, in some types of XML this may not be the ID
    * attribute
    * @param aContent  Node to get the ID for
    * @param aID       Where to put ID string
    * @return          true if there is an ID set for this node
    */
-  static bool GetID(nsIContent *aContent, nsAString &aID);
+  static bool GetID(nsIContent* aContent, nsAString& aID);
 
   /**
    * Convert attribute value of the given node to positive integer. If no
    * attribute or wrong value then false is returned.
    */
-  static bool GetUIntAttr(nsIContent *aContent, nsAtom *aAttr, int32_t *aUInt);
+  static bool GetUIntAttr(nsIContent* aContent, nsAtom* aAttr, int32_t* aUInt);
 
   /**
    * Returns language for the given node.
    *
    * @param aContent     [in] the given node
    * @param aRootContent [in] container of the given node
    * @param aLanguage    [out] language
    */
-  static void GetLanguageFor(nsIContent *aContent, nsIContent *aRootContent,
-                             nsAString &aLanguage);
+  static void GetLanguageFor(nsIContent* aContent, nsIContent* aRootContent,
+                             nsAString& aLanguage);
 
   /**
    * Return tree from any levels DOMNode under the XUL tree.
    */
-  static mozilla::dom::XULTreeElement *GetTree(nsIContent *aContent);
+  static mozilla::dom::XULTreeElement* GetTree(nsIContent* aContent);
 
   /**
    * Return first sensible column for the given tree box object.
    */
   static already_AddRefed<nsTreeColumn> GetFirstSensibleColumn(
-      mozilla::dom::XULTreeElement *aTree);
+      mozilla::dom::XULTreeElement* aTree);
 
   /**
    * Return sensible columns count for the given tree box object.
    */
-  static uint32_t GetSensibleColumnCount(mozilla::dom::XULTreeElement *aTree);
+  static uint32_t GetSensibleColumnCount(mozilla::dom::XULTreeElement* aTree);
 
   /**
    * Return sensible column at the given index for the given tree box object.
    */
   static already_AddRefed<nsTreeColumn> GetSensibleColumnAt(
-      mozilla::dom::XULTreeElement *aTree, uint32_t aIndex);
+      mozilla::dom::XULTreeElement* aTree, uint32_t aIndex);
 
   /**
    * Return next sensible column for the given column.
    */
   static already_AddRefed<nsTreeColumn> GetNextSensibleColumn(
-      nsTreeColumn *aColumn);
+      nsTreeColumn* aColumn);
 
   /**
    * Return previous sensible column for the given column.
    */
   static already_AddRefed<nsTreeColumn> GetPreviousSensibleColumn(
-      nsTreeColumn *aColumn);
+      nsTreeColumn* aColumn);
 
   /**
    * Return true if the given column is hidden (i.e. not sensible).
    */
-  static bool IsColumnHidden(nsTreeColumn *aColumn);
+  static bool IsColumnHidden(nsTreeColumn* aColumn);
 
   /**
    * Scroll content into view.
    */
   MOZ_CAN_RUN_SCRIPT
-  static void ScrollTo(PresShell *aPresShell, nsIContent *aContent,
+  static void ScrollTo(PresShell* aPresShell, nsIContent* aContent,
                        uint32_t aScrollType);
 
   /**
    * Return true if the given node is table header element.
    */
-  static bool IsHTMLTableHeader(nsIContent *aContent) {
+  static bool IsHTMLTableHeader(nsIContent* aContent) {
     return aContent->NodeInfo()->Equals(nsGkAtoms::th) ||
            (aContent->IsElement() && aContent->AsElement()->HasAttr(
                                          kNameSpaceID_None, nsGkAtoms::scope));
   }
 
   /**
    * Returns true if the given string is empty or contains whitespace symbols
    * only. In contrast to nsWhitespaceTokenizer class it takes into account
    * non-breaking space (0xa0).
    */
-  static bool IsWhitespaceString(const nsAString &aString);
+  static bool IsWhitespaceString(const nsAString& aString);
 
   /**
    * Returns true if the given character is whitespace symbol.
    */
   static bool IsWhitespace(char16_t aChar) {
     return aChar == ' ' || aChar == '\n' || aChar == '\r' || aChar == '\t' ||
            aChar == 0xa0;
   }
--- a/accessible/base/nsTextEquivUtils.h
+++ b/accessible/base/nsTextEquivUtils.h
@@ -43,116 +43,116 @@ class nsTextEquivUtils {
 
   /**
    * Determines if the accessible has a given name rule.
    *
    * @param aAccessible [in] the given accessible
    * @param aRule       [in] a given name rule
    * @return true if the accessible has the rule
    */
-  static inline bool HasNameRule(Accessible *aAccessible,
+  static inline bool HasNameRule(Accessible* aAccessible,
                                  ETextEquivRule aRule) {
     return (GetRoleRule(aAccessible->Role()) & aRule) == aRule;
   }
 
   /**
    * Calculates the name from accessible subtree if allowed.
    *
    * @param aAccessible [in] the given accessible
    * @param aName       [out] accessible name
    */
-  static nsresult GetNameFromSubtree(const Accessible *aAccessible,
-                                     nsAString &aName);
+  static nsresult GetNameFromSubtree(const Accessible* aAccessible,
+                                     nsAString& aName);
 
   /**
    * Calculates text equivalent from the subtree. Similar to GetNameFromSubtree.
    * However it returns not empty result for things like HTML p.
    */
-  static void GetTextEquivFromSubtree(const Accessible *aAccessible,
-                                      nsString &aTextEquiv) {
+  static void GetTextEquivFromSubtree(const Accessible* aAccessible,
+                                      nsString& aTextEquiv) {
     aTextEquiv.Truncate();
 
     AppendFromAccessibleChildren(aAccessible, &aTextEquiv);
     aTextEquiv.CompressWhitespace();
   }
 
   /**
    * Calculates text equivalent for the given accessible from its IDRefs
    * attribute (like aria-labelledby or aria-describedby).
    *
    * @param aAccessible  [in] the accessible text equivalent is computed for
    * @param aIDRefsAttr  [in] IDRefs attribute on DOM node of the accessible
    * @param aTextEquiv   [out] result text equivalent
    */
-  static nsresult GetTextEquivFromIDRefs(const Accessible *aAccessible,
-                                         nsAtom *aIDRefsAttr,
-                                         nsAString &aTextEquiv);
+  static nsresult GetTextEquivFromIDRefs(const Accessible* aAccessible,
+                                         nsAtom* aIDRefsAttr,
+                                         nsAString& aTextEquiv);
 
   /**
    * Calculates the text equivalent from the given content and its subtree if
    * allowed and appends it to the given string.
    *
    * @param aInitiatorAcc  [in] the accessible text equivalent is computed for
    *                       in the end (root accessible of text equivalent
    *                       calculation recursion)
    * @param aContent       [in] the given content the text equivalent is
    *                       computed from
    * @param aString        [in, out] the string
    */
-  static nsresult AppendTextEquivFromContent(const Accessible *aInitiatorAcc,
-                                             nsIContent *aContent,
-                                             nsAString *aString);
+  static nsresult AppendTextEquivFromContent(const Accessible* aInitiatorAcc,
+                                             nsIContent* aContent,
+                                             nsAString* aString);
 
   /**
    * Calculates the text equivalent from the given text content (may be text
    * node or html:br) and appends it to the given string.
    *
    * @param aContent       [in] the text content
    * @param aString        [in, out] the string
    */
-  static nsresult AppendTextEquivFromTextContent(nsIContent *aContent,
-                                                 nsAString *aString);
+  static nsresult AppendTextEquivFromTextContent(nsIContent* aContent,
+                                                 nsAString* aString);
 
  private:
   /**
    * Iterates accessible children and calculates text equivalent from each
    * child.
    */
-  static nsresult AppendFromAccessibleChildren(const Accessible *aAccessible,
-                                               nsAString *aString);
+  static nsresult AppendFromAccessibleChildren(const Accessible* aAccessible,
+                                               nsAString* aString);
 
   /**
    * Calculates text equivalent from the given accessible and its subtree if
    * allowed.
    */
-  static nsresult AppendFromAccessible(Accessible *aAccessible,
-                                       nsAString *aString);
+  static nsresult AppendFromAccessible(Accessible* aAccessible,
+                                       nsAString* aString);
 
   /**
    * Calculates text equivalent from the value of given accessible.
    */
-  static nsresult AppendFromValue(Accessible *aAccessible, nsAString *aString);
+  static nsresult AppendFromValue(Accessible* aAccessible, nsAString* aString);
   /**
    * Iterates DOM children and calculates text equivalent from each child node.
    */
-  static nsresult AppendFromDOMChildren(nsIContent *aContent,
-                                        nsAString *aString);
+  static nsresult AppendFromDOMChildren(nsIContent* aContent,
+                                        nsAString* aString);
 
   /**
    * Calculates text equivalent from the given DOM node and its subtree if
    * allowed.
    */
-  static nsresult AppendFromDOMNode(nsIContent *aContent, nsAString *aString);
+  static nsresult AppendFromDOMNode(nsIContent* aContent, nsAString* aString);
 
   /**
    * Concatenates strings and appends space between them. Returns true if
    * text equivalent string was appended.
    */
-  static bool AppendString(nsAString *aString,
-                           const nsAString &aTextEquivalent);
+  static bool AppendString(nsAString* aString,
+                           const nsAString& aTextEquivalent);
 
   /**
    * Returns the rule (constant of ETextEquivRule) for a given role.
    */
   static uint32_t GetRoleRule(mozilla::a11y::roles::Role aRole);
 };
 
 #endif
--- a/accessible/interfaces/msaa/AccessibleMarshalThunk.c
+++ b/accessible/interfaces/msaa/AccessibleMarshalThunk.c
@@ -2,16 +2,16 @@
 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "ISimpleDOM.h"
 
 HRESULT STDMETHODCALLTYPE ISimpleDOMNode_get_localInterface_Proxy(
-    ISimpleDOMNode *This, void **localInterface) {
+    ISimpleDOMNode* This, void** localInterface) {
   return E_NOTIMPL;
 }
 
 HRESULT STDMETHODCALLTYPE ISimpleDOMNode_get_localInterface_Stub(
-    ISimpleDOMNode *This, IUnknown **localInterface) {
+    ISimpleDOMNode* This, IUnknown** localInterface) {
   return E_NOTIMPL;
 }
--- a/accessible/ipc/win/handler/HandlerTextLeaf.cpp
+++ b/accessible/ipc/win/handler/HandlerTextLeaf.cpp
@@ -9,18 +9,18 @@
 #endif  // defined(MOZILLA_INTERNAL_API)
 
 #include "HandlerTextLeaf.h"
 #include "mozilla/Assertions.h"
 
 namespace mozilla {
 namespace a11y {
 
-HandlerTextLeaf::HandlerTextLeaf(IDispatch *aParent, long aIndexInParent,
-                                 HWND aHwnd, AccChildData &aData)
+HandlerTextLeaf::HandlerTextLeaf(IDispatch* aParent, long aIndexInParent,
+                                 HWND aHwnd, AccChildData& aData)
     : mParent(aParent),
       mIndexInParent(aIndexInParent),
       mHwnd(aHwnd),
       mData(aData) {
   MOZ_ASSERT(aParent);
 }
 
 HandlerTextLeaf::~HandlerTextLeaf() {
@@ -34,164 +34,164 @@ IMPL_IUNKNOWN_QUERY_IFACE(IDispatch)
 IMPL_IUNKNOWN_QUERY_IFACE(IAccessible)
 IMPL_IUNKNOWN_QUERY_IFACE(IAccessible2)
 IMPL_IUNKNOWN_QUERY_IFACE(IServiceProvider)
 IMPL_IUNKNOWN_QUERY_TAIL
 
 /*** IDispatch ***/
 
 HRESULT
-HandlerTextLeaf::GetTypeInfoCount(UINT *pctinfo) { return E_NOTIMPL; }
+HandlerTextLeaf::GetTypeInfoCount(UINT* pctinfo) { return E_NOTIMPL; }
 
 HRESULT
-HandlerTextLeaf::GetTypeInfo(UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo) {
+HandlerTextLeaf::GetTypeInfo(UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo) {
   return E_NOTIMPL;
 }
 
 HRESULT
-HandlerTextLeaf::GetIDsOfNames(REFIID riid, LPOLESTR *rgszNames, UINT cNames,
-                               LCID lcid, DISPID *rgDispId) {
+HandlerTextLeaf::GetIDsOfNames(REFIID riid, LPOLESTR* rgszNames, UINT cNames,
+                               LCID lcid, DISPID* rgDispId) {
   return E_NOTIMPL;
 }
 
 HRESULT
 HandlerTextLeaf::Invoke(DISPID dispIdMember, REFIID riid, LCID lcid,
-                        WORD wFlags, DISPPARAMS *pDispParams,
-                        VARIANT *pVarResult, EXCEPINFO *pExcepInfo,
-                        UINT *puArgErr) {
+                        WORD wFlags, DISPPARAMS* pDispParams,
+                        VARIANT* pVarResult, EXCEPINFO* pExcepInfo,
+                        UINT* puArgErr) {
   return E_NOTIMPL;
 }
 
 /*** IAccessible ***/
 
 HRESULT
-HandlerTextLeaf::get_accParent(IDispatch **ppdispParent) {
+HandlerTextLeaf::get_accParent(IDispatch** ppdispParent) {
   if (!ppdispParent) {
     return E_INVALIDARG;
   }
 
   RefPtr<IDispatch> parent(mParent);
   parent.forget(ppdispParent);
   return S_OK;
 }
 
 HRESULT
-HandlerTextLeaf::get_accChildCount(long *pcountChildren) {
+HandlerTextLeaf::get_accChildCount(long* pcountChildren) {
   if (!pcountChildren) {
     return E_INVALIDARG;
   }
 
   *pcountChildren = 0;
   return S_OK;
 }
 
 HRESULT
-HandlerTextLeaf::get_accChild(VARIANT varChild, IDispatch **ppdispChild) {
+HandlerTextLeaf::get_accChild(VARIANT varChild, IDispatch** ppdispChild) {
   return E_NOTIMPL;
 }
 
 HRESULT
-HandlerTextLeaf::get_accName(VARIANT varChild, BSTR *pszName) {
+HandlerTextLeaf::get_accName(VARIANT varChild, BSTR* pszName) {
   if (varChild.lVal != CHILDID_SELF || !pszName) {
     return E_INVALIDARG;
   }
 
   *pszName = CopyBSTR(mData.mText);
   return S_OK;
 }
 
 HRESULT
-HandlerTextLeaf::get_accValue(VARIANT varChild, BSTR *pszValue) {
+HandlerTextLeaf::get_accValue(VARIANT varChild, BSTR* pszValue) {
   return E_NOTIMPL;
 }
 
 HRESULT
-HandlerTextLeaf::get_accDescription(VARIANT varChild, BSTR *pszDescription) {
+HandlerTextLeaf::get_accDescription(VARIANT varChild, BSTR* pszDescription) {
   return E_NOTIMPL;
 }
 
 HRESULT
-HandlerTextLeaf::get_accRole(VARIANT varChild, VARIANT *pvarRole) {
+HandlerTextLeaf::get_accRole(VARIANT varChild, VARIANT* pvarRole) {
   if (varChild.lVal != CHILDID_SELF || !pvarRole) {
     return E_INVALIDARG;
   }
 
   pvarRole->vt = VT_I4;
   pvarRole->lVal = mData.mTextRole;
   return S_OK;
 }
 
 HRESULT
-HandlerTextLeaf::get_accState(VARIANT varChild, VARIANT *pvarState) {
+HandlerTextLeaf::get_accState(VARIANT varChild, VARIANT* pvarState) {
   if (varChild.lVal != CHILDID_SELF || !pvarState) {
     return E_INVALIDARG;
   }
 
   pvarState->vt = VT_I4;
   pvarState->lVal = mData.mTextState;
   return S_OK;
 }
 
 HRESULT
-HandlerTextLeaf::get_accHelp(VARIANT varChild, BSTR *pszHelp) {
+HandlerTextLeaf::get_accHelp(VARIANT varChild, BSTR* pszHelp) {
   return E_NOTIMPL;
 }
 
 HRESULT
-HandlerTextLeaf::get_accHelpTopic(BSTR *pszHelpFile, VARIANT varChild,
-                                  long *pidTopic) {
+HandlerTextLeaf::get_accHelpTopic(BSTR* pszHelpFile, VARIANT varChild,
+                                  long* pidTopic) {
   return E_NOTIMPL;
 }
 
 HRESULT
 HandlerTextLeaf::get_accKeyboardShortcut(VARIANT varChild,
-                                         BSTR *pszKeyboardShortcut) {
+                                         BSTR* pszKeyboardShortcut) {
   return E_NOTIMPL;
 }
 
 HRESULT
-HandlerTextLeaf::get_accFocus(VARIANT *pvarChild) { return E_NOTIMPL; }
+HandlerTextLeaf::get_accFocus(VARIANT* pvarChild) { return E_NOTIMPL; }
 
 HRESULT
-HandlerTextLeaf::get_accSelection(VARIANT *pvarChildren) { return E_NOTIMPL; }
+HandlerTextLeaf::get_accSelection(VARIANT* pvarChildren) { return E_NOTIMPL; }
 
 HRESULT
 HandlerTextLeaf::get_accDefaultAction(VARIANT varChild,
-                                      BSTR *pszDefaultAction) {
+                                      BSTR* pszDefaultAction) {
   return E_NOTIMPL;
 }
 
 HRESULT
 HandlerTextLeaf::accSelect(long flagsSelect, VARIANT varChild) {
   return E_NOTIMPL;
 }
 
 HRESULT
-HandlerTextLeaf::accLocation(long *pxLeft, long *pyTop, long *pcxWidth,
-                             long *pcyHeight, VARIANT varChild) {
+HandlerTextLeaf::accLocation(long* pxLeft, long* pyTop, long* pcxWidth,
+                             long* pcyHeight, VARIANT varChild) {
   if (varChild.lVal != CHILDID_SELF || !pxLeft || !pyTop || !pcxWidth ||
       !pcyHeight) {
     return E_INVALIDARG;
   }
 
   *pxLeft = mData.mTextLeft;
   *pyTop = mData.mTextTop;
   *pcxWidth = mData.mTextWidth;
   *pcyHeight = mData.mTextHeight;
   return S_OK;
 }
 
 HRESULT
 HandlerTextLeaf::accNavigate(long navDir, VARIANT varStart,
-                             VARIANT *pvarEndUpAt) {
+                             VARIANT* pvarEndUpAt) {
   return E_NOTIMPL;
 }
 
 HRESULT
-HandlerTextLeaf::accHitTest(long xLeft, long yTop, VARIANT *pvarChild) {
+HandlerTextLeaf::accHitTest(long xLeft, long yTop, VARIANT* pvarChild) {
   return E_NOTIMPL;
 }
 
 HRESULT
 HandlerTextLeaf::accDoDefaultAction(VARIANT varChild) { return E_NOTIMPL; }
 
 HRESULT
 HandlerTextLeaf::put_accName(VARIANT varChild, BSTR szName) {
@@ -201,33 +201,33 @@ HandlerTextLeaf::put_accName(VARIANT var
 HRESULT
 HandlerTextLeaf::put_accValue(VARIANT varChild, BSTR szValue) {
   return E_NOTIMPL;
 }
 
 /*** IAccessible2 ***/
 
 HRESULT
-HandlerTextLeaf::get_nRelations(long *nRelations) { return E_NOTIMPL; }
+HandlerTextLeaf::get_nRelations(long* nRelations) { return E_NOTIMPL; }
 
 HRESULT
 HandlerTextLeaf::get_relation(long relationIndex,
-                              IAccessibleRelation **relation) {
+                              IAccessibleRelation** relation) {
   return E_NOTIMPL;
 }
 
 HRESULT
 HandlerTextLeaf::get_relations(long maxRelations,
-                               IAccessibleRelation **relations,
-                               long *nRelations) {
+                               IAccessibleRelation** relations,
+                               long* nRelations) {
   return E_NOTIMPL;
 }
 
 HRESULT
-HandlerTextLeaf::role(long *role) {
+HandlerTextLeaf::role(long* role) {
   if (!role) {
     return E_INVALIDARG;
   }
 
   *role = mData.mTextRole;
   return S_OK;
 }
 
@@ -236,99 +236,99 @@ HandlerTextLeaf::scrollTo(IA2ScrollType 
 
 HRESULT
 HandlerTextLeaf::scrollToPoint(IA2CoordinateType coordinateType, long x,
                                long y) {
   return E_NOTIMPL;
 }
 
 HRESULT
-HandlerTextLeaf::get_groupPosition(long *groupLevel, long *similarItemsInGroup,
-                                   long *positionInGroup) {
+HandlerTextLeaf::get_groupPosition(long* groupLevel, long* similarItemsInGroup,
+                                   long* positionInGroup) {
   return E_NOTIMPL;
 }
 
 HRESULT
-HandlerTextLeaf::get_states(AccessibleStates *states) {
+HandlerTextLeaf::get_states(AccessibleStates* states) {
   if (!states) {
     return E_INVALIDARG;
   }
 
   *states = 0;
   return S_OK;
 }
 
 HRESULT
-HandlerTextLeaf::get_extendedRole(BSTR *extendedRole) { return E_NOTIMPL; }
+HandlerTextLeaf::get_extendedRole(BSTR* extendedRole) { return E_NOTIMPL; }
 
 HRESULT
-HandlerTextLeaf::get_localizedExtendedRole(BSTR *localizedExtendedRole) {
+HandlerTextLeaf::get_localizedExtendedRole(BSTR* localizedExtendedRole) {
   return E_NOTIMPL;
 }
 
 HRESULT
-HandlerTextLeaf::get_nExtendedStates(long *nExtendedStates) {
+HandlerTextLeaf::get_nExtendedStates(long* nExtendedStates) {
   return E_NOTIMPL;
 }
 
 HRESULT
 HandlerTextLeaf::get_extendedStates(long maxExtendedStates,
-                                    BSTR **extendedStates,
-                                    long *nExtendedStates) {
+                                    BSTR** extendedStates,
+                                    long* nExtendedStates) {
   return E_NOTIMPL;
 }
 
 HRESULT
 HandlerTextLeaf::get_localizedExtendedStates(long maxLocalizedExtendedStates,
-                                             BSTR **localizedExtendedStates,
-                                             long *nLocalizedExtendedStates) {
+                                             BSTR** localizedExtendedStates,
+                                             long* nLocalizedExtendedStates) {
   return E_NOTIMPL;
 }
 
 HRESULT
-HandlerTextLeaf::get_uniqueID(long *uniqueID) {
+HandlerTextLeaf::get_uniqueID(long* uniqueID) {
   if (!uniqueID) {
     return E_INVALIDARG;
   }
 
   *uniqueID = mData.mTextId;
   return S_OK;
 }
 
 HRESULT
-HandlerTextLeaf::get_windowHandle(HWND *windowHandle) {
+HandlerTextLeaf::get_windowHandle(HWND* windowHandle) {
   if (!windowHandle) {
     return E_INVALIDARG;
   }
 
   *windowHandle = mHwnd;
   return S_OK;
 }
 
 HRESULT
-HandlerTextLeaf::get_indexInParent(long *indexInParent) {
+HandlerTextLeaf::get_indexInParent(long* indexInParent) {
   if (!indexInParent) {
     return E_INVALIDARG;
   }
 
   *indexInParent = mIndexInParent;
   return S_OK;
 }
 
 HRESULT
-HandlerTextLeaf::get_locale(IA2Locale *locale) { return E_NOTIMPL; }
+HandlerTextLeaf::get_locale(IA2Locale* locale) { return E_NOTIMPL; }
 
 HRESULT
-HandlerTextLeaf::get_attributes(BSTR *attributes) { return E_NOTIMPL; }
+HandlerTextLeaf::get_attributes(BSTR* attributes) { return E_NOTIMPL; }
 
 /*** IServiceProvider ***/
 
 HRESULT
 HandlerTextLeaf::QueryService(REFGUID aServiceId, REFIID aIid,
-                              void **aOutInterface) {
+                              void** aOutInterface) {
   if (aIid == IID_IAccessible2) {
     RefPtr<IAccessible2> ia2(this);
     ia2.forget(aOutInterface);
     return S_OK;
   }
 
   return E_INVALIDARG;
 }
--- a/accessible/ipc/win/handler/HandlerTextLeaf.h
+++ b/accessible/ipc/win/handler/HandlerTextLeaf.h
@@ -15,90 +15,90 @@
 #  include "IUnknownImpl.h"
 #  include "mozilla/RefPtr.h"
 
 namespace mozilla {
 namespace a11y {
 
 class HandlerTextLeaf final : public IAccessible2, public IServiceProvider {
  public:
-  explicit HandlerTextLeaf(IDispatch *aParent, long aIndexInParent, HWND aHwnd,
-                           AccChildData &aData);
+  explicit HandlerTextLeaf(IDispatch* aParent, long aIndexInParent, HWND aHwnd,
+                           AccChildData& aData);
 
   DECL_IUNKNOWN
 
   // IDispatch
-  STDMETHODIMP GetTypeInfoCount(UINT *pctinfo) override;
+  STDMETHODIMP GetTypeInfoCount(UINT* pctinfo) override;
   STDMETHODIMP GetTypeInfo(UINT iTInfo, LCID lcid,
-                           ITypeInfo **ppTInfo) override;
-  STDMETHODIMP GetIDsOfNames(REFIID riid, LPOLESTR *rgszNames, UINT cNames,
-                             LCID lcid, DISPID *rgDispId) override;
+                           ITypeInfo** ppTInfo) override;
+  STDMETHODIMP GetIDsOfNames(REFIID riid, LPOLESTR* rgszNames, UINT cNames,
+                             LCID lcid, DISPID* rgDispId) override;
   STDMETHODIMP Invoke(DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags,
-                      DISPPARAMS *pDispParams, VARIANT *pVarResult,
-                      EXCEPINFO *pExcepInfo, UINT *puArgErr) override;
+                      DISPPARAMS* pDispParams, VARIANT* pVarResult,
+                      EXCEPINFO* pExcepInfo, UINT* puArgErr) override;
 
   // IAccessible
-  STDMETHODIMP get_accParent(IDispatch **ppdispParent) override;
-  STDMETHODIMP get_accChildCount(long *pcountChildren) override;
-  STDMETHODIMP get_accChild(VARIANT varChild, IDispatch **ppdispChild) override;
-  STDMETHODIMP get_accName(VARIANT varChild, BSTR *pszName) override;
-  STDMETHODIMP get_accValue(VARIANT varChild, BSTR *pszValue) override;
+  STDMETHODIMP get_accParent(IDispatch** ppdispParent) override;
+  STDMETHODIMP get_accChildCount(long* pcountChildren) override;
+  STDMETHODIMP get_accChild(VARIANT varChild, IDispatch** ppdispChild) override;
+  STDMETHODIMP get_accName(VARIANT varChild, BSTR* pszName) override;
+  STDMETHODIMP get_accValue(VARIANT varChild, BSTR* pszValue) override;
   STDMETHODIMP get_accDescription(VARIANT varChild,
-                                  BSTR *pszDescription) override;
-  STDMETHODIMP get_accRole(VARIANT varChild, VARIANT *pvarRole) override;
-  STDMETHODIMP get_accState(VARIANT varChild, VARIANT *pvarState) override;
-  STDMETHODIMP get_accHelp(VARIANT varChild, BSTR *pszHelp) override;
-  STDMETHODIMP get_accHelpTopic(BSTR *pszHelpFile, VARIANT varChild,
-                                long *pidTopic) override;
+                                  BSTR* pszDescription) override;
+  STDMETHODIMP get_accRole(VARIANT varChild, VARIANT* pvarRole) override;
+  STDMETHODIMP get_accState(VARIANT varChild, VARIANT* pvarState) override;
+  STDMETHODIMP get_accHelp(VARIANT varChild, BSTR* pszHelp) override;
+  STDMETHODIMP get_accHelpTopic(BSTR* pszHelpFile, VARIANT varChild,
+                                long* pidTopic) override;
   STDMETHODIMP get_accKeyboardShortcut(VARIANT varChild,
-                                       BSTR *pszKeyboardShortcut) override;
-  STDMETHODIMP get_accFocus(VARIANT *pvarChild) override;
-  STDMETHODIMP get_accSelection(VARIANT *pvarChildren) override;
+                                       BSTR* pszKeyboardShortcut) override;
+  STDMETHODIMP get_accFocus(VARIANT* pvarChild) override;
+  STDMETHODIMP get_accSelection(VARIANT* pvarChildren) override;
   STDMETHODIMP get_accDefaultAction(VARIANT varChild,
-                                    BSTR *pszDefaultAction) override;
+                                    BSTR* pszDefaultAction) override;
   STDMETHODIMP accSelect(long flagsSelect, VARIANT varChild) override;
-  STDMETHODIMP accLocation(long *pxLeft, long *pyTop, long *pcxWidth,
-                           long *pcyHeight, VARIANT varChild) override;
+  STDMETHODIMP accLocation(long* pxLeft, long* pyTop, long* pcxWidth,
+                           long* pcyHeight, VARIANT varChild) override;
   STDMETHODIMP accNavigate(long navDir, VARIANT varStart,
-                           VARIANT *pvarEndUpAt) override;
-  STDMETHODIMP accHitTest(long xLeft, long yTop, VARIANT *pvarChild) override;
+                           VARIANT* pvarEndUpAt) override;
+  STDMETHODIMP accHitTest(long xLeft, long yTop, VARIANT* pvarChild) override;
   STDMETHODIMP accDoDefaultAction(VARIANT varChild) override;
   STDMETHODIMP put_accName(VARIANT varChild, BSTR szName) override;
   STDMETHODIMP put_accValue(VARIANT varChild, BSTR szValue) override;
 
   // IAccessible2
-  STDMETHODIMP get_nRelations(long *nRelations) override;
+  STDMETHODIMP get_nRelations(long* nRelations) override;
   STDMETHODIMP get_relation(long relationIndex,
-                            IAccessibleRelation **relation) override;
-  STDMETHODIMP get_relations(long maxRelations, IAccessibleRelation **relations,
-                             long *nRelations) override;
-  STDMETHODIMP role(long *role) override;
+                            IAccessibleRelation** relation) override;
+  STDMETHODIMP get_relations(long maxRelations, IAccessibleRelation** relations,
+                             long* nRelations) override;
+  STDMETHODIMP role(long* role) override;
   STDMETHODIMP scrollTo(IA2ScrollType scrollType) override;
   STDMETHODIMP scrollToPoint(IA2CoordinateType coordinateType, long x,
                              long y) override;
-  STDMETHODIMP get_groupPosition(long *groupLevel, long *similarItemsInGroup,
-                                 long *positionInGroup) override;
-  STDMETHODIMP get_states(AccessibleStates *states) override;
-  STDMETHODIMP get_extendedRole(BSTR *extendedRole) override;
-  STDMETHODIMP get_localizedExtendedRole(BSTR *localizedExtendedRole) override;
-  STDMETHODIMP get_nExtendedStates(long *nExtendedStates) override;
-  STDMETHODIMP get_extendedStates(long maxExtendedStates, BSTR **extendedStates,
-                                  long *nExtendedStates) override;
+  STDMETHODIMP get_groupPosition(long* groupLevel, long* similarItemsInGroup,
+                                 long* positionInGroup) override;
+  STDMETHODIMP get_states(AccessibleStates* states) override;
+  STDMETHODIMP get_extendedRole(BSTR* extendedRole) override;
+  STDMETHODIMP get_localizedExtendedRole(BSTR* localizedExtendedRole) override;
+  STDMETHODIMP get_nExtendedStates(long* nExtendedStates) override;
+  STDMETHODIMP get_extendedStates(long maxExtendedStates, BSTR** extendedStates,
+                                  long* nExtendedStates) override;
   STDMETHODIMP get_localizedExtendedStates(
-      long maxLocalizedExtendedStates, BSTR **localizedExtendedStates,
-      long *nLocalizedExtendedStates) override;
-  STDMETHODIMP get_uniqueID(long *uniqueID) override;
-  STDMETHODIMP get_windowHandle(HWND *windowHandle) override;
-  STDMETHODIMP get_indexInParent(long *indexInParent) override;
-  STDMETHODIMP get_locale(IA2Locale *locale) override;
-  STDMETHODIMP get_attributes(BSTR *attributes) override;
+      long maxLocalizedExtendedStates, BSTR** localizedExtendedStates,
+      long* nLocalizedExtendedStates) override;
+  STDMETHODIMP get_uniqueID(long* uniqueID) override;
+  STDMETHODIMP get_windowHandle(HWND* windowHandle) override;
+  STDMETHODIMP get_indexInParent(long* indexInParent) override;
+  STDMETHODIMP get_locale(IA2Locale* locale) override;
+  STDMETHODIMP get_attributes(BSTR* attributes) override;
 
   // IServiceProvider
   STDMETHODIMP QueryService(REFGUID aServiceId, REFIID aIid,
-                            void **aOutInterface) override;
+                            void** aOutInterface) override;
 
  private:
   ~HandlerTextLeaf();
 
   RefPtr<IDispatch> mParent;
   long mIndexInParent;
   HWND mHwnd;
   AccChildData mData;
--- a/accessible/windows/ia2/ia2AccessibleAction.h
+++ b/accessible/windows/ia2/ia2AccessibleAction.h
@@ -13,69 +13,69 @@
 #include "AccessibleAction.h"
 
 namespace mozilla {
 namespace a11y {
 
 class ia2AccessibleAction : public IAccessibleAction {
  public:
   // IUnknown
-  STDMETHODIMP QueryInterface(REFIID, void **);
+  STDMETHODIMP QueryInterface(REFIID, void**);
 
   // IAccessibleAction
   virtual HRESULT STDMETHODCALLTYPE nActions(
-      /* [retval][out] */ long *nActions);
+      /* [retval][out] */ long* nActions);
 
   virtual HRESULT STDMETHODCALLTYPE doAction(
       /* [in] */ long actionIndex);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_description(
       /* [in] */ long actionIndex,
-      /* [retval][out] */ BSTR *description);
+      /* [retval][out] */ BSTR* description);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_keyBinding(
       /* [in] */ long actionIndex,
       /* [in] */ long nMaxBinding,
-      /* [length_is][length_is][size_is][size_is][out] */ BSTR **keyBinding,
-      /* [retval][out] */ long *nBinding);
+      /* [length_is][length_is][size_is][size_is][out] */ BSTR** keyBinding,
+      /* [retval][out] */ long* nBinding);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_name(
       /* [in] */ long actionIndex,
-      /* [retval][out] */ BSTR *name);
+      /* [retval][out] */ BSTR* name);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_localizedName(
       /* [in] */ long actionIndex,
-      /* [retval][out] */ BSTR *localizedName);
+      /* [retval][out] */ BSTR* localizedName);
 };
 
 }  // namespace a11y
 }  // namespace mozilla
 
 #define FORWARD_IACCESSIBLEACTION(Class)                                       \
-  virtual HRESULT STDMETHODCALLTYPE nActions(long *nActions) {                 \
+  virtual HRESULT STDMETHODCALLTYPE nActions(long* nActions) {                 \
     return Class::nActions(nActions);                                          \
   }                                                                            \
                                                                                \
   virtual HRESULT STDMETHODCALLTYPE doAction(long actionIndex) {               \
     return Class::doAction(actionIndex);                                       \
   }                                                                            \
                                                                                \
   virtual HRESULT STDMETHODCALLTYPE get_description(long actionIndex,          \
-                                                    BSTR *description) {       \
+                                                    BSTR* description) {       \
     return Class::get_description(actionIndex, description);                   \
   }                                                                            \
                                                                                \
   virtual HRESULT STDMETHODCALLTYPE get_keyBinding(                            \
-      long actionIndex, long nMaxBinding, BSTR **keyBinding, long *nBinding) { \
+      long actionIndex, long nMaxBinding, BSTR** keyBinding, long* nBinding) { \
     return Class::get_keyBinding(actionIndex, nMaxBinding, keyBinding,         \
                                  nBinding);                                    \
   }                                                                            \
                                                                                \
-  virtual HRESULT STDMETHODCALLTYPE get_name(long actionIndex, BSTR *name) {   \
+  virtual HRESULT STDMETHODCALLTYPE get_name(long actionIndex, BSTR* name) {   \
     return Class::get_name(actionIndex, name);                                 \
   }                                                                            \
                                                                                \
   virtual HRESULT STDMETHODCALLTYPE get_localizedName(long actionIndex,        \
-                                                      BSTR *localizedName) {   \
+                                                      BSTR* localizedName) {   \
     return Class::get_localizedName(actionIndex, localizedName);               \
   }
 
 #endif
--- a/accessible/windows/ia2/ia2AccessibleComponent.h
+++ b/accessible/windows/ia2/ia2AccessibleComponent.h
@@ -11,26 +11,26 @@
 #include "AccessibleComponent.h"
 
 namespace mozilla {
 namespace a11y {
 
 class ia2AccessibleComponent : public IAccessibleComponent {
  public:
   // IUnknown
-  STDMETHODIMP QueryInterface(REFIID, void **);
+  STDMETHODIMP QueryInterface(REFIID, void**);
 
   // IAccessibleComponent
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_locationInParent(
-      /* [out] */ long *x,
-      /* [retval][out] */ long *y);
+      /* [out] */ long* x,
+      /* [retval][out] */ long* y);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_foreground(
-      /* [retval][out] */ IA2Color *foreground);
+      /* [retval][out] */ IA2Color* foreground);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_background(
-      /* [retval][out] */ IA2Color *background);
+      /* [retval][out] */ IA2Color* background);
 };
 
 }  // namespace a11y
 }  // namespace mozilla
 
 #endif
--- a/accessible/windows/ia2/ia2AccessibleEditableText.h
+++ b/accessible/windows/ia2/ia2AccessibleEditableText.h
@@ -23,33 +23,33 @@ class ia2AccessibleEditableText : public
       /* [in] */ long endOffset);
 
   virtual HRESULT STDMETHODCALLTYPE deleteText(
       /* [in] */ long startOffset,
       /* [in] */ long endOffset);
 
   virtual HRESULT STDMETHODCALLTYPE insertText(
       /* [in] */ long offset,
-      /* [in] */ BSTR *text);
+      /* [in] */ BSTR* text);
 
   virtual HRESULT STDMETHODCALLTYPE cutText(
       /* [in] */ long startOffset,
       /* [in] */ long endOffset);
 
   MOZ_CAN_RUN_SCRIPT_BOUNDARY
   virtual HRESULT STDMETHODCALLTYPE pasteText(
       /* [in] */ long offset);
 
   virtual HRESULT STDMETHODCALLTYPE replaceText(
       /* [in] */ long startOffset,
       /* [in] */ long endOffset,
-      /* [in] */ BSTR *text);
+      /* [in] */ BSTR* text);
 
   virtual HRESULT STDMETHODCALLTYPE setAttributes(
       /* [in] */ long startOffset,
       /* [in] */ long endOffset,
-      /* [in] */ BSTR *attributes);
+      /* [in] */ BSTR* attributes);
 };
 
 }  // namespace a11y
 }  // namespace mozilla
 
 #endif
--- a/accessible/windows/ia2/ia2AccessibleHyperlink.h
+++ b/accessible/windows/ia2/ia2AccessibleHyperlink.h
@@ -15,35 +15,35 @@
 
 namespace mozilla {
 namespace a11y {
 
 class ia2AccessibleHyperlink : public ia2AccessibleAction,
                                public IAccessibleHyperlink {
  public:
   // IUnknown
-  STDMETHODIMP QueryInterface(REFIID, void **);
+  STDMETHODIMP QueryInterface(REFIID, void**);
 
   // IAccessibleAction
   FORWARD_IACCESSIBLEACTION(ia2AccessibleAction)
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_anchor(
       /* [in] */ long index,
-      /* [retval][out] */ VARIANT *anchor);
+      /* [retval][out] */ VARIANT* anchor);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_anchorTarget(
       /* [in] */ long index,
-      /* [retval][out] */ VARIANT *anchorTarget);
+      /* [retval][out] */ VARIANT* anchorTarget);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_startIndex(
-      /* [retval][out] */ long *index);
+      /* [retval][out] */ long* index);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_endIndex(
-      /* [retval][out] */ long *index);
+      /* [retval][out] */ long* index);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_valid(
-      /* [retval][out] */ boolean *valid);
+      /* [retval][out] */ boolean* valid);
 };
 
 }  // namespace a11y
 }  // namespace mozilla
 
 #endif
--- a/accessible/windows/ia2/ia2AccessibleImage.h
+++ b/accessible/windows/ia2/ia2AccessibleImage.h
@@ -11,28 +11,28 @@
 #include "AccessibleImage.h"
 
 namespace mozilla {
 namespace a11y {
 
 class ia2AccessibleImage : public IAccessibleImage {
  public:
   // IUnknown
-  STDMETHODIMP QueryInterface(REFIID, void **);
+  STDMETHODIMP QueryInterface(REFIID, void**);
 
   // IAccessibleImage
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_description(
-      /* [retval][out] */ BSTR *description);
+      /* [retval][out] */ BSTR* description);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_imagePosition(
       /* [in] */ enum IA2CoordinateType coordinateType,
-      /* [out] */ long *x,
-      /* [retval][out] */ long *y);
+      /* [out] */ long* x,
+      /* [retval][out] */ long* y);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_imageSize(
-      /* [out] */ long *height,
-      /* [retval][out] */ long *width);
+      /* [out] */ long* height,
+      /* [retval][out] */ long* width);
 };
 
 }  // namespace a11y
 }  // namespace mozilla
 
 #endif
--- a/accessible/windows/ia2/ia2AccessibleRelation.cpp
+++ b/accessible/windows/ia2/ia2AccessibleRelation.cpp
@@ -9,33 +9,33 @@
 
 #include "Relation.h"
 #include "nsID.h"
 
 #include "AccessibleRelation_i.c"
 
 using namespace mozilla::a11y;
 
-ia2AccessibleRelation::ia2AccessibleRelation(RelationType aType, Relation *aRel)
+ia2AccessibleRelation::ia2AccessibleRelation(RelationType aType, Relation* aRel)
     : mType(aType) {
-  Accessible *target = nullptr;
+  Accessible* target = nullptr;
   while ((target = aRel->Next())) mTargets.AppendElement(target);
 }
 
 // IUnknown
 
 IMPL_IUNKNOWN_QUERY_HEAD(ia2AccessibleRelation)
 IMPL_IUNKNOWN_QUERY_IFACE(IAccessibleRelation)
 IMPL_IUNKNOWN_QUERY_IFACE(IUnknown)
 IMPL_IUNKNOWN_QUERY_TAIL
 
 // IAccessibleRelation
 
 STDMETHODIMP
-ia2AccessibleRelation::get_relationType(BSTR *aRelationType) {
+ia2AccessibleRelation::get_relationType(BSTR* aRelationType) {
   if (!aRelationType) return E_INVALIDARG;
 
   *aRelationType = nullptr;
 
 #define RELATIONTYPE(geckoType, geckoTypeName, atkType, msaaType, ia2Type) \
   case RelationType::geckoType:                                            \
     *aRelationType = ::SysAllocString(ia2Type);                            \
     break;
@@ -43,48 +43,48 @@ ia2AccessibleRelation::get_relationType(
   switch (mType) {
 #include "RelationTypeMap.h"
   }
 
   return *aRelationType ? S_OK : E_OUTOFMEMORY;
 }
 
 STDMETHODIMP
-ia2AccessibleRelation::get_localizedRelationType(BSTR *aLocalizedRelationType) {
+ia2AccessibleRelation::get_localizedRelationType(BSTR* aLocalizedRelationType) {
   if (!aLocalizedRelationType) return E_INVALIDARG;
 
   *aLocalizedRelationType = nullptr;
   return E_NOTIMPL;
 }
 
 STDMETHODIMP
-ia2AccessibleRelation::get_nTargets(long *aNTargets) {
+ia2AccessibleRelation::get_nTargets(long* aNTargets) {
   if (!aNTargets) return E_INVALIDARG;
 
   *aNTargets = mTargets.Length();
   return S_OK;
 }
 
 STDMETHODIMP
-ia2AccessibleRelation::get_target(long aTargetIndex, IUnknown **aTarget) {
+ia2AccessibleRelation::get_target(long aTargetIndex, IUnknown** aTarget) {
   if (aTargetIndex < 0 || (uint32_t)aTargetIndex >= mTargets.Length() ||
       !aTarget)
     return E_INVALIDARG;
 
-  AccessibleWrap *target =
-      static_cast<AccessibleWrap *>(mTargets[aTargetIndex].get());
-  *aTarget = static_cast<IAccessible *>(target);
+  AccessibleWrap* target =
+      static_cast<AccessibleWrap*>(mTargets[aTargetIndex].get());
+  *aTarget = static_cast<IAccessible*>(target);
   (*aTarget)->AddRef();
 
   return S_OK;
 }
 
 STDMETHODIMP
-ia2AccessibleRelation::get_targets(long aMaxTargets, IUnknown **aTargets,
-                                   long *aNTargets) {
+ia2AccessibleRelation::get_targets(long aMaxTargets, IUnknown** aTargets,
+                                   long* aNTargets) {
   if (!aNTargets || !aTargets) return E_INVALIDARG;
 
   *aNTargets = 0;
   long maxTargets = mTargets.Length();
   if (maxTargets > aMaxTargets) maxTargets = aMaxTargets;
 
   for (long idx = 0; idx < maxTargets; idx++) get_target(idx, aTargets + idx);
 
--- a/accessible/windows/ia2/ia2AccessibleRelation.h
+++ b/accessible/windows/ia2/ia2AccessibleRelation.h
@@ -16,65 +16,65 @@
 
 #include "AccessibleRelation.h"
 
 namespace mozilla {
 namespace a11y {
 
 class ia2AccessibleRelation final : public IAccessibleRelation {
  public:
-  ia2AccessibleRelation(RelationType aType, Relation *aRel);
+  ia2AccessibleRelation(RelationType aType, Relation* aRel);
 
   ia2AccessibleRelation(RelationType aType,
-                        nsTArray<RefPtr<Accessible>> &&aTargets)
+                        nsTArray<RefPtr<Accessible>>&& aTargets)
       : mType(aType), mTargets(std::move(aTargets)) {}
 
   // IUnknown
   DECL_IUNKNOWN
 
   // IAccessibleRelation
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_relationType(
-      /* [retval][out] */ BSTR *relationType);
+      /* [retval][out] */ BSTR* relationType);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_localizedRelationType(
-      /* [retval][out] */ BSTR *localizedRelationType);
+      /* [retval][out] */ BSTR* localizedRelationType);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_nTargets(
-      /* [retval][out] */ long *nTargets);
+      /* [retval][out] */ long* nTargets);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_target(
       /* [in] */ long targetIndex,
-      /* [retval][out] */ IUnknown **target);
+      /* [retval][out] */ IUnknown** target);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_targets(
       /* [in] */ long maxTargets,
-      /* [length_is][size_is][out] */ IUnknown **target,
-      /* [retval][out] */ long *nTargets);
+      /* [length_is][size_is][out] */ IUnknown** target,
+      /* [retval][out] */ long* nTargets);
 
   inline bool HasTargets() const { return mTargets.Length(); }
 
  private:
   ia2AccessibleRelation();
-  ia2AccessibleRelation(const ia2AccessibleRelation &);
-  ia2AccessibleRelation &operator=(const ia2AccessibleRelation &);
+  ia2AccessibleRelation(const ia2AccessibleRelation&);
+  ia2AccessibleRelation& operator=(const ia2AccessibleRelation&);
 
   RelationType mType;
   nsTArray<RefPtr<Accessible>> mTargets;
 };
 
 /**
  * Gecko to IAccessible2 relation types map.
  */
 
-const WCHAR *const IA2_RELATION_NULL = L"";
+const WCHAR* const IA2_RELATION_NULL = L"";
 
 #define RELATIONTYPE(geckoType, name, atkType, msaaType, ia2Type) \
-  std::pair<RelationType, const WCHAR *const>(RelationType::geckoType, ia2Type),
+  std::pair<RelationType, const WCHAR* const>(RelationType::geckoType, ia2Type),
 
-static const std::pair<RelationType, const WCHAR *const> sRelationTypePairs[] =
+static const std::pair<RelationType, const WCHAR* const> sRelationTypePairs[] =
     {
 #include "RelationTypeMap.h"
 };
 
 #undef RELATIONTYPE
 
 }  // namespace a11y
 }  // namespace mozilla
--- a/accessible/windows/ia2/ia2AccessibleTable.h
+++ b/accessible/windows/ia2/ia2AccessibleTable.h
@@ -14,159 +14,159 @@
 namespace mozilla {
 namespace a11y {
 
 class TableAccessible;
 
 class ia2AccessibleTable : public IAccessibleTable, public IAccessibleTable2 {
  public:
   // IUnknown
-  STDMETHODIMP QueryInterface(REFIID, void **);
+  STDMETHODIMP QueryInterface(REFIID, void**);
 
   // IAccessibleTable
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_accessibleAt(
       /* [in] */ long row,
       /* [in] */ long column,
-      /* [retval][out] */ IUnknown **accessible);
+      /* [retval][out] */ IUnknown** accessible);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_caption(
-      /* [retval][out] */ IUnknown **accessible);
+      /* [retval][out] */ IUnknown** accessible);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_childIndex(
       /* [in] */ long rowIndex,
       /* [in] */ long columnIndex,
-      /* [retval][out] */ long *childIndex);
+      /* [retval][out] */ long* childIndex);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_columnDescription(
       /* [in] */ long column,
-      /* [retval][out] */ BSTR *description);
+      /* [retval][out] */ BSTR* description);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_columnExtentAt(
       /* [in] */ long row,
       /* [in] */ long column,
-      /* [retval][out] */ long *nColumnsSpanned);
+      /* [retval][out] */ long* nColumnsSpanned);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_columnHeader(
-      /* [out] */ IAccessibleTable **accessibleTable,
-      /* [retval][out] */ long *startingRowIndex);
+      /* [out] */ IAccessibleTable** accessibleTable,
+      /* [retval][out] */ long* startingRowIndex);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_columnIndex(
       /* [in] */ long childIndex,
-      /* [retval][out] */ long *columnIndex);
+      /* [retval][out] */ long* columnIndex);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_nColumns(
-      /* [retval][out] */ long *columnCount);
+      /* [retval][out] */ long* columnCount);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_nRows(
-      /* [retval][out] */ long *rowCount);
+      /* [retval][out] */ long* rowCount);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_nSelectedChildren(
-      /* [retval][out] */ long *childCount);
+      /* [retval][out] */ long* childCount);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_nSelectedColumns(
-      /* [retval][out] */ long *columnCount);
+      /* [retval][out] */ long* columnCount);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_nSelectedRows(
-      /* [retval][out] */ long *rowCount);
+      /* [retval][out] */ long* rowCount);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_rowDescription(
       /* [in] */ long row,
-      /* [retval][out] */ BSTR *description);
+      /* [retval][out] */ BSTR* description);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_rowExtentAt(
       /* [in] */ long row,
       /* [in] */ long column,
-      /* [retval][out] */ long *nRowsSpanned);
+      /* [retval][out] */ long* nRowsSpanned);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_rowHeader(
-      /* [out] */ IAccessibleTable **accessibleTable,
-      /* [retval][out] */ long *startingColumnIndex);
+      /* [out] */ IAccessibleTable** accessibleTable,
+      /* [retval][out] */ long* startingColumnIndex);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_rowIndex(
       /* [in] */ long childIndex,
-      /* [retval][out] */ long *rowIndex);
+      /* [retval][out] */ long* rowIndex);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_selectedChildren(
       /* [in] */ long maxChildren,
-      /* [length_is][length_is][size_is][size_is][out] */ long **children,
-      /* [retval][out] */ long *nChildren);
+      /* [length_is][length_is][size_is][size_is][out] */ long** children,
+      /* [retval][out] */ long* nChildren);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_selectedColumns(
       /* [in] */ long maxColumns,
-      /* [length_is][length_is][size_is][size_is][out] */ long **columns,
-      /* [retval][out] */ long *nColumns);
+      /* [length_is][length_is][size_is][size_is][out] */ long** columns,
+      /* [retval][out] */ long* nColumns);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_selectedRows(
       /* [in] */ long maxRows,
-      /* [length_is][length_is][size_is][size_is][out] */ long **rows,
-      /* [retval][out] */ long *nRows);
+      /* [length_is][length_is][size_is][size_is][out] */ long** rows,
+      /* [retval][out] */ long* nRows);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_summary(
-      /* [retval][out] */ IUnknown **accessible);
+      /* [retval][out] */ IUnknown** accessible);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_isColumnSelected(
       /* [in] */ long column,
-      /* [retval][out] */ boolean *isSelected);
+      /* [retval][out] */ boolean* isSelected);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_isRowSelected(
       /* [in] */ long row,
-      /* [retval][out] */ boolean *isSelected);
+      /* [retval][out] */ boolean* isSelected);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_isSelected(
       /* [in] */ long row,
       /* [in] */ long column,
-      /* [retval][out] */ boolean *isSelected);
+      /* [retval][out] */ boolean* isSelected);
 
   virtual HRESULT STDMETHODCALLTYPE selectRow(
       /* [in] */ long row);
 
   virtual HRESULT STDMETHODCALLTYPE selectColumn(
       /* [in] */ long column);
 
   virtual HRESULT STDMETHODCALLTYPE unselectRow(
       /* [in] */ long row);
 
   virtual HRESULT STDMETHODCALLTYPE unselectColumn(
       /* [in] */ long column);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_rowColumnExtentsAtIndex(
       /* [in] */ long index,
-      /* [out] */ long *row,
-      /* [out] */ long *column,
-      /* [out] */ long *rowExtents,
-      /* [out] */ long *columnExtents,
-      /* [retval][out] */ boolean *isSelected);
+      /* [out] */ long* row,
+      /* [out] */ long* column,
+      /* [out] */ long* rowExtents,
+      /* [out] */ long* columnExtents,
+      /* [retval][out] */ boolean* isSelected);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_modelChange(
-      /* [retval][out] */ IA2TableModelChange *modelChange);
+      /* [retval][out] */ IA2TableModelChange* modelChange);
 
   // IAccessibleTable2
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_cellAt(
       /* [in] */ long row,
       /* [in] */ long column,
-      /* [out, retval] */ IUnknown **cell);
+      /* [out, retval] */ IUnknown** cell);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_nSelectedCells(
-      /* [out, retval] */ long *cellCount);
+      /* [out, retval] */ long* cellCount);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_selectedCells(
-      /* [out, size_is(,*nSelectedCells,)] */ IUnknown ***cells,
-      /* [out, retval] */ long *nSelectedCells);
+      /* [out, size_is(,*nSelectedCells,)] */ IUnknown*** cells,
+      /* [out, retval] */ long* nSelectedCells);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_selectedColumns(
-      /* [out, size_is(,*nColumns)] */ long **selectedColumns,
-      /* [out, retval] */ long *nColumns);
+      /* [out, size_is(,*nColumns)] */ long** selectedColumns,
+      /* [out, retval] */ long* nColumns);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_selectedRows(
-      /* [out, size_is(,*nRows)] */ long **selectedRows,
-      /* [out, retval] */ long *nRows);
+      /* [out, size_is(,*nRows)] */ long** selectedRows,
+      /* [out, retval] */ long* nRows);
 
  protected:
-  ia2AccessibleTable(TableAccessible *aTable) : mTable(aTable) {}
+  ia2AccessibleTable(TableAccessible* aTable) : mTable(aTable) {}
 
-  TableAccessible *mTable;
+  TableAccessible* mTable;
 };
 
 }  // namespace a11y
 }  // namespace mozilla
 
 #endif
--- a/accessible/windows/ia2/ia2AccessibleTableCell.h
+++ b/accessible/windows/ia2/ia2AccessibleTableCell.h
@@ -12,56 +12,56 @@
 
 namespace mozilla {
 namespace a11y {
 class TableCellAccessible;
 
 class ia2AccessibleTableCell : public IAccessibleTableCell {
  public:
   // IUnknown
-  STDMETHODIMP QueryInterface(REFIID, void **);
+  STDMETHODIMP QueryInterface(REFIID, void**);
 
   // IAccessibleTableCell
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_table(
-      /* [out, retval] */ IUnknown **table);
+      /* [out, retval] */ IUnknown** table);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_columnExtent(
-      /* [out, retval] */ long *nColumnsSpanned);
+      /* [out, retval] */ long* nColumnsSpanned);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_columnHeaderCells(
-      /* [out, size_is(,*nColumnHeaderCells,)] */ IUnknown ***cellAccessibles,
-      /* [out, retval] */ long *nColumnHeaderCells);
+      /* [out, size_is(,*nColumnHeaderCells,)] */ IUnknown*** cellAccessibles,
+      /* [out, retval] */ long* nColumnHeaderCells);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_columnIndex(
-      /* [out, retval] */ long *columnIndex);
+      /* [out, retval] */ long* columnIndex);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_rowExtent(
-      /* [out, retval] */ long *nRowsSpanned);
+      /* [out, retval] */ long* nRowsSpanned);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_rowHeaderCells(
-      /* [out, size_is(,*nRowHeaderCells,)] */ IUnknown ***cellAccessibles,
-      /* [out, retval] */ long *nRowHeaderCells);
+      /* [out, size_is(,*nRowHeaderCells,)] */ IUnknown*** cellAccessibles,
+      /* [out, retval] */ long* nRowHeaderCells);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_rowIndex(
-      /* [out, retval] */ long *rowIndex);
+      /* [out, retval] */ long* rowIndex);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_rowColumnExtents(
-      /* [out] */ long *row,
-      /* [out] */ long *column,
-      /* [out] */ long *rowExtents,
-      /* [out] */ long *columnExtents,
-      /* [out, retval] */ boolean *isSelected);
+      /* [out] */ long* row,
+      /* [out] */ long* column,
+      /* [out] */ long* rowExtents,
+      /* [out] */ long* columnExtents,
+      /* [out, retval] */ boolean* isSelected);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_isSelected(
-      /* [out, retval] */ boolean *isSelected);
+      /* [out, retval] */ boolean* isSelected);
 
  protected:
-  ia2AccessibleTableCell(TableCellAccessible *aTableCell)
+  ia2AccessibleTableCell(TableCellAccessible* aTableCell)
       : mTableCell(aTableCell) {}
 
-  TableCellAccessible *mTableCell;
+  TableCellAccessible* mTableCell;
 };
 
 }  // namespace a11y
 }  // namespace mozilla
 
 #endif
--- a/accessible/windows/ia2/ia2AccessibleText.h
+++ b/accessible/windows/ia2/ia2AccessibleText.h
@@ -20,183 +20,183 @@ class ia2AccessibleText : public IAccess
  public:
   // IAccessibleText
   virtual HRESULT STDMETHODCALLTYPE addSelection(
       /* [in] */ long startOffset,
       /* [in] */ long endOffset);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_attributes(
       /* [in] */ long offset,
-      /* [out] */ long *startOffset,
-      /* [out] */ long *endOffset,
-      /* [retval][out] */ BSTR *textAttributes);
+      /* [out] */ long* startOffset,
+      /* [out] */ long* endOffset,
+      /* [retval][out] */ BSTR* textAttributes);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_caretOffset(
-      /* [retval][out] */ long *offset);
+      /* [retval][out] */ long* offset);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_characterExtents(
       /* [in] */ long offset,
       /* [in] */ enum IA2CoordinateType coordType,
-      /* [out] */ long *x,
-      /* [out] */ long *y,
-      /* [out] */ long *width,
-      /* [retval][out] */ long *height);
+      /* [out] */ long* x,
+      /* [out] */ long* y,
+      /* [out] */ long* width,
+      /* [retval][out] */ long* height);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_nSelections(
-      /* [retval][out] */ long *nSelections);
+      /* [retval][out] */ long* nSelections);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_offsetAtPoint(
       /* [in] */ long x,
       /* [in] */ long y,
       /* [in] */ enum IA2CoordinateType coordType,
-      /* [retval][out] */ long *offset);
+      /* [retval][out] */ long* offset);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_selection(
       /* [in] */ long selectionIndex,
-      /* [out] */ long *startOffset,
-      /* [retval][out] */ long *endOffset);
+      /* [out] */ long* startOffset,
+      /* [retval][out] */ long* endOffset);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_text(
       /* [in] */ long startOffset,
       /* [in] */ long endOffset,
-      /* [retval][out] */ BSTR *text);
+      /* [retval][out] */ BSTR* text);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_textBeforeOffset(
       /* [in] */ long offset,
       /* [in] */ enum IA2TextBoundaryType boundaryType,
-      /* [out] */ long *startOffset,
-      /* [out] */ long *endOffset,
-      /* [retval][out] */ BSTR *text);
+      /* [out] */ long* startOffset,
+      /* [out] */ long* endOffset,
+      /* [retval][out] */ BSTR* text);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_textAfterOffset(
       /* [in] */ long offset,
       /* [in] */ enum IA2TextBoundaryType boundaryType,
-      /* [out] */ long *startOffset,
-      /* [out] */ long *endOffset,
-      /* [retval][out] */ BSTR *text);
+      /* [out] */ long* startOffset,
+      /* [out] */ long* endOffset,
+      /* [retval][out] */ BSTR* text);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_textAtOffset(
       /* [in] */ long offset,
       /* [in] */ enum IA2TextBoundaryType boundaryType,
-      /* [out] */ long *startOffset,
-      /* [out] */ long *endOffset,
-      /* [retval][out] */ BSTR *text);
+      /* [out] */ long* startOffset,
+      /* [out] */ long* endOffset,
+      /* [retval][out] */ BSTR* text);
 
   virtual HRESULT STDMETHODCALLTYPE removeSelection(
       /* [in] */ long selectionIndex);
 
   virtual HRESULT STDMETHODCALLTYPE setCaretOffset(
       /* [in] */ long offset);
 
   virtual HRESULT STDMETHODCALLTYPE setSelection(
       /* [in] */ long selectionIndex,
       /* [in] */ long startOffset,
       /* [in] */ long endOffset);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_nCharacters(
-      /* [retval][out] */ long *nCharacters);
+      /* [retval][out] */ long* nCharacters);
 
   virtual HRESULT STDMETHODCALLTYPE scrollSubstringTo(
       /* [in] */ long startIndex,
       /* [in] */ long endIndex,
       /* [in] */ enum IA2ScrollType scrollType);
 
   virtual HRESULT STDMETHODCALLTYPE scrollSubstringToPoint(
       /* [in] */ long startIndex,
       /* [in] */ long endIndex,
       /* [in] */ enum IA2CoordinateType coordinateType,
       /* [in] */ long x,
       /* [in] */ long y);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_newText(
-      /* [retval][out] */ IA2TextSegment *newText);
+      /* [retval][out] */ IA2TextSegment* newText);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_oldText(
-      /* [retval][out] */ IA2TextSegment *oldText);
+      /* [retval][out] */ IA2TextSegment* oldText);
 
   static void InitTextChangeData();
-  static void UpdateTextChangeData(HyperTextAccessibleWrap *aAcc, bool aInsert,
-                                   const nsString &aStr, int32_t aStart,
+  static void UpdateTextChangeData(HyperTextAccessibleWrap* aAcc, bool aInsert,
+                                   const nsString& aStr, int32_t aStart,
                                    uint32_t aLen);
 
  protected:
   static StaticRefPtr<HyperTextAccessibleWrap> sLastTextChangeAcc;
   static StaticAutoPtr<nsString> sLastTextChangeString;
   static bool sLastTextChangeWasInsert;
   static uint32_t sLastTextChangeStart;
   static uint32_t sLastTextChangeEnd;
 
  private:
-  HRESULT GetModifiedText(bool aGetInsertedText, IA2TextSegment *aNewText);
+  HRESULT GetModifiedText(bool aGetInsertedText, IA2TextSegment* aNewText);
   AccessibleTextBoundary GetGeckoTextBoundary(
       enum IA2TextBoundaryType coordinateType);
 };
 
 }  // namespace a11y
 }  // namespace mozilla
 
 #define FORWARD_IACCESSIBLETEXT(Class)                                         \
   virtual HRESULT STDMETHODCALLTYPE addSelection(long startOffset,             \
                                                  long endOffset) {             \
     return Class::addSelection(startOffset, endOffset);                        \
   }                                                                            \
                                                                                \
   virtual HRESULT STDMETHODCALLTYPE get_attributes(                            \
-      long offset, long *startOffset, long *endOffset, BSTR *textAttributes) { \
+      long offset, long* startOffset, long* endOffset, BSTR* textAttributes) { \
     return Class::get_attributes(offset, startOffset, endOffset,               \
                                  textAttributes);                              \
   }                                                                            \
                                                                                \
-  virtual HRESULT STDMETHODCALLTYPE get_caretOffset(long *offset) {            \
+  virtual HRESULT STDMETHODCALLTYPE get_caretOffset(long* offset) {            \
     return Class::get_caretOffset(offset);                                     \
   }                                                                            \
                                                                                \
   virtual HRESULT STDMETHODCALLTYPE get_characterExtents(                      \
-      long offset, enum IA2CoordinateType coordType, long *x, long *y,         \
-      long *width, long *height) {                                             \
+      long offset, enum IA2CoordinateType coordType, long* x, long* y,         \
+      long* width, long* height) {                                             \
     return Class::get_characterExtents(offset, coordType, x, y, width,         \
                                        height);                                \
   }                                                                            \
                                                                                \
-  virtual HRESULT STDMETHODCALLTYPE get_nSelections(long *nSelections) {       \
+  virtual HRESULT STDMETHODCALLTYPE get_nSelections(long* nSelections) {       \
     return Class::get_nSelections(nSelections);                                \
   }                                                                            \
                                                                                \
   virtual HRESULT STDMETHODCALLTYPE get_offsetAtPoint(                         \
-      long x, long y, enum IA2CoordinateType coordType, long *offset) {        \
+      long x, long y, enum IA2CoordinateType coordType, long* offset) {        \
     return Class::get_offsetAtPoint(x, y, coordType, offset);                  \
   }                                                                            \
                                                                                \
   virtual HRESULT STDMETHODCALLTYPE get_selection(                             \
-      long selectionIndex, long *startOffset, long *endOffset) {               \
+      long selectionIndex, long* startOffset, long* endOffset) {               \
     return Class::get_selection(selectionIndex, startOffset, endOffset);       \
   }                                                                            \
                                                                                \
   virtual HRESULT STDMETHODCALLTYPE get_text(long startOffset, long endOffset, \
-                                             BSTR *text) {                     \
+                                             BSTR* text) {                     \
     return Class::get_text(startOffset, endOffset, text);                      \
   }                                                                            \
                                                                                \
   virtual HRESULT STDMETHODCALLTYPE get_textBeforeOffset(                      \
-      long offset, enum IA2TextBoundaryType boundaryType, long *startOffset,   \
-      long *endOffset, BSTR *text) {                                           \
+      long offset, enum IA2TextBoundaryType boundaryType, long* startOffset,   \
+      long* endOffset, BSTR* text) {                                           \
     return Class::get_textBeforeOffset(offset, boundaryType, startOffset,      \
                                        endOffset, text);                       \
   }                                                                            \
                                                                                \
   virtual HRESULT STDMETHODCALLTYPE get_textAfterOffset(                       \
-      long offset, enum IA2TextBoundaryType boundaryType, long *startOffset,   \
-      long *endOffset, BSTR *text) {                                           \
+      long offset, enum IA2TextBoundaryType boundaryType, long* startOffset,   \
+      long* endOffset, BSTR* text) {                                           \
     return Class::get_textAfterOffset(offset, boundaryType, startOffset,       \
                                       endOffset, text);                        \
   }                                                                            \
                                                                                \
   virtual HRESULT STDMETHODCALLTYPE get_textAtOffset(                          \
-      long offset, enum IA2TextBoundaryType boundaryType, long *startOffset,   \
-      long *endOffset, BSTR *text) {                                           \
+      long offset, enum IA2TextBoundaryType boundaryType, long* startOffset,   \
+      long* endOffset, BSTR* text) {                                           \
     return Class::get_textAtOffset(offset, boundaryType, startOffset,          \
                                    endOffset, text);                           \
   }                                                                            \
                                                                                \
   virtual HRESULT STDMETHODCALLTYPE removeSelection(long selectionIndex) {     \
     return Class::removeSelection(selectionIndex);                             \
   }                                                                            \
                                                                                \
@@ -204,33 +204,33 @@ class ia2AccessibleText : public IAccess
     return Class::setCaretOffset(offset);                                      \
   }                                                                            \
                                                                                \
   virtual HRESULT STDMETHODCALLTYPE setSelection(                              \
       long selectionIndex, long startOffset, long endOffset) {                 \
     return Class::setSelection(selectionIndex, startOffset, endOffset);        \
   }                                                                            \
                                                                                \
-  virtual HRESULT STDMETHODCALLTYPE get_nCharacters(long *nCharacters) {       \
+  virtual HRESULT STDMETHODCALLTYPE get_nCharacters(long* nCharacters) {       \
     return Class::get_nCharacters(nCharacters);                                \
   }                                                                            \
                                                                                \
   virtual HRESULT STDMETHODCALLTYPE scrollSubstringTo(                         \
       long startIndex, long endIndex, enum IA2ScrollType scrollType) {         \
     return Class::scrollSubstringTo(startIndex, endIndex, scrollType);         \
   }                                                                            \
                                                                                \
   virtual HRESULT STDMETHODCALLTYPE scrollSubstringToPoint(                    \
       long startIndex, long endIndex, enum IA2CoordinateType coordinateType,   \
       long x, long y) {                                                        \
     return Class::scrollSubstringToPoint(startIndex, endIndex, coordinateType, \
                                          x, y);                                \
   }                                                                            \
                                                                                \
-  virtual HRESULT STDMETHODCALLTYPE get_newText(IA2TextSegment *newText) {     \
+  virtual HRESULT STDMETHODCALLTYPE get_newText(IA2TextSegment* newText) {     \
     return Class::get_newText(newText);                                        \
   }                                                                            \
                                                                                \
-  virtual HRESULT STDMETHODCALLTYPE get_oldText(IA2TextSegment *oldText) {     \
+  virtual HRESULT STDMETHODCALLTYPE get_oldText(IA2TextSegment* oldText) {     \
     return Class::get_oldText(oldText);                                        \
   }
 
 #endif
--- a/accessible/windows/ia2/ia2AccessibleValue.h
+++ b/accessible/windows/ia2/ia2AccessibleValue.h
@@ -11,28 +11,28 @@
 #include "AccessibleValue.h"
 
 namespace mozilla {
 namespace a11y {
 
 class ia2AccessibleValue : public IAccessibleValue {
  public:
   // IUnknown
-  STDMETHODIMP QueryInterface(REFIID, void **);
+  STDMETHODIMP QueryInterface(REFIID, void**);
 
   // IAccessibleValue
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_currentValue(
-      /* [retval][out] */ VARIANT *currentValue);
+      /* [retval][out] */ VARIANT* currentValue);
 
   virtual HRESULT STDMETHODCALLTYPE setCurrentValue(
       /* [in] */ VARIANT value);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_maximumValue(
-      /* [retval][out] */ VARIANT *maximumValue);
+      /* [retval][out] */ VARIANT* maximumValue);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_minimumValue(
-      /* [retval][out] */ VARIANT *minimumValue);
+      /* [retval][out] */ VARIANT* minimumValue);
 };
 
 }  // namespace a11y
 }  // namespace mozilla
 
 #endif
--- a/accessible/windows/msaa/AccessibleWrap.h
+++ b/accessible/windows/msaa/AccessibleWrap.h
@@ -32,215 +32,215 @@ namespace a11y {
 class DocProxyAccessibleWrap;
 
 class AccessibleWrap : public Accessible,
                        public ia2Accessible,
                        public ia2AccessibleComponent,
                        public ia2AccessibleHyperlink,
                        public ia2AccessibleValue {
  public:  // construction, destruction
-  AccessibleWrap(nsIContent *aContent, DocAccessible *aDoc);
+  AccessibleWrap(nsIContent* aContent, DocAccessible* aDoc);
 
   // nsISupports
   NS_DECL_ISUPPORTS_INHERITED
 
  public:  // IUnknown methods - see iunknown.h for documentation
-  STDMETHODIMP QueryInterface(REFIID, void **) override;
+  STDMETHODIMP QueryInterface(REFIID, void**) override;
 
   // Return the registered OLE class ID of this object's CfDataObj.
   CLSID GetClassID() const;
 
  public:  // COM interface IAccessible
   virtual /* [id][propget] */ HRESULT STDMETHODCALLTYPE get_accParent(
-      /* [retval][out] */ IDispatch __RPC_FAR *__RPC_FAR *ppdispParent)
+      /* [retval][out] */ IDispatch __RPC_FAR* __RPC_FAR* ppdispParent)
       override;
 
   virtual /* [id][propget] */ HRESULT STDMETHODCALLTYPE get_accChildCount(
-      /* [retval][out] */ long __RPC_FAR *pcountChildren) override;
+      /* [retval][out] */ long __RPC_FAR* pcountChildren) override;
 
   virtual /* [id][propget] */ HRESULT STDMETHODCALLTYPE get_accChild(
       /* [in] */ VARIANT varChild,
-      /* [retval][out] */ IDispatch __RPC_FAR *__RPC_FAR *ppdispChild) override;
+      /* [retval][out] */ IDispatch __RPC_FAR* __RPC_FAR* ppdispChild) override;
 
   virtual /* [id][propget] */ HRESULT STDMETHODCALLTYPE get_accName(
       /* [optional][in] */ VARIANT varChild,
-      /* [retval][out] */ BSTR __RPC_FAR *pszName) override;
+      /* [retval][out] */ BSTR __RPC_FAR* pszName) override;
 
   virtual /* [id][propget] */ HRESULT STDMETHODCALLTYPE get_accValue(
       /* [optional][in] */ VARIANT varChild,
-      /* [retval][out] */ BSTR __RPC_FAR *pszValue) override;
+      /* [retval][out] */ BSTR __RPC_FAR* pszValue) override;
 
   virtual /* [id][propget] */ HRESULT STDMETHODCALLTYPE get_accDescription(
       /* [optional][in] */ VARIANT varChild,
-      /* [retval][out] */ BSTR __RPC_FAR *pszDescription) override;
+      /* [retval][out] */ BSTR __RPC_FAR* pszDescription) override;
 
   virtual /* [id][propget] */ HRESULT STDMETHODCALLTYPE get_accRole(
       /* [optional][in] */ VARIANT varChild,
-      /* [retval][out] */ VARIANT __RPC_FAR *pvarRole) override;
+      /* [retval][out] */ VARIANT __RPC_FAR* pvarRole) override;
 
   virtual /* [id][propget] */ HRESULT STDMETHODCALLTYPE get_accState(
       /* [optional][in] */ VARIANT varChild,
-      /* [retval][out] */ VARIANT __RPC_FAR *pvarState) override;
+      /* [retval][out] */ VARIANT __RPC_FAR* pvarState) override;
 
   virtual /* [id][propget] */ HRESULT STDMETHODCALLTYPE get_accHelp(
       /* [optional][in] */ VARIANT varChild,
-      /* [retval][out] */ BSTR __RPC_FAR *pszHelp) override;
+      /* [retval][out] */ BSTR __RPC_FAR* pszHelp) override;
 
   virtual /* [id][propget] */ HRESULT STDMETHODCALLTYPE get_accHelpTopic(
-      /* [out] */ BSTR __RPC_FAR *pszHelpFile,
+      /* [out] */ BSTR __RPC_FAR* pszHelpFile,
       /* [optional][in] */ VARIANT varChild,
-      /* [retval][out] */ long __RPC_FAR *pidTopic) override;
+      /* [retval][out] */ long __RPC_FAR* pidTopic) override;
 
   virtual /* [id][propget] */ HRESULT STDMETHODCALLTYPE get_accKeyboardShortcut(
       /* [optional][in] */ VARIANT varChild,
-      /* [retval][out] */ BSTR __RPC_FAR *pszKeyboardShortcut) override;
+      /* [retval][out] */ BSTR __RPC_FAR* pszKeyboardShortcut) override;
 
   virtual /* [id][propget] */ HRESULT STDMETHODCALLTYPE get_accFocus(
-      /* [retval][out] */ VARIANT __RPC_FAR *pvarChild) override;
+      /* [retval][out] */ VARIANT __RPC_FAR* pvarChild) override;
 
   virtual /* [id][propget] */ HRESULT STDMETHODCALLTYPE get_accSelection(
-      /* [retval][out] */ VARIANT __RPC_FAR *pvarChildren) override;
+      /* [retval][out] */ VARIANT __RPC_FAR* pvarChildren) override;
 
   virtual /* [id][propget] */ HRESULT STDMETHODCALLTYPE get_accDefaultAction(
       /* [optional][in] */ VARIANT varChild,
-      /* [retval][out] */ BSTR __RPC_FAR *pszDefaultAction) override;
+      /* [retval][out] */ BSTR __RPC_FAR* pszDefaultAction) override;
 
   virtual /* [id] */ HRESULT STDMETHODCALLTYPE accSelect(
       /* [in] */ long flagsSelect,
       /* [optional][in] */ VARIANT varChild) override;
 
   virtual /* [id] */ HRESULT STDMETHODCALLTYPE accLocation(
-      /* [out] */ long __RPC_FAR *pxLeft,
-      /* [out] */ long __RPC_FAR *pyTop,
-      /* [out] */ long __RPC_FAR *pcxWidth,
-      /* [out] */ long __RPC_FAR *pcyHeight,
+      /* [out] */ long __RPC_FAR* pxLeft,
+      /* [out] */ long __RPC_FAR* pyTop,
+      /* [out] */ long __RPC_FAR* pcxWidth,
+      /* [out] */ long __RPC_FAR* pcyHeight,
       /* [optional][in] */ VARIANT varChild) override;
 
   virtual /* [id] */ HRESULT STDMETHODCALLTYPE accNavigate(
       /* [in] */ long navDir,
       /* [optional][in] */ VARIANT varStart,
-      /* [retval][out] */ VARIANT __RPC_FAR *pvarEndUpAt) override;
+      /* [retval][out] */ VARIANT __RPC_FAR* pvarEndUpAt) override;
 
   virtual /* [id] */ HRESULT STDMETHODCALLTYPE accHitTest(
       /* [in] */ long xLeft,
       /* [in] */ long yTop,
-      /* [retval][out] */ VARIANT __RPC_FAR *pvarChild) override;
+      /* [retval][out] */ VARIANT __RPC_FAR* pvarChild) override;
 
   virtual /* [id] */ HRESULT STDMETHODCALLTYPE accDoDefaultAction(
       /* [optional][in] */ VARIANT varChild) override;
 
   virtual /* [id][propput] */ HRESULT STDMETHODCALLTYPE put_accName(
       /* [optional][in] */ VARIANT varChild,
       /* [in] */ BSTR szName) override;
 
   virtual /* [id][propput] */ HRESULT STDMETHODCALLTYPE put_accValue(
       /* [optional][in] */ VARIANT varChild,
       /* [in] */ BSTR szValue) override;
 
   // IDispatch (support of scripting languages like VB)
-  virtual HRESULT STDMETHODCALLTYPE GetTypeInfoCount(UINT *pctinfo) override;
+  virtual HRESULT STDMETHODCALLTYPE GetTypeInfoCount(UINT* pctinfo) override;
 
   virtual HRESULT STDMETHODCALLTYPE GetTypeInfo(UINT iTInfo, LCID lcid,
-                                                ITypeInfo **ppTInfo) override;
+                                                ITypeInfo** ppTInfo) override;
 
   virtual HRESULT STDMETHODCALLTYPE GetIDsOfNames(REFIID riid,
-                                                  LPOLESTR *rgszNames,
+                                                  LPOLESTR* rgszNames,
                                                   UINT cNames, LCID lcid,
-                                                  DISPID *rgDispId) override;
+                                                  DISPID* rgDispId) override;
 
   virtual HRESULT STDMETHODCALLTYPE Invoke(DISPID dispIdMember, REFIID riid,
                                            LCID lcid, WORD wFlags,
-                                           DISPPARAMS *pDispParams,
-                                           VARIANT *pVarResult,
-                                           EXCEPINFO *pExcepInfo,
-                                           UINT *puArgErr) override;
+                                           DISPPARAMS* pDispParams,
+                                           VARIANT* pVarResult,
+                                           EXCEPINFO* pExcepInfo,
+                                           UINT* puArgErr) override;
 
   // Accessible
-  virtual nsresult HandleAccEvent(AccEvent *aEvent) override;
+  virtual nsresult HandleAccEvent(AccEvent* aEvent) override;
   virtual void Shutdown() override;
 
   // Helper methods
-  static int32_t GetChildIDFor(Accessible *aAccessible);
-  static HWND GetHWNDFor(Accessible *aAccessible);
+  static int32_t GetChildIDFor(Accessible* aAccessible);
+  static HWND GetHWNDFor(Accessible* aAccessible);
 
-  static void FireWinEvent(Accessible *aTarget, uint32_t aEventType);
+  static void FireWinEvent(Accessible* aTarget, uint32_t aEventType);
 
   /**
    * System caret support: update the Windows caret position.
    * The system caret works more universally than the MSAA caret
    * For example, Window-Eyes, JAWS, ZoomText and Windows Tablet Edition use it
    * We will use an invisible system caret.
    * Gecko is still responsible for drawing its own caret
    */
-  void UpdateSystemCaretFor(Accessible *aAccessible);
-  static void UpdateSystemCaretFor(ProxyAccessible *aProxy,
-                                   const LayoutDeviceIntRect &aCaretRect);
+  void UpdateSystemCaretFor(Accessible* aAccessible);
+  static void UpdateSystemCaretFor(ProxyAccessible* aProxy,
+                                   const LayoutDeviceIntRect& aCaretRect);
 
  private:
   static void UpdateSystemCaretFor(HWND aCaretWnd,
-                                   const LayoutDeviceIntRect &aCaretRect);
+                                   const LayoutDeviceIntRect& aCaretRect);
 
  public:
   /**
    * Determine whether this is the root accessible for its HWND.
    */
   bool IsRootForHWND();
 
   /**
    * Find an accessible by the given child ID in cached documents.
    */
   MOZ_MUST_USE already_AddRefed<IAccessible> GetIAccessibleFor(
-      const VARIANT &aVarChild, bool *aIsDefunct);
+      const VARIANT& aVarChild, bool* aIsDefunct);
 
-  virtual void GetNativeInterface(void **aOutAccessible) override;
+  virtual void GetNativeInterface(void** aOutAccessible) override;
 
-  static IDispatch *NativeAccessible(Accessible *aAccessible);
+  static IDispatch* NativeAccessible(Accessible* aAccessible);
 
   uint32_t GetExistingID() const { return mID; }
   static const uint32_t kNoID = 0;
   void SetID(uint32_t aID);
 
   static uint32_t GetContentProcessIdFor(dom::ContentParentId aIPCContentId);
   static void ReleaseContentProcessIdFor(dom::ContentParentId aIPCContentId);
 
   static void SetHandlerControl(DWORD aPid, RefPtr<IHandlerControl> aCtrl);
 
   static void InvalidateHandlers();
 
-  bool DispatchTextChangeToHandler(bool aIsInsert, const nsString &aText,
+  bool DispatchTextChangeToHandler(bool aIsInsert, const nsString& aText,
                                    int32_t aStart, uint32_t aLen);
 
-  static void AssignChildIDTo(NotNull<sdnAccessible *> aSdnAcc);
-  static void ReleaseChildID(NotNull<sdnAccessible *> aSdnAcc);
+  static void AssignChildIDTo(NotNull<sdnAccessible*> aSdnAcc);
+  static void ReleaseChildID(NotNull<sdnAccessible*> aSdnAcc);
 
  protected:
   virtual ~AccessibleWrap();
 
   uint32_t mID;
 
   HRESULT
-  ResolveChild(const VARIANT &aVarChild, IAccessible **aOutInterface);
+  ResolveChild(const VARIANT& aVarChild, IAccessible** aOutInterface);
 
   /**
    * Find a remote accessible by the given child ID.
    */
   MOZ_MUST_USE already_AddRefed<IAccessible> GetRemoteIAccessibleFor(
-      const VARIANT &aVarChild);
+      const VARIANT& aVarChild);
 
   /**
    * Return the wrapper for the document's proxy.
    */
-  DocProxyAccessibleWrap *DocProxyWrapper() const;
+  DocProxyAccessibleWrap* DocProxyWrapper() const;
 
   /**
    * Creates ITypeInfo for LIBID_Accessibility if it's needed and returns it.
    */
-  static ITypeInfo *GetTI(LCID lcid);
+  static ITypeInfo* GetTI(LCID lcid);
 
-  static ITypeInfo *gTypeInfo;
+  static ITypeInfo* gTypeInfo;
 
   static MsaaIdGenerator sIDGen;
 
   enum navRelations {
     NAVRELATION_CONTROLLED_BY = 0x1000,
     NAVRELATION_CONTROLLER_FOR = 0x1001,
     NAVRELATION_LABEL_FOR = 0x1002,
     NAVRELATION_LABELLED_BY = 0x1003,
@@ -263,42 +263,42 @@ class AccessibleWrap : public Accessible
     NAVRELATION_CONTAINING_APPLICATION = 0x1014,
     NAVRELATION_DETAILS = 0x1015,
     NAVRELATION_DETAILS_FOR = 0x1016,
     NAVRELATION_ERROR = 0x1017,
     NAVRELATION_ERROR_FOR = 0x1018
   };
 
   struct HandlerControllerData final {
-    HandlerControllerData(DWORD aPid, RefPtr<IHandlerControl> &&aCtrl)
+    HandlerControllerData(DWORD aPid, RefPtr<IHandlerControl>&& aCtrl)
         : mPid(aPid), mCtrl(std::move(aCtrl)) {
       mIsProxy = mozilla::mscom::IsProxy(mCtrl);
     }
 
-    HandlerControllerData(HandlerControllerData &&aOther)
+    HandlerControllerData(HandlerControllerData&& aOther)
         : mPid(aOther.mPid),
           mIsProxy(aOther.mIsProxy),
           mCtrl(std::move(aOther.mCtrl)) {}
 
-    bool operator==(const HandlerControllerData &aOther) const {
+    bool operator==(const HandlerControllerData& aOther) const {
       return mPid == aOther.mPid;
     }
 
-    bool operator==(const DWORD &aPid) const { return mPid == aPid; }
+    bool operator==(const DWORD& aPid) const { return mPid == aPid; }
 
     DWORD mPid;
     bool mIsProxy;
     RefPtr<IHandlerControl> mCtrl;
   };
 
   static StaticAutoPtr<nsTArray<HandlerControllerData>> sHandlerControllers;
 };
 
-static inline AccessibleWrap *WrapperFor(const ProxyAccessible *aProxy) {
-  return reinterpret_cast<AccessibleWrap *>(aProxy->GetWrapper());
+static inline AccessibleWrap* WrapperFor(const ProxyAccessible* aProxy) {
+  return reinterpret_cast<AccessibleWrap*>(aProxy->GetWrapper());
 }
 
 }  // namespace a11y
 }  // namespace mozilla
 
 #ifdef XP_WIN
 // Undo the windows.h damage
 #  undef GetMessage
--- a/accessible/windows/msaa/ApplicationAccessibleWrap.h
+++ b/accessible/windows/msaa/ApplicationAccessibleWrap.h
@@ -22,28 +22,28 @@ class ApplicationAccessibleWrap : public
  public:
   // nsISupporst
   NS_DECL_ISUPPORTS_INHERITED
 
   // nsAccessible
   virtual already_AddRefed<nsIPersistentProperties> NativeAttributes() override;
 
   // IUnknown
-  STDMETHODIMP QueryInterface(REFIID, void **);
+  STDMETHODIMP QueryInterface(REFIID, void**);
 
   // IAccessibleApplication
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_appName(
-      /* [retval][out] */ BSTR *name);
+      /* [retval][out] */ BSTR* name);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_appVersion(
-      /* [retval][out] */ BSTR *version);
+      /* [retval][out] */ BSTR* version);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_toolkitName(
-      /* [retval][out] */ BSTR *name);
+      /* [retval][out] */ BSTR* name);
 
   virtual /* [propget] */ HRESULT STDMETHODCALLTYPE get_toolkitVersion(
-      /* [retval][out] */ BSTR *version);
+      /* [retval][out] */ BSTR* version);
 };
 
 }  // namespace a11y
 }  // namespace mozilla
 
 #endif
--- a/accessible/windows/msaa/LazyInstantiator.cpp
+++ b/accessible/windows/msaa/LazyInstantiator.cpp
@@ -35,17 +35,17 @@ static const wchar_t kLazyInstantiatorPr
     L"mozilla::a11y::LazyInstantiator";
 
 /* static */
 already_AddRefed<IAccessible> LazyInstantiator::GetRootAccessible(HWND aHwnd) {
   // There must only be one LazyInstantiator per HWND.
   // To track this, we set the kLazyInstantiatorProp on the HWND with a pointer
   // to an existing instance. We only create a new LazyInstatiator if that prop
   // has not already been set.
-  LazyInstantiator *existingInstantiator = reinterpret_cast<LazyInstantiator *>(
+  LazyInstantiator* existingInstantiator = reinterpret_cast<LazyInstantiator*>(
       ::GetProp(aHwnd, kLazyInstantiatorProp));
 
   RefPtr<IAccessible> result;
   if (existingInstantiator) {
     // Temporarily disable blind aggregation until we know that we have been
     // marshaled. See EnableBlindAggregation for more information.
     existingInstantiator->mAllowBlindAggregation = false;
     result = existingInstantiator;
@@ -58,35 +58,35 @@ already_AddRefed<IAccessible> LazyInstan
     // a11y is not running yet, there are no existing LazyInstantiators for this
     // HWND, so create a new one and return it as a surrogate for the root
     // accessible.
     result = new LazyInstantiator(aHwnd);
     return result.forget();
   }
 
   // a11y is running, so we just resolve the real root accessible.
-  a11y::Accessible *rootAcc = widget::WinUtils::GetRootAccessibleForHWND(aHwnd);
+  a11y::Accessible* rootAcc = widget::WinUtils::GetRootAccessibleForHWND(aHwnd);
   if (!rootAcc) {
     return nullptr;
   }
 
   if (!rootAcc->IsRoot()) {
     // rootAcc might represent a popup as opposed to a true root accessible.
     // In that case we just use the regular Accessible::GetNativeInterface.
     rootAcc->GetNativeInterface(getter_AddRefs(result));
     return result.forget();
   }
 
   // Subtle: rootAcc might still be wrapped by a LazyInstantiator, but we
   // don't need LazyInstantiator's capabilities anymore (since a11y is already
   // running). We can bypass LazyInstantiator by retrieving the internal
   // unknown (which is not wrapped by the LazyInstantiator) and then querying
   // that for IID_IAccessible.
-  a11y::RootAccessibleWrap *rootWrap =
-      static_cast<a11y::RootAccessibleWrap *>(rootAcc);
+  a11y::RootAccessibleWrap* rootWrap =
+      static_cast<a11y::RootAccessibleWrap*>(rootAcc);
   RefPtr<IUnknown> punk(rootWrap->GetInternalUnknown());
 
   MOZ_ASSERT(punk);
   if (!punk) {
     return nullptr;
   }
 
   punk->QueryInterface(IID_IAccessible, getter_AddRefs(result));
@@ -98,17 +98,17 @@ already_AddRefed<IAccessible> LazyInstan
  * calls to determine what kind of marshaling the interface supports. We need
  * to handle those queries without instantiating a11y, so we temporarily
  * disable passing through of QueryInterface calls to a11y. Once we know that
  * COM is finished marshaling, we call EnableBlindAggregation to re-enable
  * QueryInterface passthrough.
  */
 /* static */
 void LazyInstantiator::EnableBlindAggregation(HWND aHwnd) {
-  LazyInstantiator *existingInstantiator = reinterpret_cast<LazyInstantiator *>(
+  LazyInstantiator* existingInstantiator = reinterpret_cast<LazyInstantiator*>(
       ::GetProp(aHwnd, kLazyInstantiatorProp));
 
   if (!existingInstantiator) {
     return;
   }
 
   existingInstantiator->mAllowBlindAggregation = true;
 }
@@ -134,17 +134,17 @@ LazyInstantiator::~LazyInstantiator() {
 
   ClearProp();
 }
 
 void LazyInstantiator::ClearProp() {
   // Remove ourselves as the designated LazyInstantiator for mHwnd
   DebugOnly<HANDLE> removedProp = ::RemoveProp(mHwnd, kLazyInstantiatorProp);
   MOZ_ASSERT(!removedProp ||
-             reinterpret_cast<LazyInstantiator *>(removedProp.value) == this);
+             reinterpret_cast<LazyInstantiator*>(removedProp.value) == this);
 }
 
 /**
  * Given the remote client's thread ID, resolve its process ID.
  */
 DWORD
 LazyInstantiator::GetClientPid(const DWORD aClientTid) {
   nsAutoHandle callingThread(
@@ -155,17 +155,17 @@ LazyInstantiator::GetClientPid(const DWO
 
   return ::GetProcessIdOfThread(callingThread);
 }
 
 #define ALL_VERSIONS ((unsigned long long)-1LL)
 
 struct DllBlockInfo {
   // The name of the DLL.
-  const wchar_t *mName;
+  const wchar_t* mName;
 
   // If mUntilVersion is ALL_VERSIONS, we'll block all versions of this dll.
   // Otherwise, we'll block all versions less than the given version, as queried
   // by GetFileVersionInfo and VS_FIXEDFILEINFO's dwFileVersionMS and
   // dwFileVersionLS fields.
   //
   // Note that the version is usually 4 components, which is A.B.C.D
   // encoded as 0x AAAA BBBB CCCC DDDD ULL (spaces added for clarity).
@@ -179,17 +179,17 @@ static const DllBlockInfo gBlockedInproc
     // RealPlayer, bug 1418535, bug 1437417
     // Versions before 18.1.11.0 cause severe performance problems.
     {L"dtvhooks.dll", MAKE_FILE_VERSION(18, 1, 11, 0)},
     {L"dtvhooks64.dll", MAKE_FILE_VERSION(18, 1, 11, 0)}};
 
 /**
  * This is the blocklist for known "bad" remote clients that instantiate a11y.
  */
-static const char *gBlockedRemoteClients[] = {
+static const char* gBlockedRemoteClients[] = {
     "tbnotifier.exe"  // Ask.com Toolbar, bug 1453876
 };
 
 /**
  * Check for the presence of any known "bad" injected DLLs that may be trying
  * to instantiate a11y.
  *
  * @return true to block a11y instantiation, otherwise false to continue
@@ -202,17 +202,17 @@ bool LazyInstantiator::IsBlockedInjectio
 
   if (Compatibility::HasKnownNonUiaConsumer()) {
     // If we already see a known AT, don't block a11y instantiation
     return false;
   }
 
   for (size_t index = 0, len = ArrayLength(gBlockedInprocDlls); index < len;
        ++index) {
-    const DllBlockInfo &blockedDll = gBlockedInprocDlls[index];
+    const DllBlockInfo& blockedDll = gBlockedInprocDlls[index];
     HMODULE module = ::GetModuleHandleW(blockedDll.mName);
     if (!module) {
       // This dll isn't loaded.
       continue;
     }
     if (blockedDll.mUntilVersion == ALL_VERSIONS) {
       return true;
     }
@@ -260,23 +260,23 @@ bool LazyInstantiator::ShouldInstantiate
         }
       }
     }
   }
 
   return true;
 }
 
-RootAccessibleWrap *LazyInstantiator::ResolveRootAccWrap() {
-  Accessible *acc = widget::WinUtils::GetRootAccessibleForHWND(mHwnd);
+RootAccessibleWrap* LazyInstantiator::ResolveRootAccWrap() {
+  Accessible* acc = widget::WinUtils::GetRootAccessibleForHWND(mHwnd);
   if (!acc || !acc->IsRoot()) {
     return nullptr;
   }
 
-  return static_cast<RootAccessibleWrap *>(acc);
+  return static_cast<RootAccessibleWrap*>(acc);
 }
 
 /**
  * With COM aggregation, the aggregated inner object usually delegates its
  * reference counting to the outer object. In other words, we would expect
  * mRealRootUnk to delegate its AddRef() and Release() to this LazyInstantiator.
  *
  * This scheme will not work in our case because the RootAccessibleWrap is
@@ -315,30 +315,29 @@ LazyInstantiator::MaybeResolveRoot() {
   if (GetAccService() ||
       ShouldInstantiate(mscom::ProcessRuntime::GetClientThreadId())) {
     mWeakRootAccWrap = ResolveRootAccWrap();
     if (!mWeakRootAccWrap) {
       return E_POINTER;
     }
 
     // Wrap ourselves around the root accessible wrap
-    mRealRootUnk =
-        mWeakRootAccWrap->Aggregate(static_cast<IAccessible *>(this));
+    mRealRootUnk = mWeakRootAccWrap->Aggregate(static_cast<IAccessible*>(this));
     if (!mRealRootUnk) {
       return E_FAIL;
     }
 
     // Move our strong references into the root accessible (see the comments
     // above TransplantRefCnt for explanation).
     TransplantRefCnt();
 
     // Now obtain mWeakAccessible which we use to forward our incoming calls
     // to the real accesssible.
-    HRESULT hr = mRealRootUnk->QueryInterface(IID_IAccessible,
-                                              (void **)&mWeakAccessible);
+    HRESULT hr =
+        mRealRootUnk->QueryInterface(IID_IAccessible, (void**)&mWeakAccessible);
     if (FAILED(hr)) {
       return hr;
     }
 
     // mWeakAccessible is weak, so don't hold a strong ref
     mWeakAccessible->Release();
 
     // Now that a11y is running, we don't need to remain registered with our
@@ -361,17 +360,17 @@ LazyInstantiator::MaybeResolveRoot() {
   if (FAILED(hr)) {
     return hr;
   }
 
   if (!mRealRootUnk) {
     return E_NOTIMPL;
   }
 
-  hr = mRealRootUnk->QueryInterface(IID_IAccessible, (void **)&mWeakAccessible);
+  hr = mRealRootUnk->QueryInterface(IID_IAccessible, (void**)&mWeakAccessible);
   if (FAILED(hr)) {
     return hr;
   }
 
   // mWeakAccessible is weak, so don't hold a strong ref
   mWeakAccessible->Release();
 
   return S_OK;
@@ -455,24 +454,24 @@ LazyInstantiator::ResolveDispatch() {
   RefPtr<ITypeInfo> accTypeInfo;
   HRESULT hr =
       typelib->GetTypeInfoForGuid(IID_IAccessible, getter_AddRefs(accTypeInfo));
   if (FAILED(hr)) {
     return hr;
   }
 
   // Now create the standard IDispatch for IAccessible
-  hr = ::CreateStdDispatch(static_cast<IAccessible *>(this),
-                           static_cast<IAccessible *>(this), accTypeInfo,
+  hr = ::CreateStdDispatch(static_cast<IAccessible*>(this),
+                           static_cast<IAccessible*>(this), accTypeInfo,
                            getter_AddRefs(mStdDispatch));
   if (FAILED(hr)) {
     return hr;
   }
 
-  hr = mStdDispatch->QueryInterface(IID_IDispatch, (void **)&mWeakDispatch);
+  hr = mStdDispatch->QueryInterface(IID_IDispatch, (void**)&mWeakDispatch);
   if (FAILED(hr)) {
     return hr;
   }
 
   // WEAK reference
   mWeakDispatch->Release();
   return S_OK;
 }
@@ -486,201 +485,201 @@ LazyInstantiator::ResolveDispatch() {
   }
 
 /**
  * The remaining methods implement IDispatch, IAccessible, and IServiceProvider,
  * lazily resolving the real a11y objects and passing the call through.
  */
 
 HRESULT
-LazyInstantiator::GetTypeInfoCount(UINT *pctinfo) {
+LazyInstantiator::GetTypeInfoCount(UINT* pctinfo) {
   RESOLVE_IDISPATCH;
   return mWeakDispatch->GetTypeInfoCount(pctinfo);
 }
 
 HRESULT
-LazyInstantiator::GetTypeInfo(UINT iTInfo, LCID lcid, ITypeInfo **ppTInfo) {
+LazyInstantiator::GetTypeInfo(UINT iTInfo, LCID lcid, ITypeInfo** ppTInfo) {
   RESOLVE_IDISPATCH;
   return mWeakDispatch->GetTypeInfo(iTInfo, lcid, ppTInfo);
 }
 
 HRESULT
-LazyInstantiator::GetIDsOfNames(REFIID riid, LPOLESTR *rgszNames, UINT cNames,
-                                LCID lcid, DISPID *rgDispId) {
+LazyInstantiator::GetIDsOfNames(REFIID riid, LPOLESTR* rgszNames, UINT cNames,
+                                LCID lcid, DISPID* rgDispId) {
   RESOLVE_IDISPATCH;
   return mWeakDispatch->GetIDsOfNames(riid, rgszNames, cNames, lcid, rgDispId);
 }
 
 HRESULT
 LazyInstantiator::Invoke(DISPID dispIdMember, REFIID riid, LCID lcid,
-                         WORD wFlags, DISPPARAMS *pDispParams,
-                         VARIANT *pVarResult, EXCEPINFO *pExcepInfo,
-                         UINT *puArgErr) {
+                         WORD wFlags, DISPPARAMS* pDispParams,
+                         VARIANT* pVarResult, EXCEPINFO* pExcepInfo,
+                         UINT* puArgErr) {
   RESOLVE_IDISPATCH;
   return mWeakDispatch->Invoke(dispIdMember, riid, lcid, wFlags, pDispParams,
                                pVarResult, pExcepInfo, puArgErr);
 }
 
 HRESULT
-LazyInstantiator::get_accParent(IDispatch **ppdispParent) {
+LazyInstantiator::get_accParent(IDispatch** ppdispParent) {
   RESOLVE_ROOT;
   return mWeakAccessible->get_accParent(ppdispParent);
 }
 
 HRESULT
-LazyInstantiator::get_accChildCount(long *pcountChildren) {
+LazyInstantiator::get_accChildCount(long* pcountChildren) {
   if (!pcountChildren) {
     return E_INVALIDARG;
   }
 
   RESOLVE_ROOT;
   return mWeakAccessible->get_accChildCount(pcountChildren);
 }
 
 HRESULT
-LazyInstantiator::get_accChild(VARIANT varChild, IDispatch **ppdispChild) {
+LazyInstantiator::get_accChild(VARIANT varChild, IDispatch** ppdispChild) {
   if (!ppdispChild) {
     return E_INVALIDARG;
   }
 
   RESOLVE_ROOT;
   return mWeakAccessible->get_accChild(varChild, ppdispChild);
 }
 
 HRESULT
-LazyInstantiator::get_accName(VARIANT varChild, BSTR *pszName) {
+LazyInstantiator::get_accName(VARIANT varChild, BSTR* pszName) {
   if (!pszName) {
     return E_INVALIDARG;
   }
 
   RESOLVE_ROOT;
   return mWeakAccessible->get_accName(varChild, pszName);
 }
 
 HRESULT
-LazyInstantiator::get_accValue(VARIANT varChild, BSTR *pszValue) {
+LazyInstantiator::get_accValue(VARIANT varChild, BSTR* pszValue) {
   if (!pszValue) {
     return E_INVALIDARG;
   }
 
   RESOLVE_ROOT;
   return mWeakAccessible->get_accValue(varChild, pszValue);
 }
 
 HRESULT
-LazyInstantiator::get_accDescription(VARIANT varChild, BSTR *pszDescription) {
+LazyInstantiator::get_accDescription(VARIANT varChild, BSTR* pszDescription) {
   if (!pszDescription) {
     return E_INVALIDARG;
   }
 
   RESOLVE_ROOT;
   return mWeakAccessible->get_accDescription(varChild, pszDescription);
 }
 
 HRESULT
-LazyInstantiator::get_accRole(VARIANT varChild, VARIANT *pvarRole) {
+LazyInstantiator::get_accRole(VARIANT varChild, VARIANT* pvarRole) {
   if (!pvarRole) {
     return E_INVALIDARG;
   }
 
   RESOLVE_ROOT;
   return mWeakAccessible->get_accRole(varChild, pvarRole);
 }
 
 HRESULT
-LazyInstantiator::get_accState(VARIANT varChild, VARIANT *pvarState) {
+LazyInstantiator::get_accState(VARIANT varChild, VARIANT* pvarState) {
   if (!pvarState) {
     return E_INVALIDARG;
   }
 
   RESOLVE_ROOT;
   return mWeakAccessible->get_accState(varChild, pvarState);
 }
 
 HRESULT
-LazyInstantiator::get_accHelp(VARIANT varChild, BSTR *pszHelp) {
+LazyInstantiator::get_accHelp(VARIANT varChild, BSTR* pszHelp) {
   return E_NOTIMPL;
 }
 
 HRESULT
-LazyInstantiator::get_accHelpTopic(BSTR *pszHelpFile, VARIANT varChild,
-                                   long *pidTopic) {
+LazyInstantiator::get_accHelpTopic(BSTR* pszHelpFile, VARIANT varChild,
+                                   long* pidTopic) {
   return E_NOTIMPL;
 }
 
 HRESULT
 LazyInstantiator::get_accKeyboardShortcut(VARIANT varChild,
-                                          BSTR *pszKeyboardShortcut) {
+                                          BSTR* pszKeyboardShortcut) {
   if (!pszKeyboardShortcut) {
     return E_INVALIDARG;
   }
 
   RESOLVE_ROOT;
   return mWeakAccessible->get_accKeyboardShortcut(varChild,
                                                   pszKeyboardShortcut);
 }
 
 HRESULT
-LazyInstantiator::get_accFocus(VARIANT *pvarChild) {
+LazyInstantiator::get_accFocus(VARIANT* pvarChild) {
   if (!pvarChild) {
     return E_INVALIDARG;
   }
 
   RESOLVE_ROOT;
   return mWeakAccessible->get_accFocus(pvarChild);
 }
 
 HRESULT
-LazyInstantiator::get_accSelection(VARIANT *pvarChildren) {
+LazyInstantiator::get_accSelection(VARIANT* pvarChildren) {
   if (!pvarChildren) {
     return E_INVALIDARG;
   }
 
   RESOLVE_ROOT;
   return mWeakAccessible->get_accSelection(pvarChildren);
 }
 
 HRESULT
 LazyInstantiator::get_accDefaultAction(VARIANT varChild,
-                                       BSTR *pszDefaultAction) {
+                                       BSTR* pszDefaultAction) {
   if (!pszDefaultAction) {
     return E_INVALIDARG;
   }
 
   RESOLVE_ROOT;
   return mWeakAccessible->get_accDefaultAction(varChild, pszDefaultAction);
 }
 
 HRESULT
 LazyInstantiator::accSelect(long flagsSelect, VARIANT varChild) {
   RESOLVE_ROOT;
   return mWeakAccessible->accSelect(flagsSelect, varChild);
 }
 
 HRESULT
-LazyInstantiator::accLocation(long *pxLeft, long *pyTop, long *pcxWidth,
-                              long *pcyHeight, VARIANT varChild) {
+LazyInstantiator::accLocation(long* pxLeft, long* pyTop, long* pcxWidth,
+                              long* pcyHeight, VARIANT varChild) {
   RESOLVE_ROOT;
   return mWeakAccessible->accLocation(pxLeft, pyTop, pcxWidth, pcyHeight,
                                       varChild);
 }
 
 HRESULT
 LazyInstantiator::accNavigate(long navDir, VARIANT varStart,
-                              VARIANT *pvarEndUpAt) {
+                              VARIANT* pvarEndUpAt) {
   if (!pvarEndUpAt) {
     return E_INVALIDARG;
   }
 
   RESOLVE_ROOT;
   return mWeakAccessible->accNavigate(navDir, varStart, pvarEndUpAt);
 }
 
 HRESULT
-LazyInstantiator::accHitTest(long xLeft, long yTop, VARIANT *pvarChild) {
+LazyInstantiator::accHitTest(long xLeft, long yTop, VARIANT* pvarChild) {
   if (!pvarChild) {
     return E_INVALIDARG;
   }
 
   RESOLVE_ROOT;
   return mWeakAccessible->accHitTest(xLeft, yTop, pvarChild);
 }
 
@@ -697,17 +696,17 @@ LazyInstantiator::put_accName(VARIANT va
 
 HRESULT
 LazyInstantiator::put_accValue(VARIANT varChild, BSTR szValue) {
   return E_NOTIMPL;
 }
 
 HRESULT
 LazyInstantiator::QueryService(REFGUID aServiceId, REFIID aServiceIid,
-                               void **aOutInterface) {
+                               void** aOutInterface) {
   if (!aOutInterface) {
     return E_INVALIDARG;
   }
 
   *aOutInterface = nullptr;
 
   RESOLVE_ROOT;
 
--- a/accessible/windows/msaa/LazyInstantiator.h
+++ b/accessible/windows/msaa/LazyInstantiator.h
@@ -30,62 +30,62 @@ class RootAccessibleWrap;
  * (2) LazyInstantiator::ShouldInstantiate returns true.
  */
 class LazyInstantiator final : public IAccessible, public IServiceProvider {
  public:
   static already_AddRefed<IAccessible> GetRootAccessible(HWND aHwnd);
   static void EnableBlindAggregation(HWND aHwnd);
 
   // IUnknown
-  STDMETHODIMP QueryInterface(REFIID aIid, void **aOutInterface) override;
+  STDMETHODIMP QueryInterface(REFIID aIid, void** aOutInterface) override;
   STDMETHODIMP_(ULONG) AddRef() override;
   STDMETHODIMP_(ULONG) Release() override;
 
   // IDispatch
-  STDMETHODIMP GetTypeInfoCount(UINT *pctinfo) override;
+  STDMETHODIMP GetTypeInfoCount(UINT* pctinfo) override;
   STDMETHODIMP GetTypeInfo(UINT iTInfo, LCID lcid,
-                           ITypeInfo **ppTInfo) override;
-  STDMETHODIMP GetIDsOfNames(REFIID riid, LPOLESTR *rgszNames, UINT cNames,
-                             LCID lcid, DISPID *rgDispId) override;
+                           ITypeInfo** ppTInfo) override;
+  STDMETHODIMP GetIDsOfNames(REFIID riid, LPOLESTR* rgszNames, UINT cNames,
+                             LCID lcid, DISPID* rgDispId) override;
   STDMETHODIMP Invoke(DISPID dispIdMember, REFIID riid, LCID lcid, WORD wFlags,
-                      DISPPARAMS *pDispParams, VARIANT *pVarResult,
-                      EXCEPINFO *pExcepInfo, UINT *puArgErr) override;
+                      DISPPARAMS* pDispParams, VARIANT* pVarResult,
+                      EXCEPINFO* pExcepInfo, UINT* puArgErr) override;
 
   // IAccessible
-  STDMETHODIMP get_accParent(IDispatch **ppdispParent) override;
-  STDMETHODIMP get_accChildCount(long *pcountChildren) override;
-  STDMETHODIMP get_accChild(VARIANT varChild, IDispatch **ppdispChild) override;
-  STDMETHODIMP get_accName(VARIANT varChild, BSTR *pszName) override;
-  STDMETHODIMP get_accValue(VARIANT varChild, BSTR *pszValue) override;
+  STDMETHODIMP get_accParent(IDispatch** ppdispParent) override;
+  STDMETHODIMP get_accChildCount(long* pcountChildren) override;
+  STDMETHODIMP get_accChild(VARIANT varChild, IDispatch** ppdispChild) override;
+  STDMETHODIMP get_accName(VARIANT varChild, BSTR* pszName) override;
+  STDMETHODIMP get_accValue(VARIANT varChild, BSTR* pszValue) override;
   STDMETHODIMP get_accDescription(VARIANT varChild,
-                                  BSTR *pszDescription) override;
-  STDMETHODIMP get_accRole(VARIANT varChild, VARIANT *pvarRole) override;
-  STDMETHODIMP get_accState(VARIANT varChild, VARIANT *pvarState) override;
-  STDMETHODIMP get_accHelp(VARIANT varChild, BSTR *pszHelp) override;
-  STDMETHODIMP get_accHelpTopic(BSTR *pszHelpFile, VARIANT varChild,
-                                long *pidTopic) override;
+                                  BSTR* pszDescription) override;
+  STDMETHODIMP get_accRole(VARIANT varChild, VARIANT* pvarRole) override;
+  STDMETHODIMP get_accState(VARIANT varChild, VARIANT* pvarState) override;
+  STDMETHODIMP get_accHelp(VARIANT varChild, BSTR* pszHelp) override;
+  STDMETHODIMP get_accHelpTopic(BSTR* pszHelpFile, VARIANT varChild,
+                                long* pidTopic) override;
   STDMETHODIMP get_accKeyboardShortcut(VARIANT varChild,
-                                       BSTR *pszKeyboardShortcut) override;
-  STDMETHODIMP get_accFocus(VARIANT *pvarChild) override;
-  STDMETHODIMP get_accSelection(VARIANT *pvarChildren) override;
+                                       BSTR* pszKeyboardShortcut) override;
+  STDMETHODIMP get_accFocus(VARIANT* pvarChild) override;
+  STDMETHODIMP get_accSelection(VARIANT* pvarChildren) override;
   STDMETHODIMP get_accDefaultAction(VARIANT varChild,
-                                    BSTR *pszDefaultAction) override;
+                                    BSTR* pszDefaultAction) override;
   STDMETHODIMP accSelect(long flagsSelect, VARIANT varChild) override;
-  STDMETHODIMP accLocation(long *pxLeft, long *pyTop, long *pcxWidth,
-                           long *pcyHeight, VARIANT varChild) override;
+  STDMETHODIMP accLocation(long* pxLeft, long* pyTop, long* pcxWidth,
+                           long* pcyHeight, VARIANT varChild) override;
   STDMETHODIMP accNavigate(long navDir, VARIANT varStart,
-                           VARIANT *pvarEndUpAt) override;
-  STDMETHODIMP accHitTest(long xLeft, long yTop, VARIANT *pvarChild) override;
+                           VARIANT* pvarEndUpAt) override;
+  STDMETHODIMP accHitTest(long xLeft, long yTop, VARIANT* pvarChild) override;
   STDMETHODIMP accDoDefaultAction(VARIANT varChild) override;
   STDMETHODIMP put_accName(VARIANT varChild, BSTR szName) override;
   STDMETHODIMP put_accValue(VARIANT varChild, BSTR szValue) override;
 
   // IServiceProvider
   STDMETHODIMP QueryService(REFGUID aServiceId, REFIID aServiceIid,
-                            void **aOutInterface) override;
+                            void** aOutInterface) override;
 
  private:
   explicit LazyInstantiator(HWND aHwnd);
   ~LazyInstantiator();
 
   bool IsBlockedInjection();
   bool ShouldInstantiate(const DWORD aClientTid);
 
@@ -96,34 +96,34 @@ class LazyInstantiator final : public IA
    */
   HRESULT MaybeResolveRoot();
 
   /**
    * @return S_OK if we have a valid mWeakDispatch to invoke methods on
    */
   HRESULT ResolveDispatch();
 
-  RootAccessibleWrap *ResolveRootAccWrap();
+  RootAccessibleWrap* ResolveRootAccWrap();
   void TransplantRefCnt();
   void ClearProp();
 
  private:
   mozilla::a11y::AutoRefCnt mRefCnt;
   HWND mHwnd;
   bool mAllowBlindAggregation;
   RefPtr<IUnknown> mRealRootUnk;
   RefPtr<IUnknown> mStdDispatch;
   /**
    * mWeakRootAccWrap, mWeakAccessible and mWeakDispatch are weak because they
    * are interfaces that come from objects that we aggregate. Aggregated object
    * interfaces share refcount methods with ours, so if we were to hold strong
    * references to them, we would be holding strong references to ourselves,
    * creating a cycle.
    */
-  RootAccessibleWrap *mWeakRootAccWrap;
-  IAccessible *mWeakAccessible;
-  IDispatch *mWeakDispatch;
+  RootAccessibleWrap* mWeakRootAccWrap;
+  IAccessible* mWeakAccessible;
+  IDispatch* mWeakDispatch;
 };
 
 }  // namespace a11y
 }  // namespace mozilla
 
 #endif  // mozilla_a11y_LazyInstantiator_h
--- a/accessible/windows/sdn/sdnDocAccessible.h
+++ b/accessible/windows/sdn/sdnDocAccessible.h
@@ -12,41 +12,41 @@
 
 #include "DocAccessibleWrap.h"
 
 namespace mozilla {
 namespace a11y {
 
 class sdnDocAccessible final : public ISimpleDOMDocument {
  public:
-  explicit sdnDocAccessible(DocAccessibleWrap *aAccessible)
+  explicit sdnDocAccessible(DocAccessibleWrap* aAccessible)
       : mAccessible(aAccessible){};
   ~sdnDocAccessible(){};
 
   DECL_IUNKNOWN
 
   // ISimpleDOMDocument
   virtual /* [id][propget] */ HRESULT STDMETHODCALLTYPE get_URL(
-      /* [out] */ BSTR __RPC_FAR *url);
+      /* [out] */ BSTR __RPC_FAR* url);
 
   virtual /* [id][propget] */ HRESULT STDMETHODCALLTYPE get_title(
-      /* [out] */ BSTR __RPC_FAR *title);
+      /* [out] */ BSTR __RPC_FAR* title);
 
   virtual /* [id][propget] */ HRESULT STDMETHODCALLTYPE get_mimeType(
-      /* [out] */ BSTR __RPC_FAR *mimeType);
+      /* [out] */ BSTR __RPC_FAR* mimeType);
 
   virtual /* [id][propget] */ HRESULT STDMETHODCALLTYPE get_docType(
-      /* [out] */ BSTR __RPC_FAR *docType);
+      /* [out] */ BSTR __RPC_FAR* docType);
 
   virtual /* [id][propget] */ HRESULT STDMETHODCALLTYPE get_nameSpaceURIForID(
       /* [in] */ short nameSpaceID,
-      /* [out] */ BSTR __RPC_FAR *nameSpaceURI);
+      /* [out] */ BSTR __RPC_FAR* nameSpaceURI);
 
   virtual /* [id] */ HRESULT STDMETHODCALLTYPE put_alternateViewMediaTypes(
-      /* [in] */ BSTR __RPC_FAR *commaSeparatedMediaTypes);
+      /* [in] */ BSTR __RPC_FAR* commaSeparatedMediaTypes);
 
  protected:
   RefPtr<DocAccessibleWrap> mAccessible;
 };
 
 }  // namespace a11y
 }  // namespace mozilla
 
--- a/accessible/xpcom/nsAccessibleRelation.cpp
+++ b/accessible/xpcom/nsAccessibleRelation.cpp
@@ -9,61 +9,61 @@
 #include "Accessible.h"
 #include "xpcAccessibleDocument.h"
 
 #include "nsArrayUtils.h"
 #include "nsComponentManagerUtils.h"
 
 using namespace mozilla::a11y;
 
-nsAccessibleRelation::nsAccessibleRelation(uint32_t aType, Relation *aRel)
+nsAccessibleRelation::nsAccessibleRelation(uint32_t aType, Relation* aRel)
     : mType(aType) {
   mTargets = do_CreateInstance(NS_ARRAY_CONTRACTID);
-  Accessible *targetAcc = nullptr;
+  Accessible* targetAcc = nullptr;
   while ((targetAcc = aRel->Next()))
-    mTargets->AppendElement(static_cast<nsIAccessible *>(ToXPC(targetAcc)));
+    mTargets->AppendElement(static_cast<nsIAccessible*>(ToXPC(targetAcc)));
 }
 
 nsAccessibleRelation::nsAccessibleRelation(
-    uint32_t aType, const nsTArray<ProxyAccessible *> *aTargets)
+    uint32_t aType, const nsTArray<ProxyAccessible*>* aTargets)
     : mType(aType) {
   mTargets = do_CreateInstance(NS_ARRAY_CONTRACTID);
   for (uint32_t idx = 0; idx < aTargets->Length(); ++idx) {
     mTargets->AppendElement(
-        static_cast<nsIAccessible *>(ToXPC(aTargets->ElementAt(idx))));
+        static_cast<nsIAccessible*>(ToXPC(aTargets->ElementAt(idx))));
   }
 }
 
 nsAccessibleRelation::~nsAccessibleRelation() {}
 
 // nsISupports
 NS_IMPL_ISUPPORTS(nsAccessibleRelation, nsIAccessibleRelation)
 
 // nsIAccessibleRelation
 NS_IMETHODIMP
-nsAccessibleRelation::GetRelationType(uint32_t *aType) {
+nsAccessibleRelation::GetRelationType(uint32_t* aType) {
   NS_ENSURE_ARG_POINTER(aType);
   *aType = mType;
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsAccessibleRelation::GetTargetsCount(uint32_t *aCount) {
+nsAccessibleRelation::GetTargetsCount(uint32_t* aCount) {
   NS_ENSURE_ARG_POINTER(aCount);
   *aCount = 0;
   return mTargets->GetLength(aCount);
 }
 
 NS_IMETHODIMP
-nsAccessibleRelation::GetTarget(uint32_t aIndex, nsIAccessible **aTarget) {
+nsAccessibleRelation::GetTarget(uint32_t aIndex, nsIAccessible** aTarget) {
   NS_ENSURE_ARG_POINTER(aTarget);
   nsresult rv = NS_OK;
   nsCOMPtr<nsIAccessible> target = do_QueryElementAt(mTargets, aIndex, &rv);
   target.forget(aTarget);
   return rv;
 }
 
 NS_IMETHODIMP
-nsAccessibleRelation::GetTargets(nsIArray **aTargets) {
+nsAccessibleRelation::GetTargets(nsIArray** aTargets) {
   NS_ENSURE_ARG_POINTER(aTargets);
   NS_ADDREF(*aTargets = mTargets);
   return NS_OK;
 }
--- a/browser/base/content/browser-sync.js
+++ b/browser/base/content/browser-sync.js
@@ -211,16 +211,31 @@ var gSync = {
   },
 
   showSendToDeviceView(anchor) {
     PanelUI.showSubView("PanelUI-sendTabToDevice", anchor);
     let panelViewNode = document.getElementById("PanelUI-sendTabToDevice");
     this.populateSendTabToDevicesView(panelViewNode, this.populateSendTabToDevicesView.bind(this));
   },
 
+  showSendToDeviceViewFromFxaMenu(anchor) {
+    this.showSendToDeviceView(anchor);
+    this.emitFxaToolbarTelemetry("send_tab", anchor);
+  },
+
+  showRemoteTabsFromFxaMenu(panel) {
+    PanelUI.showSubView("PanelUI-remotetabs", panel);
+    this.emitFxaToolbarTelemetry("sync_tabs", panel);
+  },
+
+  showSidebarFromFxaMenu(panel) {
+    SidebarUI.toggle("viewTabsSidebar");
+    this.emitFxaToolbarTelemetry("sync_tabs_sidebar", panel);
+  },
+
   populateSendTabToDevicesView(panelViewNode, reloadFunc) {
     let bodyNode = panelViewNode.querySelector(".panel-subview-body");
     let panelNode = panelViewNode.closest("panel");
     let browser = gBrowser.selectedBrowser;
     let url = browser.currentURI.spec;
     let title = browser.contentTitle;
     let multiselected = gBrowser.selectedTab.multiselected;
 
@@ -289,17 +304,17 @@ var gSync = {
     }
 
     this.enableSendTabIfValidTab();
 
     const anchor = document.getElementById("fxa-toolbar-menu-button");
     if (anchor.getAttribute("open") == "true") {
       PanelUI.hide();
     } else {
-      this.emitFxaToolbarTelemetry("toolbar_icon");
+      this.emitFxaToolbarTelemetry("toolbar_icon", anchor);
       PanelUI.showSubView(viewId, anchor, aEvent);
     }
   },
 
   updateFxAPanel(state = {}) {
     const mainWindowEl = document.documentElement;
 
     // The Firefox Account toolbar currently handles 3 different states for
@@ -350,28 +365,41 @@ var gSync = {
 
     if (canSendAllURIs) {
       document.getElementById("PanelUI-fxa-menu-sendtab-button").removeAttribute("disabled");
     } else {
       document.getElementById("PanelUI-fxa-menu-sendtab-button").setAttribute("disabled", true);
     }
   },
 
-  emitFxaToolbarTelemetry(type) {
-    if (!gFxaToolbarEnabled) {
-      return;
-    }
-    if (UIState.isReady()) {
+  emitFxaToolbarTelemetry(type, panel) {
+    if (UIState.isReady() && panel) {
       const state = UIState.get();
       const hasAvatar = state.avatarURL && !state.avatarURL.includes(FXA_NO_AVATAR_ZEROS);
       let extraOptions = {"fxa_status": state.status, "fxa_avatar": hasAvatar ? "true" : "false"};
-      Services.telemetry.recordEvent("fxa_avatar_menu", "click", type, null, extraOptions);
+
+      // When the fxa avatar panel is within the Firefox app menu,
+      // we emit different telemetry.
+      let eventName = "fxa_avatar_menu";
+      if (this.isPanelInsideAppMenu(panel)) {
+        eventName = "fxa_app_menu";
+      }
+
+      Services.telemetry.recordEvent(eventName, "click", type, null, extraOptions);
     }
   },
 
+  isPanelInsideAppMenu(panel = undefined) {
+    const appMenuPanel = document.getElementById("appMenu-popup");
+    if (panel && appMenuPanel.contains(panel)) {
+      return true;
+    }
+    return false;
+  },
+
   updatePanelPopup(state) {
     let defaultLabel = this.appMenuStatus.getAttribute("defaultlabel");
     const status = state.status;
     // Reset the status bar to its original state.
     this.appMenuLabel.setAttribute("label", defaultLabel);
     this.appMenuContainer.removeAttribute("fxastatus");
     this.appMenuAvatar.style.removeProperty("list-style-image");
     this.appMenuLabel.classList.remove("subviewbutton-nav");
@@ -442,16 +470,17 @@ var gSync = {
       state.syncing ? this.onActivityStart() : this.onActivityStop();
     }
   },
 
   onMenuPanelCommand() {
     switch (this.appMenuContainer.getAttribute("fxastatus")) {
     case "signedin":
       const panel = document.getElementById("appMenu-fxa-status");
+      this.emitFxaToolbarTelemetry("toolbar_icon", panel);
       PanelUI.showSubView("PanelUI-fxa", panel);
       break;
     case "error":
       if (this.appMenuContainer.getAttribute("fxastatus") == "unverified") {
         this.openPrefs("menupanel", "fxaError");
       } else {
         this.openSignInAgainPage("menupanel");
       }
@@ -480,32 +509,59 @@ var gSync = {
     });
   },
 
   async openConnectAnotherDevice(entryPoint) {
     const url = await FxAccounts.config.promiseConnectDeviceURI(entryPoint);
     openTrustedLinkIn(url, "tab");
   },
 
+  async openConnectAnotherDeviceFromFxaMenu(panel = undefined) {
+    this.emitFxaToolbarTelemetry("cad", panel);
+    let entryPoint = "fxa_discoverability_native";
+    if (this.isPanelInsideAppMenu(panel)) {
+      entryPoint = "fxa_app_menu";
+    }
+    this.openConnectAnotherDevice(entryPoint);
+  },
+
   openSendToDevicePromo() {
     let url = this.PRODUCT_INFO_BASE_URL;
     url += "send-tabs/?utm_source=" + Services.appinfo.name.toLowerCase();
     switchToTabHavingURI(url, true, { replaceQueryString: true });
   },
 
   async openFxAEmailFirstPage(entryPoint) {
     const url = await FxAccounts.config.promiseEmailFirstURI(entryPoint);
     switchToTabHavingURI(url, true, { replaceQueryString: true });
   },
 
+  async openFxAEmailFirstPageFromFxaMenu(panel = undefined) {
+    this.emitFxaToolbarTelemetry("login", panel);
+    let entryPoint = "fxa_discoverability_native";
+    if (this.isPanelInsideAppMenu(panel)) {
+        entryPoint = "fxa_app_menu";
+    }
+    this.openFxAEmailFirstPage(entryPoint);
+  },
+
   async openFxAManagePage(entryPoint) {
     const url = await FxAccounts.config.promiseManageURI(entryPoint);
     switchToTabHavingURI(url, true, { replaceQueryString: true });
   },
 
+  async openFxAManagePageFromFxaMenu(panel = undefined) {
+    this.emitFxaToolbarTelemetry("account_settings", panel);
+    let entryPoint = "fxa_discoverability_native";
+    if (this.isPanelInsideAppMenu(panel)) {
+        entryPoint = "fxa_app_menu";
+    }
+    this.openFxAManagePage(entryPoint);
+  },
+
   async sendTabToDevice(url, targets, title) {
     const fxaCommandsDevices = [];
     const oldSendTabClients = [];
     for (const target of targets) {
       if (fxAccounts.commands.sendTab.isDeviceCompatible(target)) {
         fxaCommandsDevices.push(target);
       } else if (target.clientRecord) {
         oldSendTabClients.push(target.clientRecord);
@@ -842,20 +898,34 @@ var gSync = {
         fxAccounts.commands.pollDeviceCommands().catch(e => {
           console.error("Fetching missed remote commands failed.", e);
         });
         Weave.Service.sync();
       });
     }
   },
 
+  doSyncFromFxaMenu(panel) {
+    this.doSync();
+    this.emitFxaToolbarTelemetry("sync_now", panel);
+  },
+
   openPrefs(entryPoint = "syncbutton", origin = undefined) {
     window.openPreferences("paneSync", { origin, urlParams: { entrypoint: entryPoint } });
   },
 
+  openPrefsFromFxaMenu(type, panel) {
+    this.emitFxaToolbarTelemetry(type, panel);
+    let entryPoint = "fxa_discoverability_native";
+    if (this.isPanelInsideAppMenu(panel)) {
+      entryPoint = "fxa_app_menu";
+    }
+    this.openPrefs(entryPoint);
+  },
+
   openSyncedTabsPanel() {
     let placement = CustomizableUI.getPlacementOfWidget("sync-button");
     let area = placement && placement.area;
     let anchor = document.getElementById("sync-button") ||
                  document.getElementById("PanelUI-menu-button");
     if (area == CustomizableUI.AREA_FIXED_OVERFLOW_PANEL) {
       // The button is in the overflow panel, so we need to show the panel,
       // then show our subview.
--- a/browser/base/content/browser.js
+++ b/browser/base/content/browser.js
@@ -489,25 +489,26 @@ function showFxaToolbarMenu(enable) {
   // if sync is enabled.
   const syncEnabled = Services.prefs.getBoolPref("identity.fxaccounts.enabled", false);
   const mainWindowEl = document.documentElement;
   const fxaPanelEl = document.getElementById("PanelUI-fxa");
 
   mainWindowEl.setAttribute("fxastatus", "not_configured");
   fxaPanelEl.addEventListener("ViewShowing", gSync.updateSendToDeviceTitle);
 
+  Services.telemetry.setEventRecordingEnabled("fxa_app_menu", true);
+
   if (enable && syncEnabled) {
     mainWindowEl.setAttribute("fxatoolbarmenu", "visible");
 
     // We have to manually update the sync state UI when toggling the FxA toolbar
     // because it could show an invalid icon if the user is logged in and no sync
     // event was performed yet.
     gSync.maybeUpdateUIState();
 
-    // Enabled FxA toolbar telemetry
     Services.telemetry.setEventRecordingEnabled("fxa_avatar_menu", true);
 
     // We set an attribute here so that we can toggle the custom
     // badge depending on whether the FxA menu was ever accessed.
     if (!gFxaToolbarAccessed) {
       mainWindowEl.setAttribute("fxa_avatar_badged", "badged");
     } else {
       mainWindowEl.removeAttribute("fxa_avatar_badged");
--- a/browser/base/content/test/general/browser.ini
+++ b/browser/base/content/test/general/browser.ini
@@ -71,17 +71,17 @@ support-files =
 # DO NOT ADD MORE TESTS HERE. USE A TOPICAL DIRECTORY INSTEAD.
 [browser_backButtonFitts.js]
 # DO NOT ADD MORE TESTS HERE. USE A TOPICAL DIRECTORY INSTEAD.
 [browser_beforeunload_duplicate_dialogs.js]
 # DO NOT ADD MORE TESTS HERE. USE A TOPICAL DIRECTORY INSTEAD.
 [browser_blob-channelname.js]
 # DO NOT ADD MORE TESTS HERE. USE A TOPICAL DIRECTORY INSTEAD.
 [browser_bug321000.js]
-subsuite = clipboard
+tags = clipboard
 skip-if = true # browser_bug321000.js is disabled because newline handling is shaky (bug 592528)
 # DO NOT ADD MORE TESTS HERE. USE A TOPICAL DIRECTORY INSTEAD.
 [browser_bug356571.js]
 skip-if = (verify && !debug && (os == 'win'))
 # DO NOT ADD MORE TESTS HERE. USE A TOPICAL DIRECTORY INSTEAD.
 [browser_bug380960.js]
 # DO NOT ADD MORE TESTS HERE. USE A TOPICAL DIRECTORY INSTEAD.
 [browser_bug386835.js]
@@ -135,35 +135,35 @@ skip-if = true # Bug 1478159
 # DO NOT ADD MORE TESTS HERE. USE A TOPICAL DIRECTORY INSTEAD.
 [browser_bug520538.js]
 # DO NOT ADD MORE TESTS HERE. USE A TOPICAL DIRECTORY INSTEAD.
 [browser_bug521216.js]
 # DO NOT ADD MORE TESTS HERE. USE A TOPICAL DIRECTORY INSTEAD.
 [browser_bug533232.js]
 # DO NOT ADD MORE TESTS HERE. USE A TOPICAL DIRECTORY INSTEAD.
 [browser_bug537013.js]
-subsuite = clipboard
+tags = clipboard
 skip-if = true # bug 1393813
 # skip-if = e10s # Bug 1134458 - Find bar doesn't work correctly in a detached tab
 # DO NOT ADD MORE TESTS HERE. USE A TOPICAL DIRECTORY INSTEAD.
 [browser_bug537474.js]
 # DO NOT ADD MORE TESTS HERE. USE A TOPICAL DIRECTORY INSTEAD.
 [browser_bug555224.js]
 # DO NOT ADD MORE TESTS HERE. USE A TOPICAL DIRECTORY INSTEAD.
 [browser_bug559991.js]
 # DO NOT ADD MORE TESTS HERE. USE A TOPICAL DIRECTORY INSTEAD.
 [browser_bug563588.js]
 # DO NOT ADD MORE TESTS HERE. USE A TOPICAL DIRECTORY INSTEAD.
 [browser_bug565575.js]
 # DO NOT ADD MORE TESTS HERE. USE A TOPICAL DIRECTORY INSTEAD.
 [browser_bug567306.js]
-subsuite = clipboard
+tags = clipboard
 # DO NOT ADD MORE TESTS HERE. USE A TOPICAL DIRECTORY INSTEAD.
 [browser_bug1261299.js]
-subsuite = clipboard
+tags = clipboard
 skip-if = toolkit != "cocoa" # Because of tests for supporting Service Menu of macOS, bug 1261299
 # DO NOT ADD MORE TESTS HERE. USE A TOPICAL DIRECTORY INSTEAD.
 [browser_bug1297539.js]
 skip-if = toolkit != "cocoa" # Because of tests for supporting pasting from Service Menu of macOS, bug 1297539
 # DO NOT ADD MORE TESTS HERE. USE A TOPICAL DIRECTORY INSTEAD.
 [browser_bug575561.js]
 # DO NOT ADD MORE TESTS HERE. USE A TOPICAL DIRECTORY INSTEAD.
 [browser_bug575830.js]
@@ -235,29 +235,28 @@ uses-unsafe-cpows = true
 # DO NOT ADD MORE TESTS HERE. USE A TOPICAL DIRECTORY INSTEAD.
 [browser_bug1015721.js]
 skip-if = os == 'win' || (verify && debug && (os == 'linux'))
 # DO NOT ADD MORE TESTS HERE. USE A TOPICAL DIRECTORY INSTEAD.
 [browser_accesskeys.js]
 # DO NOT ADD MORE TESTS HERE. USE A TOPICAL DIRECTORY INSTEAD.
 [browser_clipboard.js]
 uses-unsafe-cpows = true
-subsuite = clipboard
+tags = clipboard
 # DO NOT ADD MORE TESTS HERE. USE A TOPICAL DIRECTORY INSTEAD.
 [browser_clipboard_pastefile.js]
 skip-if = true # Disabled due to the clipboard not supporting real file types yet (bug 1288773)
 # DO NOT ADD MORE TESTS HERE. USE A TOPICAL DIRECTORY INSTEAD.
 [browser_contentAreaClick.js]
 skip-if = e10s # Clicks in content don't go through contentAreaClick with e10s.
 # DO NOT ADD MORE TESTS HERE. USE A TOPICAL DIRECTORY INSTEAD.
 [browser_contentAltClick.js]
 # DO NOT ADD MORE TESTS HERE. USE A TOPICAL DIRECTORY INSTEAD.
 [browser_contextmenu.js]
-subsuite = clipboard
-tags = fullscreen
+tags = fullscreen clipboard
 skip-if = toolkit == "gtk3" || verify || (os == "win" && processor == "aarch64") # disabled on Linux due to bug 513558, aarch64 due to 1531590
 # DO NOT ADD MORE TESTS HERE. USE A TOPICAL DIRECTORY INSTEAD.
 [browser_contextmenu_input.js]
 skip-if = toolkit == "gtk3" || (os == "win" && processor == "aarch64") # disabled on Linux due to bug 513558, aarch64 due to 1533161
 # DO NOT ADD MORE TESTS HERE. USE A TOPICAL DIRECTORY INSTEAD.
 [browser_ctrlTab.js]
 # DO NOT ADD MORE TESTS HERE. USE A TOPICAL DIRECTORY INSTEAD.
 [browser_datachoices_notification.js]
@@ -295,17 +294,17 @@ skip-if = e10s # Bug 863514 - no gesture
 [browser_invalid_uri_back_forward_manipulation.js]
 # DO NOT ADD MORE TESTS HERE. USE A TOPICAL DIRECTORY INSTEAD.
 [browser_lastAccessedTab.js]
 skip-if = toolkit == "windows" # Disabled on Windows due to frequent failures (bug 969405)
 # DO NOT ADD MORE TESTS HERE. USE A TOPICAL DIRECTORY INSTEAD.
 [browser_menuButtonFitts.js]
 # DO NOT ADD MORE TESTS HERE. USE A TOPICAL DIRECTORY INSTEAD.
 [browser_middleMouse_noJSPaste.js]
-subsuite = clipboard
+tags = clipboard
 # DO NOT ADD MORE TESTS HERE. USE A TOPICAL DIRECTORY INSTEAD.
 [browser_minimize.js]
 # DO NOT ADD MORE TESTS HERE. USE A TOPICAL DIRECTORY INSTEAD.
 [browser_modifiedclick_inherit_principal.js]
 # DO NOT ADD MORE TESTS HERE. USE A TOPICAL DIRECTORY INSTEAD.
 [browser_new_http_window_opened_from_file_tab.js]
 # DO NOT ADD MORE TESTS HERE. USE A TOPICAL DIRECTORY INSTEAD.
 [browser_offlineQuotaNotification.js]
--- a/browser/base/content/test/pageActions/browser.ini
+++ b/browser/base/content/test/pageActions/browser.ini
@@ -6,16 +6,16 @@ support-files =
 support-files =
   page_action_menu_add_search_engine_one.html
   page_action_menu_add_search_engine_many.html
   page_action_menu_add_search_engine_same_names.html
   page_action_menu_add_search_engine_0.xml
   page_action_menu_add_search_engine_1.xml
   page_action_menu_add_search_engine_2.xml
 [browser_page_action_menu_clipboard.js]
-subsuite = clipboard
+tags = clipboard
 [browser_page_action_menu_share_mac.js]
 skip-if = os != "mac" # Mac only feature
 [browser_page_action_menu_share_win.js]
 support-files =
   browser_page_action_menu_share_win.html
 skip-if = os != "win" # Windows only feature
 [browser_page_action_menu.js]
--- a/browser/base/content/test/tabs/browser.ini
+++ b/browser/base/content/test/tabs/browser.ini
@@ -56,17 +56,17 @@ support-files = file_new_tab_page.html
 skip-if = !e10s # Pref and test only relevant for e10s.
 [browser_new_web_tab_in_file_process_pref.js]
 skip-if = !e10s # Pref and test only relevant for e10s.
 [browser_newwindow_tabstrip_overflow.js]
 [browser_open_newtab_start_observer_notification.js]
 [browser_opened_file_tab_navigated_to_web.js]
 [browser_overflowScroll.js]
 [browser_paste_event_at_middle_click_on_link.js]
-subsuite = clipboard
+tags = clipboard
 support-files = file_anchor_elements.html
 [browser_pinnedTabs_clickOpen.js]
 [browser_pinnedTabs_closeByKeyboard.js]
 [browser_pinnedTabs.js]
 [browser_positional_attributes.js]
 skip-if = (verify && (os == 'win' || os == 'mac'))
 [browser_preloadedBrowser_zoom.js]
 [browser_reload_deleted_file.js]
--- a/browser/components/about/AboutRedirector.h
+++ b/browser/components/about/AboutRedirector.h
@@ -13,17 +13,17 @@ namespace browser {
 
 class AboutRedirector : public nsIAboutModule {
  public:
   NS_DECL_ISUPPORTS
   NS_DECL_NSIABOUTMODULE
 
   AboutRedirector() {}
 
-  static nsresult Create(nsISupports *aOuter, REFNSIID aIID, void **aResult);
+  static nsresult Create(nsISupports* aOuter, REFNSIID aIID, void** aResult);
 
  protected:
   virtual ~AboutRedirector() {}
 
  private:
   static bool sNewTabPageEnabled;
 };
 
--- a/browser/components/aboutconfig/test/browser/browser.ini
+++ b/browser/components/aboutconfig/test/browser/browser.ini
@@ -1,14 +1,14 @@
 [DEFAULT]
 skip-if = debug || asan # Bug 1507747 and bug 1520398
 support-files =
   head.js
 
 [browser_accessibility.js]
 [browser_basic.js]
 [browser_clipboard.js]
-subsuite = clipboard
+tags = clipboard
 [browser_edit.js]
 [browser_locked.js]
 [browser_observe.js]
 [browser_search.js]
 [browser_warning.js]
--- a/browser/components/customizableui/content/panelUI.inc.xul
+++ b/browser/components/customizableui/content/panelUI.inc.xul
@@ -688,66 +688,66 @@
     <panelview id="PanelUI-fxa" class="PanelUI-subView" descriptionheightworkaround="true">
       <vbox class="panel-subview-body">
         <vbox id="PanelUI-fxa-signin">
           <image class="fxaChooseWhatToSyncDevices"/>
           <label class="PanelUI-fxa-signin-instruction-callout">&fxa.signin.callout.label;</label>
           <label class="PanelUI-fxa-signin-instruction-label">&fxa.signin.description.label;</label>
           <toolbarbutton class="PanelUI-fxa-signin-button"
                          label="&fxa.signin.button.label;"
-                         oncommand="gSync.openFxAEmailFirstPage('fxa_discoverability_native'); gSync.emitFxaToolbarTelemetry('login');"/>
+                         oncommand="gSync.openFxAEmailFirstPageFromFxaMenu(this);"/>
         </vbox>
         <vbox id="PanelUI-fxa-unverified" class="PanelUI-fxa-unverified-instruction-box">
           <image class="fxaGraphicMail"/>
           <label class="PanelUI-fxa-signin-instruction-callout">&fxa.unverified.callout.label;</label>
           <label class="PanelUI-fxa-signin-instruction-label">&fxa.unverified.description.label;</label>
           <toolbarbutton class="PanelUI-fxa-signin-button"
                          label="&fxa.unverified.button.label;"
-                         oncommand="gSync.openPrefs('fxa_discoverability_native'); gSync.emitFxaToolbarTelemetry('unver_sync_settings');"/>
+                         oncommand="gSync.openPrefsFromFxaMenu('unver_sync_settings', this);"/>
         </vbox>
         <vbox id="PanelUI-fxa-menu">
           <hbox flex="1" align="center" class="fxa-avatar-subpanel">
             <image role="presentation" id="fxa-menu-avatar"/>
             <vbox flex="1">
               <label class="fxa-avatar-subpanel-description" >&fxa.menu.signedInAs.label;</label>
               <label id="fxa-menu-email"></label>
             </vbox>
           </hbox>
           <toolbarseparator/>
           <toolbarbutton id="PanelUI-fxa-menu-sendtab-button"
                          class="subviewbutton subviewbutton-iconic subviewbutton-nav"
                          closemenu="none"
-                         oncommand="gSync.showSendToDeviceView(this); gSync.emitFxaToolbarTelemetry('send_tab');"/>
+                         oncommand="gSync.showSendToDeviceViewFromFxaMenu(this);"/>
           <toolbarbutton id="PanelUI-fxa-menu-remotetabs-button"
                          class="subviewbutton subviewbutton-iconic subviewbutton-nav"
                          label="&appMenuRemoteTabs.label;"
                          closemenu="none"
-                         oncommand="PanelUI.showSubView('PanelUI-remotetabs', this); gSync.emitFxaToolbarTelemetry('sync_tabs');"/>
+                         oncommand="gSync.showRemoteTabsFromFxaMenu(this);"/>
           <toolbarbutton id="PanelUI-fxa-menu-view-sidebar"
                          class="subviewbutton subviewbutton-iconic"
                          label="&appMenuRemoteTabs.sidebar.label;"
-                         oncommand="SidebarUI.toggle('viewTabsSidebar'); gSync.emitFxaToolbarTelemetry('sync_tabs_sidebar');">
+                         oncommand="gSync.showSidebarFromFxaMenu(this);">
             <observes element="sidebar-box" attribute="positionend"/>
           </toolbarbutton>
           <toolbarseparator/>
           <toolbarbutton class="subviewbutton"
                          label="&fxa.menu.connectAnotherDevice2.label;"
-                         oncommand="gSync.openConnectAnotherDevice('fxa_discoverability_native'); gSync.emitFxaToolbarTelemetry('cad');"/>
+                         oncommand="gSync.openConnectAnotherDeviceFromFxaMenu(this);"/>
           <toolbarbutton class="subviewbutton"
                          label="&fxa.menu.manageAccount.label;"
-                         oncommand="gSync.openFxAManagePage('fxa_discoverability_native'); gSync.emitFxaToolbarTelemetry('account_settings');"/>
+                         oncommand="gSync.openFxAManagePageFromFxaMenu(this);"/>
           <toolbarbutton class="subviewbutton"
                          label="&fxa.menu.syncSettings.label;"
-                         oncommand="gSync.openPrefs('fxa_discoverability_native'); gSync.emitFxaToolbarTelemetry('sync_settings');"/>
+                         oncommand="gSync.openPrefsFromFxaMenu('sync_settings', this);"/>
           <toolbarseparator/>
           <toolbarbutton id="PanelUI-fxa-menu-syncnow-button"
                          label="&syncSyncNowItem.label;"
                          syncinglabel="&syncSyncNowItemSyncing.label;"
                          class="subviewbutton subviewbutton-iconic"
-                         oncommand="gSync.doSync(); gSync.emitFxaToolbarTelemetry('sync_now');"
+                         oncommand="gSync.doSyncFromFxaMenu(this);"
                          closemenu="none"/>
         </vbox>
       </vbox>
     </panelview>
     <!-- This panelview is used to contain the dynamically created buttons for send tab to devices -->
     <panelview id="PanelUI-sendTabToDevice" flex="1" class="PanelUI-subView">
       <vbox class="panel-subview-body">
         <toolbarbutton id="PanelUI-sendTabToDevice-syncingDevices" class="subviewbutton subviewbutton-iconic pageAction-sendToDevice-notReady"
--- a/browser/components/customizableui/test/browser.ini
+++ b/browser/components/customizableui/test/browser.ini
@@ -52,32 +52,32 @@ skip-if = (verify && debug && (os == 'li
 [browser_941083_invalidate_wrapper_cache_createWidget.js]
 skip-if = verify
 [browser_942581_unregisterArea_keeps_placements.js]
 [browser_944887_destroyWidget_should_destroy_in_palette.js]
 [browser_945739_showInPrivateBrowsing_customize_mode.js]
 [browser_947914_button_addons.js]
 skip-if = os == "linux" # Intermittent failures
 [browser_947914_button_copy.js]
-subsuite = clipboard
+tags = clipboard
 skip-if = os == "linux" # Intermittent failures on Linux
 [browser_947914_button_cut.js]
-subsuite = clipboard
+tags = clipboard
 skip-if = os == "linux" # Intermittent failures on Linux
 [browser_947914_button_find.js]
 skip-if = os == "linux" # Intermittent failures
 [browser_947914_button_history.js]
 support-files = dummy_history_item.html
 skip-if = os == "linux" # Intermittent failures
 [browser_947914_button_newPrivateWindow.js]
 skip-if = os == "linux" # Intermittent failures
 [browser_947914_button_newWindow.js]
 skip-if = os == "linux" # Intermittent failures
 [browser_947914_button_paste.js]
-subsuite = clipboard
+tags = clipboard
 skip-if = os == "linux" # Intermittent failures on Linux
 [browser_947914_button_print.js]
 skip-if = os == "linux" # Intermittent failures on Linux
 [browser_947914_button_zoomIn.js]
 skip-if = os == "linux" # Intermittent failures
 [browser_947914_button_zoomOut.js]
 skip-if = os == "linux" # Intermittent failures
 [browser_947914_button_zoomReset.js]
@@ -164,17 +164,17 @@ tags = fullscreen
 [browser_panelUINotifications_multiWindow.js]
 [browser_remove_customized_specials.js]
 [browser_reset_builtin_widget_currentArea.js]
 [browser_switch_to_customize_mode.js]
 [browser_synced_tabs_menu.js]
 [browser_backfwd_enabled_post_customize.js]
 [browser_check_tooltips_in_navbar.js]
 [browser_editcontrols_update.js]
-subsuite = clipboard
+tags = clipboard
 [browser_customization_context_menus.js]
 [browser_newtab_button_customizemode.js]
 [browser_open_from_popup.js]
 [browser_open_in_lazy_tab.js]
 [browser_PanelMultiView_focus.js]
 [browser_PanelMultiView_keyboard.js]
 [browser_reload_tab.js]
 [browser_sidebar_toggle.js]
--- a/browser/components/dirprovider/DirectoryProvider.cpp
+++ b/browser/components/dirprovider/DirectoryProvider.cpp
@@ -29,18 +29,18 @@ using mozilla::intl::LocaleService;
 
 namespace mozilla {
 namespace browser {
 
 NS_IMPL_ISUPPORTS(DirectoryProvider, nsIDirectoryServiceProvider,
                   nsIDirectoryServiceProvider2)
 
 NS_IMETHODIMP
-DirectoryProvider::GetFile(const char *aKey, bool *aPersist,
-                           nsIFile **aResult) {
+DirectoryProvider::GetFile(const char* aKey, bool* aPersist,
+                           nsIFile** aResult) {
   return NS_ERROR_FAILURE;
 }
 
 // Appends the distribution-specific search engine directories to the
 // array.  The directory structure is as follows:
 
 // appdir/
 // \- distribution/
@@ -51,18 +51,18 @@ DirectoryProvider::GetFile(const char *a
 //          ...
 //          \- <locale N>/
 
 // common engines are loaded for all locales.  If there is no locale
 // directory for the current locale, there is a pref:
 // "distribution.searchplugins.defaultLocale"
 // which specifies a default locale to use.
 
-static void AppendDistroSearchDirs(nsIProperties *aDirSvc,
-                                   nsCOMArray<nsIFile> &array) {
+static void AppendDistroSearchDirs(nsIProperties* aDirSvc,
+                                   nsCOMArray<nsIFile>& array) {
   nsCOMPtr<nsIFile> searchPlugins;
   nsresult rv = aDirSvc->Get(XRE_APP_DISTRIBUTION_DIR, NS_GET_IID(nsIFile),
                              getter_AddRefs(searchPlugins));
   if (NS_FAILED(rv)) return;
   searchPlugins->AppendNative(NS_LITERAL_CSTRING("searchplugins"));
 
   bool exists;
   rv = searchPlugins->Exists(&exists);
@@ -113,39 +113,39 @@ static void AppendDistroSearchDirs(nsIPr
         array.AppendObject(curLocalePlugins);
         return;  // all done
       }
     }
   }
 }
 
 NS_IMETHODIMP
-DirectoryProvider::GetFiles(const char *aKey, nsISimpleEnumerator **aResult) {
+DirectoryProvider::GetFiles(const char* aKey, nsISimpleEnumerator** aResult) {
   if (!strcmp(aKey, NS_APP_DISTRIBUTION_SEARCH_DIR_LIST)) {
     nsCOMPtr<nsIProperties> dirSvc(
         do_GetService(NS_DIRECTORY_SERVICE_CONTRACTID));
     if (!dirSvc) return NS_ERROR_FAILURE;
 
     nsCOMArray<nsIFile> distroFiles;
     AppendDistroSearchDirs(dirSvc, distroFiles);
 
     return NS_NewArrayEnumerator(aResult, distroFiles, NS_GET_IID(nsIFile));
   }
 
   return NS_ERROR_FAILURE;
 }
 
 NS_IMETHODIMP
-DirectoryProvider::AppendingEnumerator::HasMoreElements(bool *aResult) {
+DirectoryProvider::AppendingEnumerator::HasMoreElements(bool* aResult) {
   *aResult = mNext ? true : false;
   return NS_OK;
 }
 
 NS_IMETHODIMP
-DirectoryProvider::AppendingEnumerator::GetNext(nsISupports **aResult) {
+DirectoryProvider::AppendingEnumerator::GetNext(nsISupports** aResult) {
   if (aResult) NS_ADDREF(*aResult = mNext);
 
   mNext = nullptr;
 
   nsresult rv;
 
   // Ignore all errors
 
@@ -155,33 +155,33 @@ DirectoryProvider::AppendingEnumerator::
     mBase->GetNext(getter_AddRefs(nextbasesupp));
 
     nsCOMPtr<nsIFile> nextbase(do_QueryInterface(nextbasesupp));
     if (!nextbase) continue;
 
     nextbase->Clone(getter_AddRefs(mNext));
     if (!mNext) continue;
 
-    char const *const *i = mAppendList;
+    char const* const* i = mAppendList;
     while (*i) {
       mNext->AppendNative(nsDependentCString(*i));
       ++i;
     }
 
     bool exists;
     rv = mNext->Exists(&exists);
     if (NS_SUCCEEDED(rv) && exists) break;
 
     mNext = nullptr;
   }
 
   return NS_OK;
 }
 
 DirectoryProvider::AppendingEnumerator::AppendingEnumerator(
-    nsISimpleEnumerator *aBase, char const *const *aAppendList)
+    nsISimpleEnumerator* aBase, char const* const* aAppendList)
     : mBase(aBase), mAppendList(aAppendList) {
   // Initialize mNext to begin.
   GetNext(nullptr);
 }
 
 }  // namespace browser
 }  // namespace mozilla
--- a/browser/components/dirprovider/DirectoryProvider.h
+++ b/browser/components/dirprovider/DirectoryProvider.h
@@ -25,24 +25,24 @@ class DirectoryProvider final : public n
 
  private:
   ~DirectoryProvider() {}
 
   class AppendingEnumerator final : public nsSimpleEnumerator {
    public:
     NS_DECL_NSISIMPLEENUMERATOR
 
-    AppendingEnumerator(nsISimpleEnumerator *aBase,
-                        char const *const *aAppendList);
+    AppendingEnumerator(nsISimpleEnumerator* aBase,
+                        char const* const* aAppendList);
 
    private:
     ~AppendingEnumerator() override = default;
 
     nsCOMPtr<nsISimpleEnumerator> mBase;
-    char const *const *const mAppendList;
+    char const* const* const mAppendList;
     nsCOMPtr<nsIFile> mNext;
   };
 };
 
 }  // namespace browser
 }  // namespace mozilla
 
 #endif  // DirectoryProvider_h__
--- a/browser/components/extensions/test/xpcshell/test_ext_settings_overrides_search.js
+++ b/browser/components/extensions/test/xpcshell/test_ext_settings_overrides_search.js
@@ -190,8 +190,44 @@ add_task(async function test_extension_p
 
   let expectedSuggestURL = kSearchSuggestURL.replace("{searchTerms}", kSearchTerm);
   let submissionSuggest = engine.getSubmission(kSearchTerm, URLTYPE_SUGGEST_JSON);
   equal(submissionSuggest.uri.spec, expectedSuggestURL, "Suggest URLs should match");
   equal(submissionSuggest.postData.data.data, "foo=bar&bar=foo", "Suggest postData should match");
 
   await ext1.unload();
 });
+
+add_task(async function test_extension_no_query_params() {
+  const ext1 = ExtensionTestUtils.loadExtension({
+    manifest: {
+      "chrome_settings_overrides": {
+        "search_provider": {
+          "name": "MozSearch",
+          "keyword": "MozSearch",
+          "search_url": "https://example.com/{searchTerms}",
+          "suggest_url": "https://example.com/suggest/{searchTerms}",
+        },
+      },
+    },
+    useAddonManager: "temporary",
+  });
+
+  await ext1.startup();
+  await AddonTestUtils.waitForSearchProviderStartup(ext1);
+
+  let engine = Services.search.getEngineByName("MozSearch");
+  ok(engine, "Engine should exist.");
+
+  const encodedSubmissionURL = engine.getSubmission(kSearchTermIntl).uri.spec;
+  const testSubmissionURL = "https://example.com/" + encodeURIComponent(kSearchTermIntl);
+  equal(encodedSubmissionURL, testSubmissionURL, "Encoded UTF-8 URLs should match");
+
+  const expectedSuggestURL = "https://example.com/suggest/" + kSearchTerm;
+  let submissionSuggest = engine.getSubmission(kSearchTerm, URLTYPE_SUGGEST_JSON);
+  equal(submissionSuggest.uri.spec, expectedSuggestURL, "Suggest URLs should match");
+
+  await ext1.unload();
+  await delay();
+
+  engine = Services.search.getEngineByName("MozSearch");
+  ok(!engine, "Engine should not exist");
+});
--- a/browser/components/places/tests/browser/browser.ini
+++ b/browser/components/places/tests/browser/browser.ini
@@ -49,19 +49,19 @@ skip-if = (verify && debug && (os == 'wi
 [browser_bookmarksProperties.js]
 skip-if = (verify && debug && (os == 'win' || os == 'mac'))
 [browser_check_correct_controllers.js]
 [browser_click_bookmarks_on_toolbar.js]
 [browser_controller_onDrop_sidebar.js]
 [browser_controller_onDrop_tagFolder.js]
 [browser_controller_onDrop.js]
 [browser_copy_query_without_tree.js]
-subsuite = clipboard
+tags = clipboard
 [browser_cutting_bookmarks.js]
-subsuite = clipboard
+tags = clipboard
 [browser_drag_bookmarks_on_toolbar.js]
 [browser_enable_toolbar_sidebar.js]
 skip-if = (verify && debug && (os == 'mac' || os == 'linux'))
 [browser_forgetthissite_single.js]
 [browser_history_sidebar_search.js]
 [browser_library_commands.js]
 [browser_library_delete_bookmarks_in_tags.js]
 [browser_library_delete_tags.js]
@@ -77,22 +77,22 @@ skip-if = (verify && debug && (os == 'ma
 [browser_library_panel_leak.js]
 [browser_library_search.js]
 [browser_library_tree_leak.js]
 [browser_library_views_liveupdate.js]
 [browser_library_warnOnOpen.js]
 [browser_markPageAsFollowedLink.js]
 [browser_panelview_bookmarks_delete.js]
 [browser_paste_bookmarks.js]
-subsuite = clipboard
+tags = clipboard
 [browser_paste_into_tags.js]
 [browser_paste_resets_cut_highlights.js]
-subsuite = clipboard
+tags = clipboard
 [browser_remove_bookmarks.js]
-subsuite = clipboard
+tags = clipboard
 [browser_sidebar_open_bookmarks.js]
 [browser_sidebarpanels_click.js]
 skip-if = (os == "mac" && debug) # Bug 1467049
 [browser_sort_in_library.js]
 [browser_stayopenmenu.js]
 [browser_toolbar_drop_text.js]
 [browser_toolbar_library_open_recent.js]
 [browser_toolbar_overflow.js]
--- a/browser/components/preferences/in-content/syncDisconnect.xul
+++ b/browser/components/preferences/in-content/syncDisconnect.xul
@@ -44,22 +44,20 @@
         </vbox>
       </hbox>
     </vbox>
 
     <vbox>
       <spacer flex="1"/>
       <hbox class="actionButtons" align="right" flex="1">
         <button id="butCancel"
-                is="highlightable-button"
                 oncommand="close(event);"
                 class="syncDisconnectButton"
                 data-l10n-id="sync-disconnect-cancel"/>
         <button id="butDisconnect"
-                is="highlightable-button"
                 oncommand="gSyncDisconnectDialog.accept(event);"
                 class="syncDisconnectButton"
                 data-l10n-id="sync-disconnect-confirm-disconnect"/>
       </hbox>
     </vbox>
   </vbox>
 
   <vbox id="deletingContent" align="center" pack="center" flex="1" hidden="true">
--- a/browser/components/shell/nsGNOMEShellService.cpp
+++ b/browser/components/shell/nsGNOMEShellService.cpp
@@ -39,23 +39,23 @@
 #include <gdk/gdk.h>
 #include <gdk-pixbuf/gdk-pixbuf.h>
 #include <limits.h>
 #include <stdlib.h>
 
 using namespace mozilla;
 
 struct ProtocolAssociation {
-  const char *name;
+  const char* name;
   bool essential;
 };
 
 struct MimeTypeAssociation {
-  const char *mimeType;
-  const char *extensions;
+  const char* mimeType;
+  const char* extensions;
 };
 
 static const ProtocolAssociation appProtocols[] = {
     // clang-format off
   { "http",   true     },
   { "https",  true     },
   { "ftp",    false },
   { "chrome", false }
@@ -110,42 +110,42 @@ nsresult nsGNOMEShellService::Init() {
 
   return appPath->GetNativePath(mAppPath);
 }
 
 NS_IMPL_ISUPPORTS(nsGNOMEShellService, nsIGNOMEShellService, nsIShellService,
                   nsIToolkitShellService)
 
 bool nsGNOMEShellService::GetAppPathFromLauncher() {
-  gchar *tmp;
+  gchar* tmp;
 
-  const char *launcher = PR_GetEnv("MOZ_APP_LAUNCHER");
+  const char* launcher = PR_GetEnv("MOZ_APP_LAUNCHER");
   if (!launcher) return false;
 
   if (g_path_is_absolute(launcher)) {
     mAppPath = launcher;
     tmp = g_path_get_basename(launcher);
-    gchar *fullpath = g_find_program_in_path(tmp);
+    gchar* fullpath = g_find_program_in_path(tmp);
     if (fullpath && mAppPath.Equals(fullpath)) mAppIsInPath = true;
     g_free(fullpath);
   } else {
     tmp = g_find_program_in_path(launcher);
     if (!tmp) return false;
     mAppPath = tmp;
     mAppIsInPath = true;
   }
 
   g_free(tmp);
   return true;
 }
 
-bool nsGNOMEShellService::KeyMatchesAppName(const char *aKeyValue) const {
-  gchar *commandPath;
+bool nsGNOMEShellService::KeyMatchesAppName(const char* aKeyValue) const {
+  gchar* commandPath;
   if (mUseLocaleFilenames) {
-    gchar *nativePath =
+    gchar* nativePath =
         g_filename_from_utf8(aKeyValue, -1, nullptr, nullptr, nullptr);
     if (!nativePath) {
       NS_ERROR("Error converting path to filesystem encoding");
       return false;
     }
 
     commandPath = g_find_program_in_path(nativePath);
     g_free(nativePath);
@@ -156,19 +156,19 @@ bool nsGNOMEShellService::KeyMatchesAppN
   if (!commandPath) return false;
 
   bool matches = mAppPath.Equals(commandPath);
   g_free(commandPath);
   return matches;
 }
 
 bool nsGNOMEShellService::CheckHandlerMatchesAppName(
-    const nsACString &handler) const {
+    const nsACString& handler) const {
   gint argc;
-  gchar **argv;
+  gchar** argv;
   nsAutoCString command(handler);
 
   // The string will be something of the form: [/path/to/]browser "%s"
   // We want to remove all of the parameters and get just the binary name.
 
   if (g_shell_parse_argv(command.get(), &argc, &argv, nullptr) && argc > 0) {
     command.Assign(argv[0]);
     g_strfreev(argv);
@@ -177,27 +177,27 @@ bool nsGNOMEShellService::CheckHandlerMa
   if (!KeyMatchesAppName(command.get()))
     return false;  // the handler is set to another app
 
   return true;
 }
 
 NS_IMETHODIMP
 nsGNOMEShellService::IsDefaultBrowser(bool aForAllTypes,
-                                      bool *aIsDefaultBrowser) {
+                                      bool* aIsDefaultBrowser) {
   *aIsDefaultBrowser = false;
 
   if (IsRunningAsASnap()) {
-    const gchar *argv[] = {"xdg-settings", "check", "default-web-browser",
+    const gchar* argv[] = {"xdg-settings", "check", "default-web-browser",
                            "firefox.desktop", nullptr};
     GSpawnFlags flags = static_cast<GSpawnFlags>(G_SPAWN_SEARCH_PATH |
                                                  G_SPAWN_STDERR_TO_DEV_NULL);
-    gchar *output = nullptr;
+    gchar* output = nullptr;
     gint exit_status = 0;
-    if (!g_spawn_sync(nullptr, (gchar **)argv, nullptr, flags, nullptr, nullptr,
+    if (!g_spawn_sync(nullptr, (gchar**)argv, nullptr, flags, nullptr, nullptr,
                       &output, nullptr, &exit_status, nullptr)) {
       return NS_OK;
     }
     if (exit_status != 0) {
       g_free(output);
       return NS_OK;
     }
     if (strcmp(output, "yes\n") == 0) {
@@ -238,22 +238,22 @@ NS_IMETHODIMP
 nsGNOMEShellService::SetDefaultBrowser(bool aClaimAllTypes, bool aForAllUsers) {
 #ifdef DEBUG
   if (aForAllUsers)
     NS_WARNING(
         "Setting the default browser for all users is not yet supported");
 #endif
 
   if (IsRunningAsASnap()) {
-    const gchar *argv[] = {"xdg-settings", "set", "default-web-browser",
+    const gchar* argv[] = {"xdg-settings", "set", "default-web-browser",
                            "firefox.desktop", nullptr};
     GSpawnFlags flags = static_cast<GSpawnFlags>(G_SPAWN_SEARCH_PATH |
                                                  G_SPAWN_STDOUT_TO_DEV_NULL |
                                                  G_SPAWN_STDERR_TO_DEV_NULL);
-    g_spawn_sync(nullptr, (gchar **)argv, nullptr, flags, nullptr, nullptr,
+    g_spawn_sync(nullptr, (gchar**)argv, nullptr, flags, nullptr, nullptr,
                  nullptr, nullptr, nullptr, nullptr);
     return NS_OK;
   }
 
   nsCOMPtr<nsIGIOService> giovfs = do_GetService(NS_GIOSERVICE_CONTRACTID);
   if (giovfs) {
     nsresult rv;
     nsCOMPtr<nsIStringBundleService> bundleService =
@@ -307,57 +307,57 @@ nsGNOMEShellService::SetDefaultBrowser(b
     // before it is silenced.
     (void)prefs->SetIntPref(PREF_DEFAULTBROWSERCHECKCOUNT, 0);
   }
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsGNOMEShellService::GetCanSetDesktopBackground(bool *aResult) {
+nsGNOMEShellService::GetCanSetDesktopBackground(bool* aResult) {
   // setting desktop background is currently only supported
   // for Gnome or desktops using the same GSettings keys
-  const char *currentDesktop = getenv("XDG_CURRENT_DESKTOP");
+  const char* currentDesktop = getenv("XDG_CURRENT_DESKTOP");
   if (currentDesktop && strstr(currentDesktop, "GNOME") != nullptr) {
     *aResult = true;
     return NS_OK;
   }
 
-  const char *gnomeSession = getenv("GNOME_DESKTOP_SESSION_ID");
+  const char* gnomeSession = getenv("GNOME_DESKTOP_SESSION_ID");
   if (gnomeSession) {
     *aResult = true;
   } else {
     *aResult = false;
   }
 
   return NS_OK;
 }
 
-static nsresult WriteImage(const nsCString &aPath, imgIContainer *aImage) {
+static nsresult WriteImage(const nsCString& aPath, imgIContainer* aImage) {
 #if !defined(MOZ_WIDGET_GTK)
   return NS_ERROR_NOT_AVAILABLE;
 #else
   nsCOMPtr<nsIImageToPixbuf> imgToPixbuf =
       do_GetService("@mozilla.org/widget/image-to-gdk-pixbuf;1");
   if (!imgToPixbuf) return NS_ERROR_NOT_AVAILABLE;
 
-  GdkPixbuf *pixbuf = imgToPixbuf->ConvertImageToPixbuf(aImage);
+  GdkPixbuf* pixbuf = imgToPixbuf->ConvertImageToPixbuf(aImage);
   if (!pixbuf) return NS_ERROR_NOT_AVAILABLE;
 
   gboolean res = gdk_pixbuf_save(pixbuf, aPath.get(), "png", nullptr, nullptr);
 
   g_object_unref(pixbuf);
   return res ? NS_OK : NS_ERROR_FAILURE;
 #endif
 }
 
 NS_IMETHODIMP
-nsGNOMEShellService::SetDesktopBackground(dom::Element *aElement,
+nsGNOMEShellService::SetDesktopBackground(dom::Element* aElement,
                                           int32_t aPosition,
-                                          const nsACString &aImageName) {
+                                          const nsACString& aImageName) {
   nsresult rv;
   nsCOMPtr<nsIImageLoadingContent> imageContent =
       do_QueryInterface(aElement, &rv);
   if (!imageContent) return rv;
 
   // get the image container
   nsCOMPtr<imgIRequest> request;
   rv = imageContent->GetRequest(nsIImageLoadingContent::CURRENT_REQUEST,
@@ -410,17 +410,17 @@ nsGNOMEShellService::SetDesktopBackgroun
 
   nsCOMPtr<nsIGSettingsService> gsettings =
       do_GetService(NS_GSETTINGSSERVICE_CONTRACTID);
   if (gsettings) {
     nsCOMPtr<nsIGSettingsCollection> background_settings;
     gsettings->GetCollectionForSchema(NS_LITERAL_CSTRING(kDesktopBGSchema),
                                       getter_AddRefs(background_settings));
     if (background_settings) {
-      gchar *file_uri = g_filename_to_uri(filePath.get(), nullptr, nullptr);
+      gchar* file_uri = g_filename_to_uri(filePath.get(), nullptr, nullptr);
       if (!file_uri) return NS_ERROR_FAILURE;
 
       background_settings->SetString(NS_LITERAL_CSTRING(kDesktopOptionGSKey),
                                      options);
 
       background_settings->SetString(NS_LITERAL_CSTRING(kDesktopImageGSKey),
                                      nsDependentCString(file_uri));
       g_free(file_uri);
@@ -432,17 +432,17 @@ nsGNOMEShellService::SetDesktopBackgroun
 
   return NS_ERROR_FAILURE;
 }
 
 #define COLOR_16_TO_8_BIT(_c) ((_c) >> 8)
 #define COLOR_8_TO_16_BIT(_c) ((_c) << 8 | (_c))
 
 NS_IMETHODIMP
-nsGNOMEShellService::GetDesktopBackgroundColor(uint32_t *aColor) {
+nsGNOMEShellService::GetDesktopBackgroundColor(uint32_t* aColor) {
   nsCOMPtr<nsIGSettingsService> gsettings =
       do_GetService(NS_GSETTINGSSERVICE_CONTRACTID);
   nsCOMPtr<nsIGSettingsCollection> background_settings;
   nsAutoCString background;
 
   if (gsettings) {
     gsettings->GetCollectionForSchema(NS_LITERAL_CSTRING(kDesktopBGSchema),
                                       getter_AddRefs(background_settings));
@@ -462,20 +462,20 @@ nsGNOMEShellService::GetDesktopBackgroun
 
   NS_ENSURE_TRUE(success, NS_ERROR_FAILURE);
 
   *aColor = COLOR_16_TO_8_BIT(color.red) << 16 |
             COLOR_16_TO_8_BIT(color.green) << 8 | COLOR_16_TO_8_BIT(color.blue);
   return NS_OK;
 }
 
-static void ColorToCString(uint32_t aColor, nsCString &aResult) {
+static void ColorToCString(uint32_t aColor, nsCString& aResult) {
   // The #rrrrggggbbbb format is used to match gdk_color_to_string()
   aResult.SetLength(13);
-  char *buf = aResult.BeginWriting();
+  char* buf = aResult.BeginWriting();
   if (!buf) return;
 
   uint16_t red = COLOR_8_TO_16_BIT((aColor >> 16) & 0xff);
   uint16_t green = COLOR_8_TO_16_BIT((aColor >> 8) & 0xff);
   uint16_t blue = COLOR_8_TO_16_BIT(aColor & 0xff);
 
   snprintf(buf, 14, "#%04x%04x%04x", red, green, blue);
 }
@@ -518,22 +518,22 @@ nsGNOMEShellService::OpenApplication(int
     giovfs->GetAppForURIScheme(scheme, getter_AddRefs(handlerApp));
     if (handlerApp) return handlerApp->LaunchWithURI(nullptr, nullptr);
   }
 
   return NS_ERROR_FAILURE;
 }
 
 NS_IMETHODIMP
-nsGNOMEShellService::OpenApplicationWithURI(nsIFile *aApplication,
-                                            const nsACString &aURI) {
+nsGNOMEShellService::OpenApplicationWithURI(nsIFile* aApplication,
+                                            const nsACString& aURI) {
   nsresult rv;
   nsCOMPtr<nsIProcess> process =
       do_CreateInstance("@mozilla.org/process/util;1", &rv);
   if (NS_FAILED(rv)) return rv;
 
   rv = process->Init(aApplication);
   if (NS_FAILED(rv)) return rv;
 
   const nsCString spec(aURI);
-  const char *specStr = spec.get();
+  const char* specStr = spec.get();
   return process->Run(false, &specStr, 1);
 }
--- a/browser/components/urlbar/UrlbarUtils.jsm
+++ b/browser/components/urlbar/UrlbarUtils.jsm
@@ -162,16 +162,17 @@ var UrlbarUtils = {
     let postData = null;
     // Split on the first whitespace.
     let [keyword, param = ""] = url.trim().split(/\s(.+)/, 2);
 
     if (!keyword) {
       return { url, postData, mayInheritPrincipal };
     }
 
+    await Services.search.init();
     let engine = Services.search.getEngineByAlias(keyword);
     if (engine) {
       let submission = engine.getSubmission(param, null, "keyword");
       return { url: submission.uri.spec,
                postData: submission.postData,
                mayInheritPrincipal };
     }
 
--- a/browser/components/urlbar/tests/browser/browser.ini
+++ b/browser/components/urlbar/tests/browser/browser.ini
@@ -57,27 +57,27 @@ support-files =
   print_postdata.sjs
   searchSuggestionEngine.xml
   searchSuggestionEngine.sjs
 [browser_locationBarCommand.js]
 [browser_locationBarExternalLoad.js]
 [browser_moz_action_link.js]
 [browser_new_tab_urlbar_reset.js]
 [browser_pasteAndGo.js]
-subsuite = clipboard
+tags = clipboard
 [browser_percent_encoded.js]
 [browser_populateAfterPushState.js]
 [browser_privateBrowsingWindowChange.js]
 [browser_raceWithTabs.js]
 skip-if = os == "linux" # Bug 1533807
 [browser_redirect_error.js]
 support-files = redirect_error.sjs
 [browser_remotetab.js]
 [browser_removeUnsafeProtocolsFromURLBarPaste.js]
-subsuite = clipboard
+tags = clipboard
 [browser_restoreEmptyInput.js]
 [browser_search_favicon.js]
 skip-if = true # Bug 1526222 - Doesn't currently work with QuantumBar
 [browser_searchTelemetry.js]
 support-files =
   searchSuggestionEngine.xml
   searchSuggestionEngine.sjs
 [browser_selectionKeyNavigation.js]
@@ -112,34 +112,34 @@ run-if = e10s
 [browser_urlbar_speculative_connect.js]
 support-files =
   searchSuggestionEngine2.xml
   searchSuggestionEngine.sjs
 [browser_urlbar_speculative_connect_not_with_client_cert.js]
 [browser_urlbar_whereToOpen.js]
 [browser_urlbarAboutHomeLoading.js]
 [browser_urlbarCopying.js]
-subsuite = clipboard
+tags = clipboard
 support-files =
   authenticate.sjs
 [browser_urlbarCutting.js]
 [browser_urlbarDecode.js]
 [browser_urlbarDelete.js]
 [browser_urlbarEnter.js]
 [browser_urlbarEnterAfterMouseOver.js]
 skip-if = os == "linux" # Bug 1073339 - Investigate autocomplete test unreliability on Linux/e10s
 [browser_urlbarFocusedCmdK.js]
 [browser_urlbarHashChangeProxyState.js]
 [browser_UrlbarInput_formatValue.js]
 [browser_UrlbarInput_hiddenFocus.js]
 [browser_UrlbarInput_overflow.js]
 [browser_UrlbarInput_overflow_resize.js]
 [browser_UrlbarInput_tooltip.js]
 [browser_UrlbarInput_trimURLs.js]
-subsuite = clipboard
+tags = clipboard
 [browser_UrlbarInput_unit.js]
 support-files = empty.xul
 [browser_UrlbarLoadRace.js]
 [browser_urlbarOneOffs_contextMenu.js]
 support-files =
   searchSuggestionEngine.xml
   searchSuggestionEngine.sjs
 [browser_urlbarOneOffs_searchSuggestions.js]
--- a/browser/components/urlbar/tests/legacy/browser.ini
+++ b/browser/components/urlbar/tests/legacy/browser.ini
@@ -9,17 +9,17 @@ support-files =
 # These tests are ones we are not porting to QuantumBar. The ones in the
 # section underneath this are ones that work in both QuantumBar and the legacy
 # address bar.
 
 # Not porting browser_switchtab_override_keynav.js/browser_switchtab_copy.js
 # to QuantumBar as we no longer have moz-action uris, so they aren't relevant
 # any more.
 [browser_switchtab_copy.js]
-subsuite = clipboard
+tags = clipboard
 [browser_switchtab_override_keynav.js]
 # Not porting browser_urlbarAddonIframe.js - we'll be implementing new
 # WebExtension APIs
 [browser_urlbarAddonIframe.js]
 support-files =
   ../browser/Panel.jsm
   ../browser/urlbarAddonIframe.html
   ../browser/urlbarAddonIframe.js
@@ -71,27 +71,27 @@ support-files =
   ../browser/print_postdata.sjs
 [../browser/browser_URLBarSetURI.js]
 skip-if = (os == "linux" || os == "mac") && debug # bug 970052, bug 970053
 [../browser/browser_locationBarCommand.js]
 [../browser/browser_locationBarExternalLoad.js]
 [../browser/browser_moz_action_link.js]
 [../browser/browser_new_tab_urlbar_reset.js]
 [../browser/browser_pasteAndGo.js]
-subsuite = clipboard
+tags = clipboard
 [../browser/browser_percent_encoded.js]
 [../browser/browser_populateAfterPushState.js]
 [../browser/browser_privateBrowsingWindowChange.js]
 [../browser/browser_raceWithTabs.js]
 skip-if = os == "linux" # Bug 1533807
 [../browser/browser_redirect_error.js]
 support-files = ../browser/redirect_error.sjs
 [../browser/browser_remotetab.js]
 [../browser/browser_removeUnsafeProtocolsFromURLBarPaste.js]
-subsuite = clipboard
+tags = clipboard
 [../browser/browser_search_favicon.js]
 [../browser/browser_searchTelemetry.js]
 support-files =
   ../browser/searchSuggestionEngine.xml
   ../browser/searchSuggestionEngine.sjs
 [../browser/browser_stop_pending.js]
 support-files =
   ../browser/slow-page.sjs
@@ -106,17 +106,17 @@ skip-if = true # Bug 1507755
 [../browser/browser_tabMatchesInAwesomebar_perwindowpb.js]
 skip-if = os == 'linux' # Bug 1104755
 [../browser/browser_tabMatchesInAwesomebar.js]
 support-files =
   ../browser/moz.png
 [../browser/browser_textruns.js]
 [../browser/browser_urlbarAboutHomeLoading.js]
 [../browser/browser_urlbarCopying.js]
-subsuite = clipboard
+tags = clipboard
 support-files =
   ../browser/authenticate.sjs
 [../browser/browser_urlbarCutting.js]
 [../browser/browser_urlbarDecode.js]
 [../browser/browser_urlbar_blanking.js]
 support-files =
   ../browser/file_blank_but_not_blank.html
 [../browser/browser_urlbar_content_opener.js]
--- a/build/macosx/permissions/chown_revert.c
+++ b/build/macosx/permissions/chown_revert.c
@@ -1,18 +1,18 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include <unistd.h>
 #include <stdio.h>
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   if (argc != 2) return 1;
 
   uid_t realuser = getuid();
   char uidstring[20];
   snprintf(uidstring, 19, "%i", realuser);
   uidstring[19] = '\0';
 
   return execl("/usr/sbin/chown", "/usr/sbin/chown", "-R", "-h", uidstring,
-               argv[1], (char *)0);
+               argv[1], (char*)0);
 }
--- a/build/macosx/permissions/chown_root.c
+++ b/build/macosx/permissions/chown_root.c
@@ -1,12 +1,12 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include <unistd.h>
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   if (argc != 2) return 1;
 
   return execl("/usr/sbin/chown", "/usr/sbin/chown", "-R", "-h", "root:admin",
-               argv[1], (char *)0);
+               argv[1], (char*)0);
 }
--- a/build/unix/elfhack/elf.cpp
+++ b/build/unix/elfhack/elf.cpp
@@ -3,17 +3,17 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #undef NDEBUG
 #include <cstring>
 #include <assert.h>
 #include "elfxx.h"
 
 template <class endian, typename R, typename T>
-void Elf_Ehdr_Traits::swap(T &t, R &r) {
+void Elf_Ehdr_Traits::swap(T& t, R& r) {
   memcpy(r.e_ident, t.e_ident, sizeof(r.e_ident));
   r.e_type = endian::swap(t.e_type);
   r.e_machine = endian::swap(t.e_machine);
   r.e_version = endian::swap(t.e_version);
   r.e_entry = endian::swap(t.e_entry);
   r.e_phoff = endian::swap(t.e_phoff);
   r.e_shoff = endian::swap(t.e_shoff);
   r.e_flags = endian::swap(t.e_flags);
@@ -21,96 +21,96 @@ void Elf_Ehdr_Traits::swap(T &t, R &r) {
   r.e_phentsize = endian::swap(t.e_phentsize);
   r.e_phnum = endian::swap(t.e_phnum);
   r.e_shentsize = endian::swap(t.e_shentsize);
   r.e_shnum = endian::swap(t.e_shnum);
   r.e_shstrndx = endian::swap(t.e_shstrndx);
 }
 
 template <class endian, typename R, typename T>
-void Elf_Phdr_Traits::swap(T &t, R &r) {
+void Elf_Phdr_Traits::swap(T& t, R& r) {
   r.p_type = endian::swap(t.p_type);
   r.p_offset = endian::swap(t.p_offset);
   r.p_vaddr = endian::swap(t.p_vaddr);
   r.p_paddr = endian::swap(t.p_paddr);
   r.p_filesz = endian::swap(t.p_filesz);
   r.p_memsz = endian::swap(t.p_memsz);
   r.p_flags = endian::swap(t.p_flags);
   r.p_align = endian::swap(t.p_align);
 }
 
 template <class endian, typename R, typename T>
-void Elf_Shdr_Traits::swap(T &t, R &r) {
+void Elf_Shdr_Traits::swap(T& t, R& r) {
   r.sh_name = endian::swap(t.sh_name);
   r.sh_type = endian::swap(t.sh_type);
   r.sh_flags = endian::swap(t.sh_flags);
   r.sh_addr = endian::swap(t.sh_addr);
   r.sh_offset = endian::swap(t.sh_offset);
   r.sh_size = endian::swap(t.sh_size);
   r.sh_link = endian::swap(t.sh_link);
   r.sh_info = endian::swap(t.sh_info);
   r.sh_addralign = endian::swap(t.sh_addralign);
   r.sh_entsize = endian::swap(t.sh_entsize);
 }
 
 template <class endian, typename R, typename T>
-void Elf_Dyn_Traits::swap(T &t, R &r) {
+void Elf_Dyn_Traits::swap(T& t, R& r) {
   r.d_tag = endian::swap(t.d_tag);
   r.d_un.d_val = endian::swap(t.d_un.d_val);
 }
 
 template <class endian, typename R, typename T>
-void Elf_Sym_Traits::swap(T &t, R &r) {
+void Elf_Sym_Traits::swap(T& t, R& r) {
   r.st_name = endian::swap(t.st_name);
   r.st_value = endian::swap(t.st_value);
   r.st_size = endian::swap(t.st_size);
   r.st_info = t.st_info;
   r.st_other = t.st_other;
   r.st_shndx = endian::swap(t.st_shndx);
 }
 
 template <class endian>
 struct _Rel_info {
-  static inline void swap(Elf32_Word &t, Elf32_Word &r) { r = endian::swap(t); }
-  static inline void swap(Elf64_Xword &t, Elf64_Xword &r) {
+  static inline void swap(Elf32_Word& t, Elf32_Word& r) { r = endian::swap(t); }
+  static inline void swap(Elf64_Xword& t, Elf64_Xword& r) {
     r = endian::swap(t);
   }
-  static inline void swap(Elf64_Xword &t, Elf32_Word &r) {
+  static inline void swap(Elf64_Xword& t, Elf32_Word& r) {
     r = endian::swap(ELF32_R_INFO(ELF64_R_SYM(t), ELF64_R_TYPE(t)));
   }
-  static inline void swap(Elf32_Word &t, Elf64_Xword &r) {
+  static inline void swap(Elf32_Word& t, Elf64_Xword& r) {
     r = endian::swap(ELF64_R_INFO(ELF32_R_SYM(t), ELF32_R_TYPE(t)));
   }
 };
 
 template <class endian, typename R, typename T>
-void Elf_Rel_Traits::swap(T &t, R &r) {
+void Elf_Rel_Traits::swap(T& t, R& r) {
   r.r_offset = endian::swap(t.r_offset);
   _Rel_info<endian>::swap(t.r_info, r.r_info);
 }
 
 template <class endian, typename R, typename T>
-void Elf_Rela_Traits::swap(T &t, R &r) {
+void Elf_Rela_Traits::swap(T& t, R& r) {
   r.r_offset = endian::swap(t.r_offset);
   _Rel_info<endian>::swap(t.r_info, r.r_info);
   r.r_addend = endian::swap(t.r_addend);
 }
 
 static const Elf32_Shdr null32_section = {0, SHT_NULL,  0, 0, 0,
                                           0, SHN_UNDEF, 0, 0, 0};
 
 Elf_Shdr null_section(null32_section);
 
-Elf_Ehdr::Elf_Ehdr(std::ifstream &file, char ei_class, char ei_data)
+Elf_Ehdr::Elf_Ehdr(std::ifstream& file, char ei_class, char ei_data)
     : serializable<Elf_Ehdr_Traits>(file, ei_class, ei_data),
       ElfSection(null_section, nullptr, nullptr) {
   shdr.sh_size = Elf_Ehdr::size(ei_class);
 }
 
-Elf::Elf(std::ifstream &file) {
+Elf::Elf(std::ifstream& file) {
   if (!file.is_open()) throw std::runtime_error("Error opening file");
 
   file.exceptions(std::ifstream::eofbit | std::ifstream::failbit |
                   std::ifstream::badbit);
   // Read ELF magic number and identification information
   char e_ident[EI_VERSION];
   file.seekg(0);
   file.read(e_ident, sizeof(e_ident));
@@ -147,17 +147,17 @@ Elf::Elf(std::ifstream &file) {
   } else if (ehdr->e_phoff != ehdr->e_ehsize)
     throw std::runtime_error(
         "unsupported ELF inconsistency: ehdr->e_phoff != ehdr->e_ehsize");
   else if (ehdr->e_phentsize != Elf_Phdr::size(e_ident[EI_CLASS]))
     throw std::runtime_error(
         "unsupported ELF inconsistency: ehdr->e_phentsize != sizeof(phdr)");
 
   // Read section headers
-  Elf_Shdr **shdr = new Elf_Shdr *[ehdr->e_shnum];
+  Elf_Shdr** shdr = new Elf_Shdr*[ehdr->e_shnum];
   file.seekg(ehdr->e_shoff);
   for (int i = 0; i < ehdr->e_shnum; i++)
     shdr[i] = new Elf_Shdr(file, e_ident[EI_CLASS], e_ident[EI_DATA]);
 
   // Sanity check in section header for index 0
   if ((shdr[0]->sh_name != 0) || (shdr[0]->sh_type != SHT_NULL) ||
       (shdr[0]->sh_flags != 0) || (shdr[0]->sh_addr != 0) ||
       (shdr[0]->sh_offset != 0) || (shdr[0]->sh_size != 0) ||
@@ -172,17 +172,17 @@ Elf::Elf(std::ifstream &file) {
         "unsupported ELF content: string table with sh_link != 0 || sh_info != "
         "0");
 
   // Store these temporarily
   tmp_shdr = shdr;
   tmp_file = &file;
 
   // Fill sections list
-  sections = new ElfSection *[ehdr->e_shnum];
+  sections = new ElfSection*[ehdr->e_shnum];
   for (int i = 0; i < ehdr->e_shnum; i++) sections[i] = nullptr;
   for (int i = 1; i < ehdr->e_shnum; i++) {
     if (sections[i] != nullptr) continue;
     getSection(i);
   }
   Elf_Shdr s;
   s.sh_name = 0;
   s.sh_type = SHT_NULL;
@@ -218,17 +218,17 @@ Elf::Elf(std::ifstream &file) {
   if (shdr_section->getPrevious() == nullptr)
     shdr_section->insertAfter(sections[ehdr->e_shnum - 1], false);
 
   tmp_file = nullptr;
   tmp_shdr = nullptr;
   for (int i = 0; i < ehdr->e_shnum; i++) delete shdr[i];
   delete[] shdr;
 
-  eh_shstrndx = (ElfStrtab_Section *)sections[ehdr->e_shstrndx];
+  eh_shstrndx = (ElfStrtab_Section*)sections[ehdr->e_shstrndx];
 
   // Skip reading program headers if there aren't any
   if (ehdr->e_phnum == 0) return;
 
   bool adjusted_phdr_section = false;
   // Read program headers
   file.seekg(ehdr->e_phoff);
   for (int i = 0; i < ehdr->e_phnum; i++) {
@@ -237,17 +237,17 @@ Elf::Elf(std::ifstream &file) {
       // Default alignment for PT_LOAD on x86-64 prevents elfhack from
       // doing anything useful. However, the system doesn't actually
       // require such a big alignment, so in order for elfhack to work
       // efficiently, reduce alignment when it's originally the default
       // one.
       if ((ehdr->e_machine == EM_X86_64) && (phdr.p_align == 0x200000))
         phdr.p_align = 0x1000;
     }
-    ElfSegment *segment = new ElfSegment(&phdr);
+    ElfSegment* segment = new ElfSegment(&phdr);
     // Some segments aren't entirely filled (if at all) by sections
     // For those, we use fake sections
     if ((phdr.p_type == PT_LOAD) && (phdr.p_offset == 0)) {
       // Use a fake section for ehdr and phdr
       ehdr->getShdr().sh_addr = phdr.p_vaddr;
       if (!adjusted_phdr_section) {
         phdr_section->getShdr().sh_addr += phdr.p_vaddr;
         adjusted_phdr_section = true;
@@ -281,41 +281,41 @@ Elf::Elf(std::ifstream &file) {
     assert(memsize == phdr.p_memsz - gold_adjustment);
     segments.push_back(segment);
   }
 
   new (&eh_entry) ElfLocation(ehdr->e_entry, this);
 }
 
 Elf::~Elf() {
-  for (std::vector<ElfSegment *>::iterator seg = segments.begin();
+  for (std::vector<ElfSegment*>::iterator seg = segments.begin();
        seg != segments.end(); seg++)
     delete *seg;
   delete[] sections;
-  ElfSection *section = ehdr;
+  ElfSection* section = ehdr;
   while (section != nullptr) {
-    ElfSection *next = section->getNext();
+    ElfSection* next = section->getNext();
     delete section;
     section = next;
   }
 }
 
 // TODO: This shouldn't fail after inserting sections
-ElfSection *Elf::getSection(int index) {
+ElfSection* Elf::getSection(int index) {
   if ((index < -1) || (index >= ehdr->e_shnum))
     throw std::runtime_error("Section index out of bounds");
   if (index == -1)
     index = ehdr->e_shstrndx;  // TODO: should be fixed to use the actual
                                // current number
   // Special case: the section at index 0 is void
   if (index == 0) return nullptr;
   // Infinite recursion guard
-  if (sections[index] == (ElfSection *)this) return nullptr;
+  if (sections[index] == (ElfSection*)this) return nullptr;
   if (sections[index] == nullptr) {
-    sections[index] = (ElfSection *)this;
+    sections[index] = (ElfSection*)this;
     switch (tmp_shdr[index]->sh_type) {
       case SHT_DYNAMIC:
         sections[index] =
             new ElfDynamic_Section(*tmp_shdr[index], tmp_file, this);
         break;
       case SHT_REL:
         sections[index] =
             new ElfRel_Section<Elf_Rel>(*tmp_shdr[index], tmp_file, this);
@@ -335,87 +335,87 @@ ElfSection *Elf::getSection(int index) {
         break;
       default:
         sections[index] = new ElfSection(*tmp_shdr[index], tmp_file, this);
     }
   }
   return sections[index];
 }
 
-ElfSection *Elf::getSectionAt(unsigned int offset) {
+ElfSection* Elf::getSectionAt(unsigned int offset) {
   for (int i = 1; i < ehdr->e_shnum; i++) {
-    ElfSection *section = getSection(i);
+    ElfSection* section = getSection(i);
     if ((section != nullptr) && (section->getFlags() & SHF_ALLOC) &&
         !(section->getFlags() & SHF_TLS) && (offset >= section->getAddr()) &&
         (offset < section->getAddr() + section->getSize()))
       return section;
   }
   return nullptr;
 }
 
-ElfSegment *Elf::getSegmentByType(unsigned int type, ElfSegment *last) {
-  std::vector<ElfSegment *>::iterator seg;
+ElfSegment* Elf::getSegmentByType(unsigned int type, ElfSegment* last) {
+  std::vector<ElfSegment*>::iterator seg;
   if (last) {
     seg = std::find(segments.begin(), segments.end(), last);
     ++seg;
   } else
     seg = segments.begin();
   for (; seg != segments.end(); seg++)
     if ((*seg)->getType() == type) return *seg;
   return nullptr;
 }
 
-void Elf::removeSegment(ElfSegment *segment) {
+void Elf::removeSegment(ElfSegment* segment) {
   if (!segment) return;
-  std::vector<ElfSegment *>::iterator seg;
+  std::vector<ElfSegment*>::iterator seg;
   seg = std::find(segments.begin(), segments.end(), segment);
   if (seg == segments.end()) return;
   segment->clear();
   segments.erase(seg);
 }
 
-ElfDynamic_Section *Elf::getDynSection() {
-  for (std::vector<ElfSegment *>::iterator seg = segments.begin();
+ElfDynamic_Section* Elf::getDynSection() {
+  for (std::vector<ElfSegment*>::iterator seg = segments.begin();
        seg != segments.end(); seg++)
     if (((*seg)->getType() == PT_DYNAMIC) &&
         ((*seg)->getFirstSection() != nullptr) &&
         (*seg)->getFirstSection()->getType() == SHT_DYNAMIC)
-      return (ElfDynamic_Section *)(*seg)->getFirstSection();
+      return (ElfDynamic_Section*)(*seg)->getFirstSection();
 
   return nullptr;
 }
 
 void Elf::normalize() {
   // fixup section headers sh_name; TODO: that should be done by sections
   // themselves
-  for (ElfSection *section = ehdr; section != nullptr;
+  for (ElfSection* section = ehdr; section != nullptr;
        section = section->getNext()) {
     if (section->getIndex() == 0)
       continue;
     else
       ehdr->e_shnum = section->getIndex() + 1;
     section->getShdr().sh_name = eh_shstrndx->getStrIndex(section->getName());
   }
   ehdr->markDirty();
   // Check segments consistency
   int i = 0;
-  for (std::vector<ElfSegment *>::iterator seg = segments.begin();
+  for (std::vector<ElfSegment*>::iterator seg = segments.begin();
        seg != segments.end(); seg++, i++) {
-    std::list<ElfSection *>::iterator it = (*seg)->begin();
-    for (ElfSection *last = *(it++); it != (*seg)->end(); last = *(it++)) {
+    std::list<ElfSection*>::iterator it = (*seg)->begin();
+    for (ElfSection* last = *(it++); it != (*seg)->end(); last = *(it++)) {
       if (((*it)->getType() != SHT_NOBITS) &&
           ((*it)->getAddr() - last->getAddr()) !=
               ((*it)->getOffset() - last->getOffset())) {
         throw std::runtime_error("Segments inconsistency");
       }
     }
   }
 
-  ElfSegment *prevLoad = nullptr;
-  for (auto &it : segments) {
+  ElfSegment* prevLoad = nullptr;
+  for (auto& it : segments) {
     if (it->getType() == PT_LOAD) {
       if (prevLoad) {
         size_t alignedPrevEnd = (prevLoad->getAddr() + prevLoad->getMemSize() +
                                  prevLoad->getAlign() - 1) &
                                 ~(prevLoad->getAlign() - 1);
         size_t alignedStart = it->getAddr() & ~(it->getAlign() - 1);
         if (alignedPrevEnd > alignedStart) {
           throw std::runtime_error("Segments overlap");
@@ -437,84 +437,84 @@ void Elf::normalize() {
     shdr_section->getShdr().sh_size =
         ehdr->e_shnum * Elf_Shdr::size(ehdr->e_ident[EI_CLASS]);
   ehdr->e_shoff = shdr_section->getOffset();
   ehdr->e_entry = eh_entry.getValue();
   ehdr->e_shstrndx = eh_shstrndx->getIndex();
 
   // Check sections consistency
   unsigned int minOffset = 0;
-  for (ElfSection *section = ehdr; section != nullptr;
+  for (ElfSection* section = ehdr; section != nullptr;
        section = section->getNext()) {
     unsigned int offset = section->getOffset();
     if (offset < minOffset) {
       throw std::runtime_error("Sections overlap");
     }
     if (section->getType() != SHT_NOBITS) {
       minOffset = offset + section->getSize();
     }
   }
 }
 
-void Elf::write(std::ofstream &file) {
+void Elf::write(std::ofstream& file) {
   normalize();
-  for (ElfSection *section = ehdr; section != nullptr;
+  for (ElfSection* section = ehdr; section != nullptr;
        section = section->getNext()) {
     file.seekp(section->getOffset());
     if (section == phdr_section) {
-      for (std::vector<ElfSegment *>::iterator seg = segments.begin();
+      for (std::vector<ElfSegment*>::iterator seg = segments.begin();
            seg != segments.end(); seg++) {
         Elf_Phdr phdr;
         phdr.p_type = (*seg)->getType();
         phdr.p_flags = (*seg)->getFlags();
         phdr.p_offset = (*seg)->getOffset();
         phdr.p_vaddr = (*seg)->getAddr();
         phdr.p_paddr = phdr.p_vaddr + (*seg)->getVPDiff();
         phdr.p_filesz = (*seg)->getFileSize();
         phdr.p_memsz = (*seg)->getMemSize();
         phdr.p_align = (*seg)->getAlign();
         phdr.serialize(file, ehdr->e_ident[EI_CLASS], ehdr->e_ident[EI_DATA]);
       }
     } else if (section == shdr_section) {
       null_section.serialize(file, ehdr->e_ident[EI_CLASS],
                              ehdr->e_ident[EI_DATA]);
-      for (ElfSection *sec = ehdr; sec != nullptr; sec = sec->getNext()) {
+      for (ElfSection* sec = ehdr; sec != nullptr; sec = sec->getNext()) {
         if (sec->getType() != SHT_NULL)
           sec->getShdr().serialize(file, ehdr->e_ident[EI_CLASS],
                                    ehdr->e_ident[EI_DATA]);
       }
     } else
       section->serialize(file, ehdr->e_ident[EI_CLASS], ehdr->e_ident[EI_DATA]);
   }
 }
 
-ElfSection::ElfSection(Elf_Shdr &s, std::ifstream *file, Elf *parent)
+ElfSection::ElfSection(Elf_Shdr& s, std::ifstream* file, Elf* parent)
     : shdr(s),
       link(shdr.sh_link == SHN_UNDEF ? nullptr
                                      : parent->getSection(shdr.sh_link)),
       next(nullptr),
       previous(nullptr),
       index(-1) {
   if ((file == nullptr) || (shdr.sh_type == SHT_NULL) ||
       (shdr.sh_type == SHT_NOBITS))
     data = nullptr;
   else {
-    data = static_cast<char *>(malloc(shdr.sh_size));
+    data = static_cast<char*>(malloc(shdr.sh_size));
     if (!data) {
       throw std::runtime_error("Could not malloc ElfSection data");
     }
     int pos = file->tellg();
     file->seekg(shdr.sh_offset);
     file->read(data, shdr.sh_size);
     file->seekg(pos);
   }
   if (shdr.sh_name == 0)
     name = nullptr;
   else {
-    ElfStrtab_Section *strtab = (ElfStrtab_Section *)parent->getSection(-1);
+    ElfStrtab_Section* strtab = (ElfStrtab_Section*)parent->getSection(-1);
     // Special case (see elfgeneric.cpp): if strtab is nullptr, the
     // section being created is the strtab.
     if (strtab == nullptr)
       name = &data[shdr.sh_name];
     else
       name = strtab->getStr(shdr.sh_name);
   }
   // Only SHT_REL/SHT_RELA sections use sh_info to store a section
@@ -543,28 +543,28 @@ unsigned int ElfSection::getAddr() {
 
 unsigned int ElfSection::getOffset() {
   if (shdr.sh_offset != (Elf32_Word)-1) return shdr.sh_offset;
 
   if (previous == nullptr) return (shdr.sh_offset = 0);
 
   unsigned int offset = previous->getOffset();
 
-  ElfSegment *ptload = getSegmentByType(PT_LOAD);
-  ElfSegment *prev_ptload = previous->getSegmentByType(PT_LOAD);
+  ElfSegment* ptload = getSegmentByType(PT_LOAD);
+  ElfSegment* prev_ptload = previous->getSegmentByType(PT_LOAD);
 
   if (ptload && (ptload == prev_ptload)) {
     offset += getAddr() - previous->getAddr();
     return (shdr.sh_offset = offset);
   }
 
   if (previous->getType() != SHT_NOBITS) offset += previous->getSize();
 
   Elf32_Word align = 0x1000;
-  for (std::vector<ElfSegment *>::iterator seg = segments.begin();
+  for (std::vector<ElfSegment*>::iterator seg = segments.begin();
        seg != segments.end(); seg++)
     align = std::max(align, (*seg)->getAlign());
 
   Elf32_Word mask = align - 1;
   // SHF_TLS is used for .tbss which is some kind of special case.
   if (((getType() != SHT_NOBITS) || (getFlags() & SHF_TLS)) &&
       (getFlags() & SHF_ALLOC)) {
     if ((getAddr() & mask) < (offset & mask))
@@ -576,69 +576,69 @@ unsigned int ElfSection::getOffset() {
     offset = (offset | (getAddrAlign() - 1)) + 1;
 
   return (shdr.sh_offset = offset);
 }
 
 int ElfSection::getIndex() {
   if (index != -1) return index;
   if (getType() == SHT_NULL) return (index = 0);
-  ElfSection *reference;
+  ElfSection* reference;
   for (reference = previous;
        (reference != nullptr) && (reference->getType() == SHT_NULL);
        reference = reference->getPrevious())
     ;
   if (reference == nullptr) return (index = 1);
   return (index = reference->getIndex() + 1);
 }
 
-Elf_Shdr &ElfSection::getShdr() {
+Elf_Shdr& ElfSection::getShdr() {
   getOffset();
   if (shdr.sh_link == (Elf32_Word)-1)
     shdr.sh_link = getLink() ? getLink()->getIndex() : 0;
   if (shdr.sh_info == (Elf32_Word)-1)
     shdr.sh_info = ((getType() == SHT_REL) || (getType() == SHT_RELA))
                        ? (getInfo().section ? getInfo().section->getIndex() : 0)
                        : getInfo().index;
 
   return shdr;
 }
 
-ElfSegment::ElfSegment(Elf_Phdr *phdr)
+ElfSegment::ElfSegment(Elf_Phdr* phdr)
     : type(phdr->p_type),
       v_p_diff(phdr->p_paddr - phdr->p_vaddr),
       flags(phdr->p_flags),
       align(phdr->p_align),
       vaddr(phdr->p_vaddr),
       filesz(phdr->p_filesz),
       memsz(phdr->p_memsz) {}
 
-void ElfSegment::addSection(ElfSection *section) {
+void ElfSegment::addSection(ElfSection* section) {
   // Make sure all sections in PT_GNU_RELRO won't be moved by elfhack
   assert(!((type == PT_GNU_RELRO) && (section->isRelocatable())));
 
   // TODO: Check overlapping sections
-  std::list<ElfSection *>::iterator i;
+  std::list<ElfSection*>::iterator i;
   for (i = sections.begin(); i != sections.end(); ++i)
     if ((*i)->getAddr() > section->getAddr()) break;
   sections.insert(i, section);
   section->addToSegment(this);
 }
 
-void ElfSegment::removeSection(ElfSection *section) {
+void ElfSegment::removeSection(ElfSection* section) {
   sections.remove(section);
   section->removeFromSegment(this);
 }
 
 unsigned int ElfSegment::getFileSize() {
   if (type == PT_GNU_RELRO) return filesz;
 
   if (sections.empty()) return 0;
   // Search the last section that is not SHT_NOBITS
-  std::list<ElfSection *>::reverse_iterator i;
+  std::list<ElfSection*>::reverse_iterator i;
   for (i = sections.rbegin();
        (i != sections.rend()) && ((*i)->getType() == SHT_NOBITS); ++i)
     ;
   // All sections are SHT_NOBITS
   if (i == sections.rend()) return 0;
 
   unsigned int end = (*i)->getAddr() + (*i)->getSize();
 
@@ -669,35 +669,35 @@ unsigned int ElfSegment::getAddr() {
       (sections.front()->getAddr() != vaddr))
     throw std::runtime_error(
         "PT_GNU_RELRO segment doesn't start on a section start");
 
   return sections.empty() ? 0 : sections.front()->getAddr();
 }
 
 void ElfSegment::clear() {
-  for (std::list<ElfSection *>::iterator i = sections.begin();
+  for (std::list<ElfSection*>::iterator i = sections.begin();
        i != sections.end(); ++i)
     (*i)->removeFromSegment(this);
   sections.clear();
 }
 
-ElfValue *ElfDynamic_Section::getValueForType(unsigned int tag) {
+ElfValue* ElfDynamic_Section::getValueForType(unsigned int tag) {
   for (unsigned int i = 0; i < shdr.sh_size / shdr.sh_entsize; i++)
     if (dyns[i].tag == tag) return dyns[i].value;
 
   return nullptr;
 }
 
-ElfSection *ElfDynamic_Section::getSectionForType(unsigned int tag) {
-  ElfValue *value = getValueForType(tag);
+ElfSection* ElfDynamic_Section::getSectionForType(unsigned int tag) {
+  ElfValue* value = getValueForType(tag);
   return value ? value->getSection() : nullptr;
 }
 
-bool ElfDynamic_Section::setValueForType(unsigned int tag, ElfValue *val) {
+bool ElfDynamic_Section::setValueForType(unsigned int tag, ElfValue* val) {
   unsigned int i;
   unsigned int shnum = shdr.sh_size / shdr.sh_entsize;
   for (i = 0; (i < shnum) && (dyns[i].tag != DT_NULL); i++)
     if (dyns[i].tag == tag) {
       delete dyns[i].value;
       dyns[i].value = val;
       return true;
     }
@@ -706,18 +706,18 @@ bool ElfDynamic_Section::setValueForType
   // use to add our value, but if we are on the last entry, we can't.
   if (i >= shnum - 1) return false;
 
   dyns[i].tag = tag;
   dyns[i].value = val;
   return true;
 }
 
-ElfDynamic_Section::ElfDynamic_Section(Elf_Shdr &s, std::ifstream *file,
-                                       Elf *parent)
+ElfDynamic_Section::ElfDynamic_Section(Elf_Shdr& s, std::ifstream* file,
+                                       Elf* parent)
     : ElfSection(s, file, parent) {
   int pos = file->tellg();
   dyns.resize(s.sh_size / s.sh_entsize);
   file->seekg(shdr.sh_offset);
   // Here we assume tags refer to only one section (e.g. DT_RELSZ accounts
   // for .rel.dyn size)
   for (unsigned int i = 0; i < s.sh_size / s.sh_entsize; i++) {
     Elf_Dyn dyn(*file, parent->getClass(), parent->getData());
@@ -797,130 +797,130 @@ ElfDynamic_Section::ElfDynamic_Section(E
   file->seekg(pos);
 }
 
 ElfDynamic_Section::~ElfDynamic_Section() {
   for (unsigned int i = 0; i < shdr.sh_size / shdr.sh_entsize; i++)
     delete dyns[i].value;
 }
 
-void ElfDynamic_Section::serialize(std::ofstream &file, char ei_class,
+void ElfDynamic_Section::serialize(std::ofstream& file, char ei_class,
                                    char ei_data) {
   for (unsigned int i = 0; i < shdr.sh_size / shdr.sh_entsize; i++) {
     Elf_Dyn dyn;
     dyn.d_tag = dyns[i].tag;
     dyn.d_un.d_val = (dyns[i].value != nullptr) ? dyns[i].value->getValue() : 0;
     dyn.serialize(file, ei_class, ei_data);
   }
 }
 
-ElfSymtab_Section::ElfSymtab_Section(Elf_Shdr &s, std::ifstream *file,
-                                     Elf *parent)
+ElfSymtab_Section::ElfSymtab_Section(Elf_Shdr& s, std::ifstream* file,
+                                     Elf* parent)
     : ElfSection(s, file, parent) {
   int pos = file->tellg();
   syms.resize(s.sh_size / s.sh_entsize);
-  ElfStrtab_Section *strtab = (ElfStrtab_Section *)getLink();
+  ElfStrtab_Section* strtab = (ElfStrtab_Section*)getLink();
   file->seekg(shdr.sh_offset);
   for (unsigned int i = 0; i < shdr.sh_size / shdr.sh_entsize; i++) {
     Elf_Sym sym(*file, parent->getClass(), parent->getData());
     syms[i].name = strtab->getStr(sym.st_name);
     syms[i].info = sym.st_info;
     syms[i].other = sym.st_other;
-    ElfSection *section =
+    ElfSection* section =
         (sym.st_shndx == SHN_ABS) ? nullptr : parent->getSection(sym.st_shndx);
     new (&syms[i].value)
         ElfLocation(section, sym.st_value, ElfLocation::ABSOLUTE);
     syms[i].size = sym.st_size;
     syms[i].defined = (sym.st_shndx != SHN_UNDEF);
   }
   file->seekg(pos);
 }
 
-void ElfSymtab_Section::serialize(std::ofstream &file, char ei_class,
+void ElfSymtab_Section::serialize(std::ofstream& file, char ei_class,
                                   char ei_data) {
-  ElfStrtab_Section *strtab = (ElfStrtab_Section *)getLink();
+  ElfStrtab_Section* strtab = (ElfStrtab_Section*)getLink();
   for (unsigned int i = 0; i < shdr.sh_size / shdr.sh_entsize; i++) {
     Elf_Sym sym;
     sym.st_name = strtab->getStrIndex(syms[i].name);
     sym.st_info = syms[i].info;
     sym.st_other = syms[i].other;
     sym.st_value = syms[i].value.getValue();
-    ElfSection *section = syms[i].value.getSection();
+    ElfSection* section = syms[i].value.getSection();
     if (syms[i].defined)
       sym.st_shndx = section ? section->getIndex() : SHN_ABS;
     else
       sym.st_shndx = SHN_UNDEF;
     sym.st_size = syms[i].size;
     sym.serialize(file, ei_class, ei_data);
   }
 }
 
-Elf_SymValue *ElfSymtab_Section::lookup(const char *name,
+Elf_SymValue* ElfSymtab_Section::lookup(const char* name,
                                         unsigned int type_filter) {
   for (std::vector<Elf_SymValue>::iterator sym = syms.begin();
        sym != syms.end(); sym++) {
     if ((type_filter & (1 << ELF32_ST_TYPE(sym->info))) &&
         (strcmp(sym->name, name) == 0)) {
       return &*sym;
     }
   }
   return nullptr;
 }
 
-const char *ElfStrtab_Section::getStr(unsigned int index) {
+const char* ElfStrtab_Section::getStr(unsigned int index) {
   for (std::vector<table_storage>::iterator t = table.begin(); t != table.end();
        t++) {
     if (index < t->used) return t->buf + index;
     index -= t->used;
   }
   assert(1 == 0);
   return nullptr;
 }
 
-const char *ElfStrtab_Section::getStr(const char *string) {
+const char* ElfStrtab_Section::getStr(const char* string) {
   if (string == nullptr) return nullptr;
 
   // If the given string is within the section, return it
   for (std::vector<table_storage>::iterator t = table.begin(); t != table.end();
        t++)
     if ((string >= t->buf) && (string < t->buf + t->used)) return string;
 
   // TODO: should scan in the section to find an existing string
 
   // If not, we need to allocate the string in the section
   size_t len = strlen(string) + 1;
 
   if (table.back().size - table.back().used < len)
     table.resize(table.size() + 1);
 
-  char *alloc_str = table.back().buf + table.back().used;
+  char* alloc_str = table.back().buf + table.back().used;
   memcpy(alloc_str, string, len);
   table.back().used += len;
 
   shdr.sh_size += len;
   markDirty();
 
   return alloc_str;
 }
 
-unsigned int ElfStrtab_Section::getStrIndex(const char *string) {
+unsigned int ElfStrtab_Section::getStrIndex(const char* string) {
   if (string == nullptr) return 0;
 
   unsigned int index = 0;
   string = getStr(string);
   for (std::vector<table_storage>::iterator t = table.begin(); t != table.end();
        t++) {
     if ((string >= t->buf) && (string < t->buf + t->used))
       return index + (string - t->buf);
     index += t->used;
   }
 
   assert(1 == 0);
   return 0;
 }
 
-void ElfStrtab_Section::serialize(std::ofstream &file, char ei_class,
+void ElfStrtab_Section::serialize(std::ofstream& file, char ei_class,
                                   char ei_data) {
   file.seekp(getOffset());
   for (std::vector<table_storage>::iterator t = table.begin(); t != table.end();
        t++)
     file.write(t->buf, t->used);
 }
--- a/build/unix/elfhack/elfhack.cpp
+++ b/build/unix/elfhack/elfhack.cpp
@@ -22,77 +22,77 @@
 #endif
 #ifndef R_ARM_JUMP24
 #  define R_ARM_JUMP24 0x1d
 #endif
 #ifndef R_ARM_THM_JUMP24
 #  define R_ARM_THM_JUMP24 0x1e
 #endif
 
-char *rundir = nullptr;
+char* rundir = nullptr;
 
 template <typename T>
 struct wrapped {
   T value;
 };
 
 class Elf_Addr_Traits {
  public:
   typedef wrapped<Elf32_Addr> Type32;
   typedef wrapped<Elf64_Addr> Type64;
 
   template <class endian, typename R, typename T>
-  static inline void swap(T &t, R &r) {
+  static inline void swap(T& t, R& r) {
     r.value = endian::swap(t.value);
   }
 };
 
 typedef serializable<Elf_Addr_Traits> Elf_Addr;
 
 class Elf_RelHack_Traits {
  public:
   typedef Elf32_Rel Type32;
   typedef Elf32_Rel Type64;
 
   template <class endian, typename R, typename T>
-  static inline void swap(T &t, R &r) {
+  static inline void swap(T& t, R& r) {
     r.r_offset = endian::swap(t.r_offset);
     r.r_info = endian::swap(t.r_info);
   }
 };
 
 typedef serializable<Elf_RelHack_Traits> Elf_RelHack;
 
 class ElfRelHack_Section : public ElfSection {
  public:
-  ElfRelHack_Section(Elf_Shdr &s) : ElfSection(s, nullptr, nullptr) {
+  ElfRelHack_Section(Elf_Shdr& s) : ElfSection(s, nullptr, nullptr) {
     name = elfhack_data;
   };
 
-  void serialize(std::ofstream &file, char ei_class, char ei_data) {
+  void serialize(std::ofstream& file, char ei_class, char ei_data) {
     for (std::vector<Elf_RelHack>::iterator i = rels.begin(); i != rels.end();
          ++i)
       (*i).serialize(file, ei_class, ei_data);
   }
 
   bool isRelocatable() { return true; }
 
-  void push_back(Elf_RelHack &r) {
+  void push_back(Elf_RelHack& r) {
     rels.push_back(r);
     shdr.sh_size = rels.size() * shdr.sh_entsize;
   }
 
  private:
   std::vector<Elf_RelHack> rels;
 };
 
 class ElfRelHackCode_Section : public ElfSection {
  public:
-  ElfRelHackCode_Section(Elf_Shdr &s, Elf &e,
-                         ElfRelHack_Section &relhack_section, unsigned int init,
+  ElfRelHackCode_Section(Elf_Shdr& s, Elf& e,
+                         ElfRelHack_Section& relhack_section, unsigned int init,
                          unsigned int mprotect_cb, unsigned int sysconf_cb)
       : ElfSection(s, nullptr, nullptr),
         parent(e),
         relhack_section(relhack_section),
         init(init),
         init_trampoline(nullptr),
         mprotect_cb(mprotect_cb),
         sysconf_cb(sysconf_cb) {
@@ -115,158 +115,158 @@ class ElfRelHackCode_Section : public El
     std::ifstream inject(file.c_str(), std::ios::in | std::ios::binary);
     elf = new Elf(inject);
     if (elf->getType() != ET_REL)
       throw std::runtime_error("object for injected code is not ET_REL");
     if (elf->getMachine() != parent.getMachine())
       throw std::runtime_error(
           "architecture of object for injected code doesn't match");
 
-    ElfSymtab_Section *symtab = nullptr;
+    ElfSymtab_Section* symtab = nullptr;
 
     // Find the symbol table.
-    for (ElfSection *section = elf->getSection(1); section != nullptr;
+    for (ElfSection* section = elf->getSection(1); section != nullptr;
          section = section->getNext()) {
       if (section->getType() == SHT_SYMTAB)
-        symtab = (ElfSymtab_Section *)section;
+        symtab = (ElfSymtab_Section*)section;
     }
     if (symtab == nullptr)
       throw std::runtime_error(
           "Couldn't find a symbol table for the injected code");
 
     relro = parent.getSegmentByType(PT_GNU_RELRO);
 
     // Find the init symbol
     entry_point = -1;
     std::string symbol = "init";
     if (!init) symbol += "_noinit";
     if (relro) symbol += "_relro";
-    Elf_SymValue *sym = symtab->lookup(symbol.c_str());
+    Elf_SymValue* sym = symtab->lookup(symbol.c_str());
     if (!sym)
       throw std::runtime_error(
           "Couldn't find an 'init' symbol in the injected code");
 
     entry_point = sym->value.getValue();
 
     // Get all relevant sections from the injected code object.
     add_code_section(sym->value.getSection());
 
     // If the original init function is located too far away, we're going to
     // need to use a trampoline. See comment in inject.c.
     // Theoretically, we should check for (init - instr) > 0xffffff, where instr
     // is the virtual address of the instruction that calls the original init,
     // but we don't have it at this point, so punt to just init.
     if (init > 0xffffff && parent.getMachine() == EM_ARM) {
-      Elf_SymValue *trampoline = symtab->lookup("init_trampoline");
+      Elf_SymValue* trampoline = symtab->lookup("init_trampoline");
       if (!trampoline) {
         throw std::runtime_error(
             "Couldn't find an 'init_trampoline' symbol in the injected code");
       }
 
       init_trampoline = trampoline->value.getSection();
       add_code_section(init_trampoline);
     }
 
     // Adjust code sections offsets according to their size
-    std::vector<ElfSection *>::iterator c = code.begin();
+    std::vector<ElfSection*>::iterator c = code.begin();
     (*c)->getShdr().sh_addr = 0;
-    for (ElfSection *last = *(c++); c != code.end(); ++c) {
+    for (ElfSection* last = *(c++); c != code.end(); ++c) {
       unsigned int addr = last->getShdr().sh_addr + last->getSize();
       if (addr & ((*c)->getAddrAlign() - 1))
         addr = (addr | ((*c)->getAddrAlign() - 1)) + 1;
       (*c)->getShdr().sh_addr = addr;
       // We need to align this section depending on the greater
       // alignment required by code sections.
       if (shdr.sh_addralign < (*c)->getAddrAlign())
         shdr.sh_addralign = (*c)->getAddrAlign();
       last = *c;
     }
     shdr.sh_size = code.back()->getAddr() + code.back()->getSize();
-    data = static_cast<char *>(malloc(shdr.sh_size));
+    data = static_cast<char*>(malloc(shdr.sh_size));
     if (!data) {
       throw std::runtime_error("Could not malloc ElfSection data");
     }
-    char *buf = data;
+    char* buf = data;
     for (c = code.begin(); c != code.end(); ++c) {
       memcpy(buf, (*c)->getData(), (*c)->getSize());
       buf += (*c)->getSize();
     }
     name = elfhack_text;
   }
 
   ~ElfRelHackCode_Section() { delete elf; }
 
-  void serialize(std::ofstream &file, char ei_class, char ei_data) {
+  void serialize(std::ofstream& file, char ei_class, char ei_data) {
     // Readjust code offsets
-    for (std::vector<ElfSection *>::iterator c = code.begin(); c != code.end();
+    for (std::vector<ElfSection*>::iterator c = code.begin(); c != code.end();
          ++c)
       (*c)->getShdr().sh_addr += getAddr();
 
     // Apply relocations
-    for (std::vector<ElfSection *>::iterator c = code.begin(); c != code.end();
+    for (std::vector<ElfSection*>::iterator c = code.begin(); c != code.end();
          ++c) {
-      for (ElfSection *rel = elf->getSection(1); rel != nullptr;
+      for (ElfSection* rel = elf->getSection(1); rel != nullptr;
            rel = rel->getNext())
         if (((rel->getType() == SHT_REL) || (rel->getType() == SHT_RELA)) &&
             (rel->getInfo().section == *c)) {
           if (rel->getType() == SHT_REL)
-            apply_relocations((ElfRel_Section<Elf_Rel> *)rel, *c);
+            apply_relocations((ElfRel_Section<Elf_Rel>*)rel, *c);
           else
-            apply_relocations((ElfRel_Section<Elf_Rela> *)rel, *c);
+            apply_relocations((ElfRel_Section<Elf_Rela>*)rel, *c);
         }
     }
 
     ElfSection::serialize(file, ei_class, ei_data);
   }
 
   bool isRelocatable() { return false; }
 
   unsigned int getEntryPoint() { return entry_point; }
 
-  void insertBefore(ElfSection *section, bool dirty = true) override {
+  void insertBefore(ElfSection* section, bool dirty = true) override {
     // Adjust the address so that this section is adjacent to the one it's
     // being inserted before. This avoids creating holes which subsequently
     // might lead the PHDR-adjusting code to create unnecessary additional
     // PT_LOADs.
     shdr.sh_addr =
         (section->getAddr() - shdr.sh_size) & ~(shdr.sh_addralign - 1);
     ElfSection::insertBefore(section, dirty);
   }
 
  private:
-  void add_code_section(ElfSection *section) {
+  void add_code_section(ElfSection* section) {
     if (section) {
       /* Don't add section if it's already been added in the past */
       for (auto s = code.begin(); s != code.end(); ++s) {
         if (section == *s) return;
       }
       code.push_back(section);
       find_code(section);
     }
   }
 
   /* Look at the relocations associated to the given section to find other
    * sections that it requires */
-  void find_code(ElfSection *section) {
-    for (ElfSection *s = elf->getSection(1); s != nullptr; s = s->getNext()) {
+  void find_code(ElfSection* section) {
+    for (ElfSection* s = elf->getSection(1); s != nullptr; s = s->getNext()) {
       if (((s->getType() == SHT_REL) || (s->getType() == SHT_RELA)) &&
           (s->getInfo().section == section)) {
         if (s->getType() == SHT_REL)
-          scan_relocs_for_code((ElfRel_Section<Elf_Rel> *)s);
+          scan_relocs_for_code((ElfRel_Section<Elf_Rel>*)s);
         else
-          scan_relocs_for_code((ElfRel_Section<Elf_Rela> *)s);
+          scan_relocs_for_code((ElfRel_Section<Elf_Rela>*)s);
       }
     }
   }
 
   template <typename Rel_Type>
-  void scan_relocs_for_code(ElfRel_Section<Rel_Type> *rel) {
-    ElfSymtab_Section *symtab = (ElfSymtab_Section *)rel->getLink();
+  void scan_relocs_for_code(ElfRel_Section<Rel_Type>* rel) {
+    ElfSymtab_Section* symtab = (ElfSymtab_Section*)rel->getLink();
     for (auto r = rel->rels.begin(); r != rel->rels.end(); ++r) {
-      ElfSection *section =
+      ElfSection* section =
           symtab->syms[ELF32_R_SYM(r->r_info)].value.getSection();
       add_code_section(section);
     }
   }
 
   class pc32_relocation {
    public:
     Elf32_Addr operator()(unsigned int base_addr, Elf32_Off offset,
@@ -344,51 +344,51 @@ class ElfRelHackCode_Section : public El
    public:
     Elf32_Addr operator()(unsigned int base_addr, Elf32_Off offset,
                           Elf32_Word addend, unsigned int addr) {
       return addr + addend;
     }
   };
 
   template <class relocation_type>
-  void apply_relocation(ElfSection *the_code, char *base, Elf_Rel *r,
+  void apply_relocation(ElfSection* the_code, char* base, Elf_Rel* r,
                         unsigned int addr) {
     relocation_type relocation;
     Elf32_Addr value;
     memcpy(&value, base + r->r_offset, 4);
     value = relocation(the_code->getAddr(), r->r_offset, value, addr);
     memcpy(base + r->r_offset, &value, 4);
   }
 
   template <class relocation_type>
-  void apply_relocation(ElfSection *the_code, char *base, Elf_Rela *r,
+  void apply_relocation(ElfSection* the_code, char* base, Elf_Rela* r,
                         unsigned int addr) {
     relocation_type relocation;
     Elf32_Addr value =
         relocation(the_code->getAddr(), r->r_offset, r->r_addend, addr);
     memcpy(base + r->r_offset, &value, 4);
   }
 
   template <typename Rel_Type>
-  void apply_relocations(ElfRel_Section<Rel_Type> *rel, ElfSection *the_code) {
+  void apply_relocations(ElfRel_Section<Rel_Type>* rel, ElfSection* the_code) {
     assert(rel->getType() == Rel_Type::sh_type);
-    char *buf = data + (the_code->getAddr() - code.front()->getAddr());
+    char* buf = data + (the_code->getAddr() - code.front()->getAddr());
     // TODO: various checks on the sections
-    ElfSymtab_Section *symtab = (ElfSymtab_Section *)rel->getLink();
+    ElfSymtab_Section* symtab = (ElfSymtab_Section*)rel->getLink();
     for (typename std::vector<Rel_Type>::iterator r = rel->rels.begin();
          r != rel->rels.end(); ++r) {
       // TODO: various checks on the symbol
-      const char *name = symtab->syms[ELF32_R_SYM(r->r_info)].name;
+      const char* name = symtab->syms[ELF32_R_SYM(r->r_info)].name;
       unsigned int addr;
       if (symtab->syms[ELF32_R_SYM(r->r_info)].value.getSection() == nullptr) {
         if (strcmp(name, "relhack") == 0) {
           addr = relhack_section.getAddr();
         } else if (strcmp(name, "elf_header") == 0) {
           // TODO: change this ungly hack to something better
-          ElfSection *ehdr = parent.getSection(1)->getPrevious()->getPrevious();
+          ElfSection* ehdr = parent.getSection(1)->getPrevious()->getPrevious();
           addr = ehdr->getAddr();
         } else if (strcmp(name, "original_init") == 0) {
           if (init_trampoline) {
             addr = init_trampoline->getAddr();
           } else {
             addr = init;
           }
         } else if (strcmp(name, "real_original_init") == 0) {
@@ -407,17 +407,17 @@ class ElfRelHackCode_Section : public El
           addr = 0;
         } else if (strcmp(name, "") == 0) {
           // This is for R_ARM_V4BX, until we find something better
           addr = -1;
         } else {
           throw std::runtime_error("Unsupported symbol in relocation");
         }
       } else {
-        ElfSection *section =
+        ElfSection* section =
             symtab->syms[ELF32_R_SYM(r->r_info)].value.getSection();
         assert((section->getType() == SHT_PROGBITS) &&
                (section->getFlags() & SHF_EXECINSTR));
         addr = symtab->syms[ELF32_R_SYM(r->r_info)].value.getValue();
       }
       // Do the relocation
 #define REL(machine, type) (EM_##machine | (R_##machine##_##type << 8))
       switch (elf->getMachine() | (ELF32_R_TYPE(r->r_info) << 8)) {
@@ -447,70 +447,70 @@ class ElfRelHackCode_Section : public El
           break;
         default:
           throw std::runtime_error("Unsupported relocation type");
       }
     }
   }
 
   Elf *elf, &parent;
-  ElfRelHack_Section &relhack_section;
-  std::vector<ElfSection *> code;
+  ElfRelHack_Section& relhack_section;
+  std::vector<ElfSection*> code;
   unsigned int init;
-  ElfSection *init_trampoline;
+  ElfSection* init_trampoline;
   unsigned int mprotect_cb;
   unsigned int sysconf_cb;
   int entry_point;
-  ElfSegment *relro;
+  ElfSegment* relro;
 };
 
-unsigned int get_addend(Elf_Rel *rel, Elf *elf) {
+unsigned int get_addend(Elf_Rel* rel, Elf* elf) {
   ElfLocation loc(rel->r_offset, elf);
   Elf_Addr addr(loc.getBuffer(), Elf_Addr::size(elf->getClass()),
                 elf->getClass(), elf->getData());
   return addr.value;
 }
 
-unsigned int get_addend(Elf_Rela *rel, Elf *elf) { return rel->r_addend; }
+unsigned int get_addend(Elf_Rela* rel, Elf* elf) { return rel->r_addend; }
 
-void set_relative_reloc(Elf_Rel *rel, Elf *elf, unsigned int value) {
+void set_relative_reloc(Elf_Rel* rel, Elf* elf, unsigned int value) {
   ElfLocation loc(rel->r_offset, elf);
   Elf_Addr addr;
   addr.value = value;
-  addr.serialize(const_cast<char *>(loc.getBuffer()),
+  addr.serialize(const_cast<char*>(loc.getBuffer()),
                  Elf_Addr::size(elf->getClass()), elf->getClass(),
                  elf->getData());
 }
 
-void set_relative_reloc(Elf_Rela *rel, Elf *elf, unsigned int value) {
+void set_relative_reloc(Elf_Rela* rel, Elf* elf, unsigned int value) {
   // ld puts the value of relocated relocations both in the addend and
   // at r_offset. For consistency, keep it that way.
-  set_relative_reloc((Elf_Rel *)rel, elf, value);
+  set_relative_reloc((Elf_Rel*)rel, elf, value);
   rel->r_addend = value;
 }
 
-void maybe_split_segment(Elf *elf, ElfSegment *segment) {
-  std::list<ElfSection *>::iterator it = segment->begin();
-  for (ElfSection *last = *(it++); it != segment->end(); last = *(it++)) {
+void maybe_split_segment(Elf* elf, ElfSegment* segment) {
+  std::list<ElfSection*>::iterator it = segment->begin();
+  for (ElfSection* last = *(it++); it != segment->end(); last = *(it++)) {
     // When two consecutive non-SHT_NOBITS sections are apart by more
     // than the alignment of the section, the second can be moved closer
     // to the first, but this requires the segment to be split.
     if (((*it)->getType() != SHT_NOBITS) && (last->getType() != SHT_NOBITS) &&
         ((*it)->getOffset() - last->getOffset() - last->getSize() >
          segment->getAlign())) {
       // Probably very wrong.
       Elf_Phdr phdr;
       phdr.p_type = PT_LOAD;
       phdr.p_vaddr = 0;
       phdr.p_paddr = phdr.p_vaddr + segment->getVPDiff();
       phdr.p_flags = segment->getFlags();
       phdr.p_align = segment->getAlign();
       phdr.p_filesz = (unsigned int)-1;
       phdr.p_memsz = (unsigned int)-1;
-      ElfSegment *newSegment = new ElfSegment(&phdr);
+      ElfSegment* newSegment = new ElfSegment(&phdr);
       elf->insertSegmentAfter(segment, newSegment);
       for (; it != segment->end(); ++it) {
         newSegment->addSection(*it);
       }
       for (it = newSegment->begin(); it != newSegment->end(); ++it) {
         segment->removeSection(*it);
       }
       break;
@@ -535,56 +535,56 @@ static const char DW_EH_PE_signed = 0x08
 static const char DW_EH_PE_pcrel = 0x10;
 
 // Return the data size part of the encoding value
 static char encoding_data_size(char encoding) { return encoding & 0x07; }
 
 // Advance `step` bytes in the buffer at `data` with size `size`, returning
 // the advanced buffer pointer and remaining size.
 // Returns true if step <= size.
-static bool advance_buffer(char **data, size_t *size, size_t step) {
+static bool advance_buffer(char** data, size_t* size, size_t step) {
   if (step > *size) return false;
 
   *data += step;
   *size -= step;
   return true;
 }
 
 // Advance in the given buffer, skipping the full length of the variable-length
 // encoded LEB128 type in CIE/FDE data.
-static bool skip_LEB128(char **data, size_t *size) {
+static bool skip_LEB128(char** data, size_t* size) {
   if (!*size) return false;
 
   while (*size && (*(*data)++ & (char)0x80)) {
     (*size)--;
   }
   return true;
 }
 
 // Advance in the given buffer, skipping the full length of a pointer encoded
 // with the given encoding.
-static bool skip_eh_frame_pointer(char **data, size_t *size, char encoding) {
+static bool skip_eh_frame_pointer(char** data, size_t* size, char encoding) {
   switch (encoding_data_size(encoding)) {
     case DW_EH_PE_data2:
       return advance_buffer(data, size, 2);
     case DW_EH_PE_data4:
       return advance_buffer(data, size, 4);
     case DW_EH_PE_data8:
       return advance_buffer(data, size, 8);
     case DW_EH_PE_LEB128:
       return skip_LEB128(data, size);
   }
   throw std::runtime_error("unreachable");
 }
 
 // Specialized implementations for adjust_eh_frame_pointer().
 template <typename T>
-static bool adjust_eh_frame_sized_pointer(char **data, size_t *size,
-                                          ElfSection *eh_frame,
-                                          unsigned int origAddr, Elf *elf) {
+static bool adjust_eh_frame_sized_pointer(char** data, size_t* size,
+                                          ElfSection* eh_frame,
+                                          unsigned int origAddr, Elf* elf) {
   if (*size < sizeof(T)) return false;
 
   serializable<FixedSizeData<T>> pointer(*data, *size, elf->getClass(),
                                          elf->getData());
   mozilla::CheckedInt<T> value = pointer.value;
   if (origAddr < eh_frame->getAddr()) {
     unsigned int diff = eh_frame->getAddr() - origAddr;
     value -= diff;
@@ -597,19 +597,19 @@ static bool adjust_eh_frame_sized_pointe
   pointer.value = value.value();
   pointer.serialize(*data, *size, elf->getClass(), elf->getData());
   return advance_buffer(data, size, sizeof(T));
 }
 
 // In the given eh_frame section, adjust the pointer with the given encoding,
 // pointed to by the given buffer (`data`, `size`), considering the eh_frame
 // section was originally at `origAddr`. Also advances in the buffer.
-static bool adjust_eh_frame_pointer(char **data, size_t *size, char encoding,
-                                    ElfSection *eh_frame, unsigned int origAddr,
-                                    Elf *elf) {
+static bool adjust_eh_frame_pointer(char** data, size_t* size, char encoding,
+                                    ElfSection* eh_frame, unsigned int origAddr,
+                                    Elf* elf) {
   if ((encoding & 0x70) != DW_EH_PE_pcrel)
     return skip_eh_frame_pointer(data, size, encoding);
 
   if (encoding & DW_EH_PE_signed) {
     switch (encoding_data_size(encoding)) {
       case DW_EH_PE_data2:
         return adjust_eh_frame_sized_pointer<int16_t>(data, size, eh_frame,
                                                       origAddr, elf);
@@ -635,36 +635,36 @@ static bool adjust_eh_frame_pointer(char
   }
 
   throw std::runtime_error("Unsupported eh_frame pointer encoding");
 }
 
 // The eh_frame section may contain "PC"-relative pointers. If we move the
 // section, those need to be adjusted. Other type of pointers are relative to
 // sections we don't touch.
-static void adjust_eh_frame(ElfSection *eh_frame, unsigned int origAddr,
-                            Elf *elf) {
+static void adjust_eh_frame(ElfSection* eh_frame, unsigned int origAddr,
+                            Elf* elf) {
   if (eh_frame->getAddr() == origAddr)  // nothing to do;
     return;
 
-  char *data = const_cast<char *>(eh_frame->getData());
+  char* data = const_cast<char*>(eh_frame->getData());
   size_t size = eh_frame->getSize();
   char LSDAencoding = DW_EH_PE_omit;
   char FDEencoding = DW_EH_PE_absptr;
   bool hasZ = false;
 
   // Decoding of eh_frame based on https://www.airs.com/blog/archives/460
   while (size) {
     if (size < sizeof(uint32_t)) goto malformed;
 
     serializable<FixedSizeData<uint32_t>> entryLength(
         data, size, elf->getClass(), elf->getData());
     if (!advance_buffer(&data, &size, sizeof(uint32_t))) goto malformed;
 
-    char *cursor = data;
+    char* cursor = data;
     size_t length = entryLength.value;
 
     if (length == 0) {
       continue;
     }
 
     if (size < sizeof(uint32_t)) goto malformed;
 
@@ -681,17 +681,17 @@ static void adjust_eh_frame(ElfSection *
       hasZ = false;
       // CIE version. Should only be 1 or 3.
       char version = *cursor++;
       length--;
       if (version != 1 && version != 3) {
         throw std::runtime_error("Unsupported eh_frame version");
       }
       // NUL terminated string.
-      const char *augmentationString = cursor;
+      const char* augmentationString = cursor;
       size_t l = strnlen(augmentationString, length - 1);
       if (l == length - 1) goto malformed;
       if (!advance_buffer(&cursor, &length, l + 1)) goto malformed;
       // Skip code alignment factor (LEB128)
       if (!skip_LEB128(&cursor, &length)) goto malformed;
       // Skip data alignment factor (LEB128)
       if (!skip_LEB128(&cursor, &length)) goto malformed;
       // Skip return address register (single byte in CIE version 1, LEB128
@@ -754,26 +754,26 @@ static void adjust_eh_frame(ElfSection *
   }
   return;
 
 malformed:
   throw std::runtime_error("malformed .eh_frame");
 }
 
 template <typename Rel_Type>
-int do_relocation_section(Elf *elf, unsigned int rel_type,
+int do_relocation_section(Elf* elf, unsigned int rel_type,
                           unsigned int rel_type2, bool force) {
-  ElfDynamic_Section *dyn = elf->getDynSection();
+  ElfDynamic_Section* dyn = elf->getDynSection();
   if (dyn == nullptr) {
     fprintf(stderr, "Couldn't find SHT_DYNAMIC section\n");
     return -1;
   }
 
-  ElfRel_Section<Rel_Type> *section =
-      (ElfRel_Section<Rel_Type> *)dyn->getSectionForType(Rel_Type::d_tag);
+  ElfRel_Section<Rel_Type>* section =
+      (ElfRel_Section<Rel_Type>*)dyn->getSectionForType(Rel_Type::d_tag);
   if (section == nullptr) {
     fprintf(stderr, "No relocations\n");
     return -1;
   }
   assert(section->getType() == Rel_Type::sh_type);
 
   Elf32_Shdr relhack32_section = {
       0,
@@ -809,31 +809,31 @@ int do_relocation_section(Elf *elf, unsi
   //   injected code call the original DT_INIT entry point.
   // - The binary has no DT_INIT entry, but has a DT_INIT_ARRAY. In this
   //   case, we interpose as well, by replacing the first entry in the
   //   array to point to the injected code, and have the injected code
   //   call the original first entry.
   // The binary may have .ctors instead of DT_INIT_ARRAY, for its init
   // functions, but this falls into the second case above, since .ctors
   // are actually run by DT_INIT code.
-  ElfValue *value = dyn->getValueForType(DT_INIT);
+  ElfValue* value = dyn->getValueForType(DT_INIT);
   unsigned int original_init = value ? value->getValue() : 0;
-  ElfSection *init_array = nullptr;
+  ElfSection* init_array = nullptr;
   if (!value || !value->getValue()) {
     value = dyn->getValueForType(DT_INIT_ARRAYSZ);
     if (value && value->getValue() >= entry_sz)
       init_array = dyn->getSectionForType(DT_INIT_ARRAY);
   }
 
   Elf_Shdr relhack_section(relhack32_section);
   Elf_Shdr relhackcode_section(relhackcode32_section);
-  ElfRelHack_Section *relhack = new ElfRelHack_Section(relhack_section);
+  ElfRelHack_Section* relhack = new ElfRelHack_Section(relhack_section);
 
-  ElfSymtab_Section *symtab = (ElfSymtab_Section *)section->getLink();
-  Elf_SymValue *sym = symtab->lookup("__cxa_pure_virtual");
+  ElfSymtab_Section* symtab = (ElfSymtab_Section*)section->getLink();
+  Elf_SymValue* sym = symtab->lookup("__cxa_pure_virtual");
 
   std::vector<Rel_Type> new_rels;
   Elf_RelHack relhack_entry;
   relhack_entry.r_offset = relhack_entry.r_info = 0;
   std::vector<Rel_Type> init_array_relocs;
   size_t init_array_insert = 0;
   for (typename std::vector<Rel_Type>::iterator i = section->rels.begin();
        i != section->rels.end(); ++i) {
@@ -851,27 +851,27 @@ int do_relocation_section(Elf *elf, unsi
       if (sym->defined) {
         // If we are statically linked to libstdc++, the
         // __cxa_pure_virtual symbol is defined in our lib, and we
         // have relative relocations (rel_type) for it.
         if (ELF32_R_TYPE(i->r_info) == rel_type) {
           Elf_Addr addr(loc.getBuffer(), entry_sz, elf->getClass(),
                         elf->getData());
           if (addr.value == sym->value.getValue()) {
-            memset((char *)loc.getBuffer(), 0, entry_sz);
+            memset((char*)loc.getBuffer(), 0, entry_sz);
             continue;
           }
         }
       } else {
         // If we are dynamically linked to libstdc++, the
         // __cxa_pure_virtual symbol is undefined in our lib, and we
         // have absolute relocations (rel_type2) for it.
         if ((ELF32_R_TYPE(i->r_info) == rel_type2) &&
             (sym == &symtab->syms[ELF32_R_SYM(i->r_info)])) {
-          memset((char *)loc.getBuffer(), 0, entry_sz);
+          memset((char*)loc.getBuffer(), 0, entry_sz);
           continue;
         }
       }
     }
     // Keep track of the relocations associated with the init_array section.
     if (init_array && i->r_offset >= init_array->getAddr() &&
         i->r_offset < init_array->getAddr() + init_array->getSize()) {
       init_array_relocs.push_back(*i);
@@ -887,17 +887,17 @@ int do_relocation_section(Elf *elf, unsi
       // relocation info doesn't contain it. Elfhack relies on the value pointed
       // by the relocation offset to also contain the addend. Which is true with
       // BFD ld and gold, but not lld, which leaves that nulled out. So if that
       // value is nulled out, we update it to the addend.
       Elf_Addr addr(loc.getBuffer(), entry_sz, elf->getClass(), elf->getData());
       unsigned int addend = get_addend(&*i, elf);
       if (addr.value == 0) {
         addr.value = addend;
-        addr.serialize(const_cast<char *>(loc.getBuffer()), entry_sz,
+        addr.serialize(const_cast<char*>(loc.getBuffer()), entry_sz,
                        elf->getClass(), elf->getData());
       } else if (addr.value != addend) {
         fprintf(stderr,
                 "Relocation addend inconsistent with content. Skipping\n");
         return -1;
       }
       if (i->r_offset ==
           relhack_entry.r_offset + relhack_entry.r_info * entry_sz) {
@@ -923,31 +923,31 @@ int do_relocation_section(Elf *elf, unsi
     // relocation, which ends up in all Android libraries, and in some cases it
     // ends up in the middle of the final .init_array section. If we have such a
     // reusable slot at the beginning of .init_array, we just use it. It we have
     // one in the middle of .init_array, we slide its content to move the "hole"
     // at the beginning and use it there (we need our injected code to run
     // before any other). Otherwise, replace the first entry and keep the
     // original pointer.
     std::sort(init_array_relocs.begin(), init_array_relocs.end(),
-              [](Rel_Type &a, Rel_Type &b) { return a.r_offset < b.r_offset; });
+              [](Rel_Type& a, Rel_Type& b) { return a.r_offset < b.r_offset; });
     size_t expected = init_array->getAddr();
     const size_t zero = 0;
     const size_t all = SIZE_MAX;
-    const char *data = init_array->getData();
+    const char* data = init_array->getData();
     size_t length = Elf_Addr::size(elf->getClass());
     size_t off = 0;
     for (; off < init_array_relocs.size(); off++) {
-      auto &r = init_array_relocs[off];
+      auto& r = init_array_relocs[off];
       if (r.r_offset >= expected + length &&
           (memcmp(data + off * length, &zero, length) == 0 ||
            memcmp(data + off * length, &all, length) == 0)) {
         // We found a hole, move the preceding entries.
         while (off) {
-          auto &p = init_array_relocs[--off];
+          auto& p = init_array_relocs[--off];
           if (ELF32_R_TYPE(p.r_info) == rel_type) {
             unsigned int addend = get_addend(&p, elf);
             p.r_offset += length;
             set_relative_reloc(&p, elf, addend);
           } else {
             fprintf(stderr,
                     "Unsupported relocation type in DT_INIT_ARRAY. Skipping\n");
             return -1;
@@ -965,22 +965,22 @@ int do_relocation_section(Elf *elf, unsi
       // Either way, code further below will take care of actually setting
       // the right r_info and r_added for the relocation.
       Rel_Type rel;
       rel.r_offset = init_array->getAddr();
       init_array_relocs.insert(init_array_relocs.begin(), rel);
     } else {
       // Use relocated value of DT_INIT_ARRAY's first entry for the
       // function to be called by the injected code.
-      auto &rel = init_array_relocs[0];
+      auto& rel = init_array_relocs[0];
       unsigned int addend = get_addend(&rel, elf);
       if (ELF32_R_TYPE(rel.r_info) == rel_type) {
         original_init = addend;
       } else if (ELF32_R_TYPE(rel.r_info) == rel_type2) {
-        ElfSymtab_Section *symtab = (ElfSymtab_Section *)section->getLink();
+        ElfSymtab_Section* symtab = (ElfSymtab_Section*)section->getLink();
         original_init =
             symtab->syms[ELF32_R_SYM(rel.r_info)].value.getValue() + addend;
       } else {
         fprintf(stderr,
                 "Unsupported relocation type for DT_INIT_ARRAY's first entry. "
                 "Skipping\n");
         return -1;
       }
@@ -1000,25 +1000,25 @@ int do_relocation_section(Elf *elf, unsi
   // add the symbol. Then the injected code needs to be able to call the
   // corresponding function, which means it needs access to a pointer to it. We
   // get such a pointer by making the linker apply a relocation for the symbol
   // at an address our code can read. The problem here is that there is not much
   // relocated space where we can put such a pointer, so we abuse the bss
   // section temporarily (it will be restored to a null value before any code
   // can actually use it)
   if (elf->getSegmentByType(PT_GNU_RELRO)) {
-    ElfSection *gnu_versym = dyn->getSectionForType(DT_VERSYM);
-    auto lookup = [&symtab, &gnu_versym](const char *symbol) {
-      Elf_SymValue *sym_value = symtab->lookup(symbol, STT(FUNC));
+    ElfSection* gnu_versym = dyn->getSectionForType(DT_VERSYM);
+    auto lookup = [&symtab, &gnu_versym](const char* symbol) {
+      Elf_SymValue* sym_value = symtab->lookup(symbol, STT(FUNC));
       if (!sym_value) {
         symtab->syms.emplace_back();
         sym_value = &symtab->syms.back();
         symtab->grow(symtab->syms.size() * symtab->getEntSize());
         sym_value->name =
-            ((ElfStrtab_Section *)symtab->getLink())->getStr(symbol);
+            ((ElfStrtab_Section*)symtab->getLink())->getStr(symbol);
         sym_value->info = ELF32_ST_INFO(STB_GLOBAL, STT_FUNC);
         sym_value->other = STV_DEFAULT;
         new (&sym_value->value) ElfLocation(nullptr, 0, ElfLocation::ABSOLUTE);
         sym_value->size = 0;
         sym_value->defined = false;
 
         // The DT_VERSYM data (in the .gnu.version section) has the same number
         // of entries as the symbols table. Since we added one entry there, we
@@ -1026,36 +1026,36 @@ int do_relocation_section(Elf *elf, unsi
         // for that symbol, which is the simplest thing to do.
         if (gnu_versym) {
           gnu_versym->grow(gnu_versym->getSize() + gnu_versym->getEntSize());
         }
       }
       return sym_value;
     };
 
-    Elf_SymValue *mprotect = lookup("mprotect");
-    Elf_SymValue *sysconf = lookup("sysconf");
+    Elf_SymValue* mprotect = lookup("mprotect");
+    Elf_SymValue* sysconf = lookup("sysconf");
 
     // Add relocations for the mprotect and sysconf symbols.
     auto add_relocation_to = [&new_rels, &symtab, rel_type2](
-                                 Elf_SymValue *symbol, unsigned int location) {
+                                 Elf_SymValue* symbol, unsigned int location) {
       new_rels.emplace_back();
-      Rel_Type &rel = new_rels.back();
+      Rel_Type& rel = new_rels.back();
       memset(&rel, 0, sizeof(rel));
       rel.r_info = ELF32_R_INFO(
           std::distance(symtab->syms.begin(),
                         std::vector<Elf_SymValue>::iterator(symbol)),
           rel_type2);
       rel.r_offset = location;
       return location;
     };
 
     // Find the beginning of the bss section, and use an aligned location in
     // there for the relocation.
-    for (ElfSection *s = elf->getSection(1); s != nullptr; s = s->getNext()) {
+    for (ElfSection* s = elf->getSection(1); s != nullptr; s = s->getNext()) {
       if (s->getType() != SHT_NOBITS ||
           (s->getFlags() & (SHF_TLS | SHF_WRITE)) != SHF_WRITE) {
         continue;
       }
       size_t ptr_size = Elf_Addr::size(elf->getClass());
       size_t usable_start = (s->getAddr() + ptr_size - 1) & ~(ptr_size - 1);
       size_t usable_end = (s->getAddr() + s->getSize()) & ~(ptr_size - 1);
       if (usable_end - usable_start >= 2 * ptr_size) {
@@ -1071,23 +1071,23 @@ int do_relocation_section(Elf *elf, unsi
     }
   }
 
   size_t old_size = section->getSize();
 
   section->rels.assign(new_rels.begin(), new_rels.end());
   section->shrink(new_rels.size() * section->getEntSize());
 
-  ElfRelHackCode_Section *relhackcode =
+  ElfRelHackCode_Section* relhackcode =
       new ElfRelHackCode_Section(relhackcode_section, *elf, *relhack,
                                  original_init, mprotect_cb, sysconf_cb);
   // Find the first executable section, and insert the relhack code before
   // that. The relhack data is inserted between .rel.dyn and .rel.plt.
-  ElfSection *first_executable = nullptr;
-  for (ElfSection *s = elf->getSection(1); s != nullptr; s = s->getNext()) {
+  ElfSection* first_executable = nullptr;
+  for (ElfSection* s = elf->getSection(1); s != nullptr; s = s->getNext()) {
     if (s->getFlags() & SHF_EXECINSTR) {
       first_executable = s;
       break;
     }
   }
 
   if (!first_executable) {
     fprintf(stderr, "Couldn't find executable section. Skipping\n");
@@ -1110,23 +1110,23 @@ int do_relocation_section(Elf *elf, unsi
     return -1;
   }
 
   // .eh_frame/.eh_frame_hdr may be between the relocation sections and the
   // executable sections. When that happens, we may end up creating a separate
   // PT_LOAD for just both of them because they are not considered relocatable.
   // But they are, in fact, kind of relocatable, albeit with some manual work.
   // Which we'll do here.
-  ElfSegment *eh_frame_segment = elf->getSegmentByType(PT_GNU_EH_FRAME);
-  ElfSection *eh_frame_hdr =
+  ElfSegment* eh_frame_segment = elf->getSegmentByType(PT_GNU_EH_FRAME);
+  ElfSection* eh_frame_hdr =
       eh_frame_segment ? eh_frame_segment->getFirstSection() : nullptr;
   // The .eh_frame section usually follows the eh_frame_hdr section.
-  ElfSection *eh_frame = eh_frame_hdr ? eh_frame_hdr->getNext() : nullptr;
-  ElfSection *first = eh_frame_hdr;
-  ElfSection *second = eh_frame;
+  ElfSection* eh_frame = eh_frame_hdr ? eh_frame_hdr->getNext() : nullptr;
+  ElfSection* first = eh_frame_hdr;
+  ElfSection* second = eh_frame;
   if (eh_frame && strcmp(eh_frame->getName(), ".eh_frame")) {
     // But sometimes it appears *before* the eh_frame_hdr section.
     eh_frame = eh_frame_hdr->getPrevious();
     first = eh_frame;
     second = eh_frame_hdr;
   }
   if (eh_frame_hdr && (!eh_frame || strcmp(eh_frame->getName(), ".eh_frame"))) {
     throw std::runtime_error(
@@ -1135,17 +1135,17 @@ int do_relocation_section(Elf *elf, unsi
   if (eh_frame && first->getAddr() > relhack->getAddr() &&
       second->getAddr() < first_executable->getAddr()) {
     // The distance between both sections needs to be preserved because
     // eh_frame_hdr contains relative offsets to eh_frame. Well, they could be
     // relocated too, but it's not worth the effort for the few number of bytes
     // this would save.
     unsigned int distance = second->getAddr() - first->getAddr();
     unsigned int origAddr = eh_frame->getAddr();
-    ElfSection *previous = first->getPrevious();
+    ElfSection* previous = first->getPrevious();
     first->getShdr().sh_addr = (previous->getAddr() + previous->getSize() +
                                 first->getAddrAlign() - 1) &
                                ~(first->getAddrAlign() - 1);
     second->getShdr().sh_addr =
         (first->getAddr() + std::min(first->getSize(), distance) +
          second->getAddrAlign() - 1) &
         ~(second->getAddrAlign() - 1);
     // Re-adjust to keep the original distance.
@@ -1155,61 +1155,61 @@ int do_relocation_section(Elf *elf, unsi
     // it will already be at the right distance.
     first->getShdr().sh_addr = second->getAddr() - distance;
     assert(distance == second->getAddr() - first->getAddr());
     first->markDirty();
     adjust_eh_frame(eh_frame, origAddr, elf);
   }
 
   // Adjust PT_LOAD segments
-  for (ElfSegment *segment = elf->getSegmentByType(PT_LOAD); segment;
+  for (ElfSegment* segment = elf->getSegmentByType(PT_LOAD); segment;
        segment = elf->getSegmentByType(PT_LOAD, segment)) {
     maybe_split_segment(elf, segment);
   }
 
   // Ensure Elf sections will be at their final location.
   elf->normalize();
-  ElfLocation *init =
+  ElfLocation* init =
       new ElfLocation(relhackcode, relhackcode->getEntryPoint());
   if (init_array) {
     // Adjust the first DT_INIT_ARRAY entry to point at the injected code
     // by transforming its relocation into a relative one pointing to the
     // address of the injected code.
-    Rel_Type *rel = &section->rels[init_array_insert];
+    Rel_Type* rel = &section->rels[init_array_insert];
     rel->r_info = ELF32_R_INFO(0, rel_type);  // Set as a relative relocation
     set_relative_reloc(rel, elf, init->getValue());
   } else if (!dyn->setValueForType(DT_INIT, init)) {
     fprintf(stderr, "Can't grow .dynamic section to set DT_INIT. Skipping\n");
     return -1;
   }
   // TODO: adjust the value according to the remaining number of relative
   // relocations
   if (dyn->getValueForType(Rel_Type::d_tag_count))
     dyn->setValueForType(Rel_Type::d_tag_count, new ElfPlainValue(0));
 
   return 0;
 }
 
-static inline int backup_file(const char *name) {
+static inline int backup_file(const char* name) {
   std::string fname(name);
   fname += ".bak";
   return rename(name, fname.c_str());
 }
 
-void do_file(const char *name, bool backup = false, bool force = false) {
+void do_file(const char* name, bool backup = false, bool force = false) {
   std::ifstream file(name, std::ios::in | std::ios::binary);
   Elf elf(file);
   unsigned int size = elf.getSize();
   fprintf(stderr, "%s: ", name);
   if (elf.getType() != ET_DYN) {
     fprintf(stderr, "Not a shared object. Skipping\n");
     return;
   }
 
-  for (ElfSection *section = elf.getSection(1); section != nullptr;
+  for (ElfSection* section = elf.getSection(1); section != nullptr;
        section = section->getNext()) {
     if (section->getName() &&
         (strncmp(section->getName(), ".elfhack.", 9) == 0)) {
       fprintf(stderr, "Already elfhacked. Skipping\n");
       return;
     }
   }
 
@@ -1237,80 +1237,80 @@ void do_file(const char *name, bool back
       std::ofstream ofile(name,
                           std::ios::out | std::ios::binary | std::ios::trunc);
       elf.write(ofile);
       fprintf(stderr, "Reduced by %d bytes\n", size - elf.getSize());
     }
   }
 }
 
-void undo_file(const char *name, bool backup = false) {
+void undo_file(const char* name, bool backup = false) {
   std::ifstream file(name, std::ios::in | std::ios::binary);
   Elf elf(file);
   unsigned int size = elf.getSize();
   fprintf(stderr, "%s: ", name);
   if (elf.getType() != ET_DYN) {
     fprintf(stderr, "Not a shared object. Skipping\n");
     return;
   }
 
   ElfSection *data = nullptr, *text = nullptr;
-  for (ElfSection *section = elf.getSection(1); section != nullptr;
+  for (ElfSection* section = elf.getSection(1); section != nullptr;
        section = section->getNext()) {
     if (section->getName() && (strcmp(section->getName(), elfhack_data) == 0))
       data = section;
     if (section->getName() && (strcmp(section->getName(), elfhack_text) == 0))
       text = section;
   }
 
   if (!data || !text) {
     fprintf(stderr, "Not elfhacked. Skipping\n");
     return;
   }
 
   // When both elfhack sections are in the same segment, try to merge
   // the segment that contains them both and the following segment.
   // When the elfhack sections are in separate segments, try to merge
   // those segments.
-  ElfSegment *first = data->getSegmentByType(PT_LOAD);
-  ElfSegment *second = text->getSegmentByType(PT_LOAD);
+  ElfSegment* first = data->getSegmentByType(PT_LOAD);
+  ElfSegment* second = text->getSegmentByType(PT_LOAD);
   if (first == second) {
     second = elf.getSegmentByType(PT_LOAD, first);
   }
 
   // Only merge the segments when their flags match.
   if (second->getFlags() != first->getFlags()) {
     fprintf(stderr, "Couldn't merge PT_LOAD segments. Skipping\n");
     return;
   }
   // Move sections from the second PT_LOAD to the first, and remove the
   // second PT_LOAD segment.
-  for (std::list<ElfSection *>::iterator section = second->begin();
+  for (std::list<ElfSection*>::iterator section = second->begin();
        section != second->end(); ++section)
     first->addSection(*section);
 
   elf.removeSegment(second);
   elf.normalize();
 
   if (backup && backup_file(name) != 0) {
     fprintf(stderr, "Couln't create backup file\n");
   } else {
     std::ofstream ofile(name,
                         std::ios::out | std::ios::binary | std::ios::trunc);
     elf.write(ofile);
     fprintf(stderr, "Grown by %d bytes\n", elf.getSize() - size);
   }
 }
 
-int main(int argc, char *argv[]) {
+int main(int argc, char* argv[]) {
   int arg;
   bool backup = false;
   bool force = false;
   bool revert = false;
-  char *lastSlash = rindex(argv[0], '/');
+  char* lastSlash = rindex(argv[0], '/');
   if (lastSlash != nullptr) rundir = strndup(argv[0], lastSlash - argv[0]);
   for (arg = 1; arg < argc; arg++) {
     if (strcmp(argv[arg], "-f") == 0)
       force = true;
     else if (strcmp(argv[arg], "-b") == 0)
       backup = true;
     else if (strcmp(argv[arg], "-r") == 0)
       revert = true;
--- a/build/unix/elfhack/elfxx.h
+++ b/build/unix/elfhack/elfxx.h
@@ -54,209 +54,209 @@ class FixedSizeData {
  public:
   struct Wrapper {
     X value;
   };
   typedef Wrapper Type32;
   typedef Wrapper Type64;
 
   template <class endian, typename R, typename T>
-  static void swap(T &t, R &r) {
+  static void swap(T& t, R& r) {
     r.value = endian::swap(t.value);
   }
 };
 
 class Elf_Ehdr_Traits {
  public:
   typedef Elf32_Ehdr Type32;
   typedef Elf64_Ehdr Type64;
 
   template <class endian, typename R, typename T>
-  static void swap(T &t, R &r);
+  static void swap(T& t, R& r);
 };
 
 class Elf_Phdr_Traits {
  public:
   typedef Elf32_Phdr Type32;
   typedef Elf64_Phdr Type64;
 
   template <class endian, typename R, typename T>
-  static void swap(T &t, R &r);
+  static void swap(T& t, R& r);
 };
 
 class Elf_Shdr_Traits {
  public:
   typedef Elf32_Shdr Type32;
   typedef Elf64_Shdr Type64;
 
   template <class endian, typename R, typename T>
-  static void swap(T &t, R &r);
+  static void swap(T& t, R& r);
 };
 
 class Elf_Dyn_Traits {
  public:
   typedef Elf32_Dyn Type32;
   typedef Elf64_Dyn Type64;
 
   template <class endian, typename R, typename T>
-  static void swap(T &t, R &r);
+  static void swap(T& t, R& r);
 };
 
 class Elf_Sym_Traits {
  public:
   typedef Elf32_Sym Type32;
   typedef Elf64_Sym Type64;
 
   template <class endian, typename R, typename T>
-  static void swap(T &t, R &r);
+  static void swap(T& t, R& r);
 };
 
 class Elf_Rel_Traits {
  public:
   typedef Elf32_Rel Type32;
   typedef Elf64_Rel Type64;
 
   template <class endian, typename R, typename T>
-  static void swap(T &t, R &r);
+  static void swap(T& t, R& r);
 };
 
 class Elf_Rela_Traits {
  public:
   typedef Elf32_Rela Type32;
   typedef Elf64_Rela Type64;
 
   template <class endian, typename R, typename T>
-  static void swap(T &t, R &r);
+  static void swap(T& t, R& r);
 };
 
 class ElfValue {
  public:
   virtual unsigned int getValue() { return 0; }
-  virtual ElfSection *getSection() { return nullptr; }
+  virtual ElfSection* getSection() { return nullptr; }
 };
 
 class ElfPlainValue : public ElfValue {
   unsigned int value;
 
  public:
   ElfPlainValue(unsigned int val) : value(val){};
   unsigned int getValue() { return value; }
 };
 
 class ElfLocation : public ElfValue {
-  ElfSection *section;
+  ElfSection* section;
   unsigned int offset;
 
  public:
   enum position { ABSOLUTE, RELATIVE };
   ElfLocation() : section(nullptr), offset(0){};
-  ElfLocation(ElfSection *section, unsigned int off,
+  ElfLocation(ElfSection* section, unsigned int off,
               enum position pos = RELATIVE);
-  ElfLocation(unsigned int location, Elf *elf);
+  ElfLocation(unsigned int location, Elf* elf);
   unsigned int getValue();
-  ElfSection *getSection() { return section; }
-  const char *getBuffer();
+  ElfSection* getSection() { return section; }
+  const char* getBuffer();
 };
 
 class ElfSize : public ElfValue {
-  ElfSection *section;
+  ElfSection* section;
 
  public:
-  ElfSize(ElfSection *s) : section(s){};
+  ElfSize(ElfSection* s) : section(s){};
   unsigned int getValue();
-  ElfSection *getSection() { return section; }
+  ElfSection* getSection() { return section; }
 };
 
 class ElfEntSize : public ElfValue {
-  ElfSection *section;
+  ElfSection* section;
 
  public:
-  ElfEntSize(ElfSection *s) : section(s){};
+  ElfEntSize(ElfSection* s) : section(s){};
   unsigned int getValue();
-  ElfSection *getSection() { return section; }
+  ElfSection* getSection() { return section; }
 };
 
 template <typename T>
 class serializable : public T::Type32 {
  public:
   serializable(){};
-  serializable(const typename T::Type32 &p) : T::Type32(p){};
+  serializable(const typename T::Type32& p) : T::Type32(p){};
 
  private:
   template <typename R>
-  void init(const char *buf, size_t len, char ei_data) {
+  void init(const char* buf, size_t len, char ei_data) {
     R e;
     assert(len >= sizeof(e));
     memcpy(&e, buf, sizeof(e));
     if (ei_data == ELFDATA2LSB) {
       T::template swap<little_endian>(e, *this);
       return;
     } else if (ei_data == ELFDATA2MSB) {
       T::template swap<big_endian>(e, *this);
       return;
     }
     throw std::runtime_error("Unsupported ELF data encoding");
   }
 
   template <typename R>
-  void serialize(const char *buf, size_t len, char ei_data) {
+  void serialize(const char* buf, size_t len, char ei_data) {
     assert(len >= sizeof(R));
     if (ei_data == ELFDATA2LSB) {
-      T::template swap<little_endian>(*this, *(R *)buf);
+      T::template swap<little_endian>(*this, *(R*)buf);
       return;
     } else if (ei_data == ELFDATA2MSB) {
-      T::template swap<big_endian>(*this, *(R *)buf);
+      T::template swap<big_endian>(*this, *(R*)buf);
       return;
     }
     throw std::runtime_error("Unsupported ELF data encoding");
   }
 
  public:
-  serializable(const char *buf, size_t len, char ei_class, char ei_data) {
+  serializable(const char* buf, size_t len, char ei_class, char ei_data) {
     if (ei_class == ELFCLASS32) {
       init<typename T::Type32>(buf, len, ei_data);
       return;
     } else if (ei_class == ELFCLASS64) {
       init<typename T::Type64>(buf, len, ei_data);
       return;
     }
     throw std::runtime_error("Unsupported ELF class");
   }
 
-  serializable(std::ifstream &file, char ei_class, char ei_data) {
+  serializable(std::ifstream& file, char ei_class, char ei_data) {
     if (ei_class == ELFCLASS32) {
       typename T::Type32 e;
-      file.read((char *)&e, sizeof(e));
-      init<typename T::Type32>((char *)&e, sizeof(e), ei_data);
+      file.read((char*)&e, sizeof(e));
+      init<typename T::Type32>((char*)&e, sizeof(e), ei_data);
       return;
     } else if (ei_class == ELFCLASS64) {
       typename T::Type64 e;
-      file.read((char *)&e, sizeof(e));
-      init<typename T::Type64>((char *)&e, sizeof(e), ei_data);
+      file.read((char*)&e, sizeof(e));
+      init<typename T::Type64>((char*)&e, sizeof(e), ei_data);
       return;
     }
     throw std::runtime_error("Unsupported ELF class or data encoding");
   }
 
-  void serialize(std::ofstream &file, char ei_class, char ei_data) {
+  void serialize(std::ofstream& file, char ei_class, char ei_data) {
     if (ei_class == ELFCLASS32) {
       typename T::Type32 e;
-      serialize<typename T::Type32>((char *)&e, sizeof(e), ei_data);
-      file.write((char *)&e, sizeof(e));
+      serialize<typename T::Type32>((char*)&e, sizeof(e), ei_data);
+      file.write((char*)&e, sizeof(e));
       return;
     } else if (ei_class == ELFCLASS64) {
       typename T::Type64 e;
-      serialize<typename T::Type64>((char *)&e, sizeof(e), ei_data);
-      file.write((char *)&e, sizeof(e));
+      serialize<typename T::Type64>((char*)&e, sizeof(e), ei_data);
+      file.write((char*)&e, sizeof(e));
       return;
     }
     throw std::runtime_error("Unsupported ELF class or data encoding");
   }
 
-  void serialize(char *buf, size_t len, char ei_class, char ei_data) {
+  void serialize(char* buf, size_t len, char ei_class, char ei_data) {
     if (ei_class == ELFCLASS32) {
       serialize<typename T::Type32>(buf, len, ei_data);
       return;
     } else if (ei_class == ELFCLASS64) {
       serialize<typename T::Type64>(buf, len, ei_data);
       return;
     }
     throw std::runtime_error("Unsupported ELF class");
@@ -270,127 +270,127 @@ class serializable : public T::Type32 {
     return 0;
   }
 };
 
 typedef serializable<Elf_Shdr_Traits> Elf_Shdr;
 
 class Elf {
  public:
-  Elf(std::ifstream &file);
+  Elf(std::ifstream& file);
   ~Elf();
 
   /* index == -1 is treated as index == ehdr.e_shstrndx */
-  ElfSection *getSection(int index);
+  ElfSection* getSection(int index);
 
-  ElfSection *getSectionAt(unsigned int offset);
+  ElfSection* getSectionAt(unsigned int offset);
 
-  ElfSegment *getSegmentByType(unsigned int type, ElfSegment *last = nullptr);
+  ElfSegment* getSegmentByType(unsigned int type, ElfSegment* last = nullptr);
 
-  ElfDynamic_Section *getDynSection();
+  ElfDynamic_Section* getDynSection();
 
   void normalize();
-  void write(std::ofstream &file);
+  void write(std::ofstream& file);
 
   char getClass();
   char getData();
   char getType();
   char getMachine();
   unsigned int getSize();
 
-  void insertSegmentAfter(ElfSegment *previous, ElfSegment *segment) {
-    std::vector<ElfSegment *>::iterator prev =
+  void insertSegmentAfter(ElfSegment* previous, ElfSegment* segment) {
+    std::vector<ElfSegment*>::iterator prev =
         std::find(segments.begin(), segments.end(), previous);
     segments.insert(prev + 1, segment);
   }
 
-  void removeSegment(ElfSegment *segment);
+  void removeSegment(ElfSegment* segment);
 
  private:
-  Elf_Ehdr *ehdr;
+  Elf_Ehdr* ehdr;
   ElfLocation eh_entry;
-  ElfStrtab_Section *eh_shstrndx;
-  ElfSection **sections;
-  std::vector<ElfSegment *> segments;
+  ElfStrtab_Section* eh_shstrndx;
+  ElfSection** sections;
+  std::vector<ElfSegment*> segments;
   ElfSection *shdr_section, *phdr_section;
   /* Values used only during initialization */
-  Elf_Shdr **tmp_shdr;
-  std::ifstream *tmp_file;
+  Elf_Shdr** tmp_shdr;
+  std::ifstream* tmp_file;
 };
 
 class ElfSection {
  public:
   typedef union {
-    ElfSection *section;
+    ElfSection* section;
     int index;
   } SectionInfo;
 
-  ElfSection(Elf_Shdr &s, std::ifstream *file, Elf *parent);
+  ElfSection(Elf_Shdr& s, std::ifstream* file, Elf* parent);
 
   virtual ~ElfSection() { free(data); }
 
-  const char *getName() { return name; }
+  const char* getName() { return name; }
   unsigned int getType() { return shdr.sh_type; }
   unsigned int getFlags() { return shdr.sh_flags; }
   unsigned int getAddr();
   unsigned int getSize() { return shdr.sh_size; }
   unsigned int getAddrAlign() { return shdr.sh_addralign; }
   unsigned int getEntSize() { return shdr.sh_entsize; }
-  const char *getData() { return data; }
-  ElfSection *getLink() { return link; }
+  const char* getData() { return data; }
+  ElfSection* getLink() { return link; }
   SectionInfo getInfo() { return info; }
 
   void shrink(unsigned int newsize) {
     if (newsize < shdr.sh_size) {
       shdr.sh_size = newsize;
       markDirty();
     }
   }
 
   void grow(unsigned int newsize) {
     if (newsize > shdr.sh_size) {
-      data = static_cast<char *>(realloc(data, newsize));
+      data = static_cast<char*>(realloc(data, newsize));
       memset(data + shdr.sh_size, 0, newsize - shdr.sh_size);
       shdr.sh_size = newsize;
       markDirty();
     }
   }
 
   unsigned int getOffset();
   int getIndex();
-  Elf_Shdr &getShdr();
+  Elf_Shdr& getShdr();
 
-  ElfSection *getNext() { return next; }
-  ElfSection *getPrevious() { return previous; }
+  ElfSection* getNext() { return next; }
+  ElfSection* getPrevious() { return previous; }
 
   virtual bool isRelocatable() {
     return ((getType() == SHT_SYMTAB) || (getType() == SHT_STRTAB) ||
             (getType() == SHT_RELA) || (getType() == SHT_HASH) ||
             (getType() == SHT_NOTE) || (getType() == SHT_REL) ||
             (getType() == SHT_DYNSYM) || (getType() == SHT_GNU_HASH) ||
             (getType() == SHT_GNU_verdef) || (getType() == SHT_GNU_verneed) ||
             (getType() == SHT_GNU_versym) || getSegmentByType(PT_INTERP)) &&
            (getFlags() & SHF_ALLOC);
   }
 
-  void insertAfter(ElfSection *section, bool dirty = true) {
+  void insertAfter(ElfSection* section, bool dirty = true) {
     if (previous != nullptr) previous->next = next;
     if (next != nullptr) next->previous = previous;
     previous = section;
     if (section != nullptr) {
       next = section->next;
       section->next = this;
     } else
       next = nullptr;
     if (next != nullptr) next->previous = this;
     if (dirty) markDirty();
     insertInSegments(section->segments);
   }
 
-  virtual void insertBefore(ElfSection *section, bool dirty = true) {
+  virtual void insertBefore(ElfSection* section, bool dirty = true) {
     if (previous != nullptr) previous->next = next;
     if (next != nullptr) next->previous = previous;
     next = section;
     if (section != nullptr) {
       previous = section->previous;
       section->previous = this;
     } else
       previous = nullptr;
@@ -402,101 +402,101 @@ class ElfSection {
   void markDirty() {
     if (link != nullptr) shdr.sh_link = -1;
     if (info.index) shdr.sh_info = -1;
     shdr.sh_offset = -1;
     if (isRelocatable()) shdr.sh_addr = -1;
     if (next) next->markDirty();
   }
 
-  virtual void serialize(std::ofstream &file, char ei_class, char ei_data) {
+  virtual void serialize(std::ofstream& file, char ei_class, char ei_data) {
     if (getType() == SHT_NOBITS) return;
     file.seekp(getOffset());
     file.write(data, getSize());
   }
 
-  ElfSegment *getSegmentByType(unsigned int type);
+  ElfSegment* getSegmentByType(unsigned int type);
 
  private:
   friend class ElfSegment;
 
-  void addToSegment(ElfSegment *segment) { segments.push_back(segment); }
+  void addToSegment(ElfSegment* segment) { segments.push_back(segment); }
 
-  void removeFromSegment(ElfSegment *segment) {
-    std::vector<ElfSegment *>::iterator i =
+  void removeFromSegment(ElfSegment* segment) {
+    std::vector<ElfSegment*>::iterator i =
         std::find(segments.begin(), segments.end(), segment);
     segments.erase(i, i + 1);
   }
 
-  void insertInSegments(std::vector<ElfSegment *> &segs);
+  void insertInSegments(std::vector<ElfSegment*>& segs);
 
  protected:
   Elf_Shdr shdr;
-  char *data;
-  const char *name;
+  char* data;
+  const char* name;
 
  private:
-  ElfSection *link;
+  ElfSection* link;
   SectionInfo info;
   ElfSection *next, *previous;
   int index;
-  std::vector<ElfSegment *> segments;
+  std::vector<ElfSegment*> segments;
 };
 
 class ElfSegment {
  public:
-  ElfSegment(Elf_Phdr *phdr);
+  ElfSegment(Elf_Phdr* phdr);
 
   unsigned int getType() { return type; }
   unsigned int getFlags() { return flags; }
   unsigned int getAlign() { return align; }
 
-  ElfSection *getFirstSection() {
+  ElfSection* getFirstSection() {
     return sections.empty() ? nullptr : sections.front();
   }
   int getVPDiff() { return v_p_diff; }
   unsigned int getFileSize();
   unsigned int getMemSize();
   unsigned int getOffset();
   unsigned int getAddr();
 
-  void addSection(ElfSection *section);
-  void removeSection(ElfSection *section);
+  void addSection(ElfSection* section);
+  void removeSection(ElfSection* section);
 
-  std::list<ElfSection *>::iterator begin() { return sections.begin(); }
-  std::list<ElfSection *>::iterator end() { return sections.end(); }
+  std::list<ElfSection*>::iterator begin() { return sections.begin(); }
+  std::list<ElfSection*>::iterator end() { return sections.end(); }
 
   void clear();
 
  private:
   unsigned int type;
   int v_p_diff;  // Difference between physical and virtual address
   unsigned int flags;
   unsigned int align;
-  std::list<ElfSection *> sections;
+  std::list<ElfSection*> sections;
   // The following are only really used for PT_GNU_RELRO until something
   // better is found.
   unsigned int vaddr;
   unsigned int filesz, memsz;
 };
 
 class Elf_Ehdr : public serializable<Elf_Ehdr_Traits>, public ElfSection {
  public:
-  Elf_Ehdr(std::ifstream &file, char ei_class, char ei_data);
-  void serialize(std::ofstream &file, char ei_class, char ei_data) {
+  Elf_Ehdr(std::ifstream& file, char ei_class, char ei_data);
+  void serialize(std::ofstream& file, char ei_class, char ei_data) {
     serializable<Elf_Ehdr_Traits>::serialize(file, ei_class, ei_data);
   }
 };
 
 class Elf_Phdr : public serializable<Elf_Phdr_Traits> {
  public:
   Elf_Phdr(){};
-  Elf_Phdr(std::ifstream &file, char ei_class, char ei_data)
+  Elf_Phdr(std::ifstream& file, char ei_class, char ei_data)
       : serializable<Elf_Phdr_Traits>(file, ei_class, ei_data){};
-  bool contains(ElfSection *section) {
+  bool contains(ElfSection* section) {
     unsigned int size = section->getSize();
     unsigned int addr = section->getAddr();
     // This may be biased, but should work in most cases
     if ((section->getFlags() & SHF_ALLOC) == 0) return false;
     // Special case for PT_DYNAMIC. Eventually, this should
     // be better handled than special cases
     if ((p_type == PT_DYNAMIC) && (section->getType() != SHT_DYNAMIC))
       return false;
@@ -505,187 +505,187 @@ class Elf_Phdr : public serializable<Elf
     return (addr >= p_vaddr) && (addr + size <= p_vaddr + p_memsz);
   }
 };
 
 typedef serializable<Elf_Dyn_Traits> Elf_Dyn;
 
 struct Elf_DynValue {
   unsigned int tag;
-  ElfValue *value;
+  ElfValue* value;
 };
 
 class ElfDynamic_Section : public ElfSection {
  public:
-  ElfDynamic_Section(Elf_Shdr &s, std::ifstream *file, Elf *parent);
+  ElfDynamic_Section(Elf_Shdr& s, std::ifstream* file, Elf* parent);
   ~ElfDynamic_Section();
 
-  void serialize(std::ofstream &file, char ei_class, char ei_data);
+  void serialize(std::ofstream& file, char ei_class, char ei_data);
 
-  ElfValue *getValueForType(unsigned int tag);
-  ElfSection *getSectionForType(unsigned int tag);
-  bool setValueForType(unsigned int tag, ElfValue *val);
+  ElfValue* getValueForType(unsigned int tag);
+  ElfSection* getSectionForType(unsigned int tag);
+  bool setValueForType(unsigned int tag, ElfValue* val);
 
  private:
   std::vector<Elf_DynValue> dyns;
 };
 
 typedef serializable<Elf_Sym_Traits> Elf_Sym;
 
 struct Elf_SymValue {
-  const char *name;
+  const char* name;
   unsigned char info;
   unsigned char other;
   ElfLocation value;
   unsigned int size;
   bool defined;
 };
 
 #define STT(type) (1 << STT_##type)
 
 class ElfSymtab_Section : public ElfSection {
  public:
-  ElfSymtab_Section(Elf_Shdr &s, std::ifstream *file, Elf *parent);
+  ElfSymtab_Section(Elf_Shdr& s, std::ifstream* file, Elf* parent);
 
-  void serialize(std::ofstream &file, char ei_class, char ei_data);
+  void serialize(std::ofstream& file, char ei_class, char ei_data);
 
-  Elf_SymValue *lookup(const char *name,
+  Elf_SymValue* lookup(const char* name,
                        unsigned int type_filter = STT(OBJECT) | STT(FUNC));
 
   // private: // Until we have a real API
   std::vector<Elf_SymValue> syms;
 };
 
 class Elf_Rel : public serializable<Elf_Rel_Traits> {
  public:
   Elf_Rel() : serializable<Elf_Rel_Traits>(){};
 
-  Elf_Rel(std::ifstream &file, char ei_class, char ei_data)
+  Elf_Rel(std::ifstream& file, char ei_class, char ei_data)
       : serializable<Elf_Rel_Traits>(file, ei_class, ei_data){};
 
   static const unsigned int sh_type = SHT_REL;
   static const unsigned int d_tag = DT_REL;
   static const unsigned int d_tag_count = DT_RELCOUNT;
 };
 
 class Elf_Rela : public serializable<Elf_Rela_Traits> {
  public:
   Elf_Rela() : serializable<Elf_Rela_Traits>(){};
 
-  Elf_Rela(std::ifstream &file, char ei_class, char ei_data)
+  Elf_Rela(std::ifstream& file, char ei_class, char ei_data)
       : serializable<Elf_Rela_Traits>(file, ei_class, ei_data){};
 
   static const unsigned int sh_type = SHT_RELA;
   static const unsigned int d_tag = DT_RELA;
   static const unsigned int d_tag_count = DT_RELACOUNT;
 };
 
 template <class Rel>
 class ElfRel_Section : public ElfSection {
  public:
-  ElfRel_Section(Elf_Shdr &s, std::ifstream *file, Elf *parent)
+  ElfRel_Section(Elf_Shdr& s, std::ifstream* file, Elf* parent)
       : ElfSection(s, file, parent) {
     int pos = file->tellg();
     file->seekg(shdr.sh_offset);
     for (unsigned int i = 0; i < s.sh_size / s.sh_entsize; i++) {
       Rel r(*file, parent->getClass(), parent->getData());
       rels.push_back(r);
     }
     file->seekg(pos);
   }
 
-  void serialize(std::ofstream &file, char ei_class, char ei_data) {
+  void serialize(std::ofstream& file, char ei_class, char ei_data) {
     for (typename std::vector<Rel>::iterator i = rels.begin(); i != rels.end();
          ++i)
       (*i).serialize(file, ei_class, ei_data);
   }
   // private: // Until we have a real API
   std::vector<Rel> rels;
 };
 
 class ElfStrtab_Section : public ElfSection {
  public:
-  ElfStrtab_Section(Elf_Shdr &s, std::ifstream *file, Elf *parent)
+  ElfStrtab_Section(Elf_Shdr& s, std::ifstream* file, Elf* parent)
       : ElfSection(s, file, parent) {
     table.push_back(table_storage(data, shdr.sh_size));
   }
 
   ~ElfStrtab_Section() {
     for (std::vector<table_storage>::iterator t = table.begin() + 1;
          t != table.end(); ++t)
       delete[] t->buf;
   }
 
-  const char *getStr(unsigned int index);
+  const char* getStr(unsigned int index);
 
-  const char *getStr(const char *string);
+  const char* getStr(const char* string);
 
-  unsigned int getStrIndex(const char *string);
+  unsigned int getStrIndex(const char* string);
 
-  void serialize(std::ofstream &file, char ei_class, char ei_data);
+  void serialize(std::ofstream& file, char ei_class, char ei_data);
 
  private:
   struct table_storage {
     unsigned int size, used;
-    char *buf;
+    char* buf;
 
     table_storage() : size(4096), used(0), buf(new char[4096]) {}
-    table_storage(const char *data, unsigned int sz)
-        : size(sz), used(sz), buf(const_cast<char *>(data)) {}
+    table_storage(const char* data, unsigned int sz)
+        : size(sz), used(sz), buf(const_cast<char*>(data)) {}
   };
   std::vector<table_storage> table;
 };
 
 inline char Elf::getClass() { return ehdr->e_ident[EI_CLASS]; }
 
 inline char Elf::getData() { return ehdr->e_ident[EI_DATA]; }
 
 inline char Elf::getType() { return ehdr->e_type; }
 
 inline char Elf::getMachine() { return ehdr->e_machine; }
 
 inline unsigned int Elf::getSize() {
-  ElfSection *section;
+  ElfSection* section;
   for (section = shdr_section /* It's usually not far from the end */;
        section->getNext() != nullptr; section = section->getNext())
     ;
   return section->getOffset() + section->getSize();
 }
 
-inline ElfSegment *ElfSection::getSegmentByType(unsigned int type) {
-  for (std::vector<ElfSegment *>::iterator seg = segments.begin();
+inline ElfSegment* ElfSection::getSegmentByType(unsigned int type) {
+  for (std::vector<ElfSegment*>::iterator seg = segments.begin();
        seg != segments.end(); ++seg)
     if ((*seg)->getType() == type) return *seg;
   return nullptr;
 }
 
-inline void ElfSection::insertInSegments(std::vector<ElfSegment *> &segs) {
-  for (std::vector<ElfSegment *>::iterator it = segs.begin(); it != segs.end();
+inline void ElfSection::insertInSegments(std::vector<ElfSegment*>& segs) {
+  for (std::vector<ElfSegment*>::iterator it = segs.begin(); it != segs.end();
        ++it) {
     (*it)->addSection(this);
   }
 }
 
-inline ElfLocation::ElfLocation(ElfSection *section, unsigned int off,
+inline ElfLocation::ElfLocation(ElfSection* section, unsigned int off,
                                 enum position pos)
     : section(section) {
   if ((pos == ABSOLUTE) && section)
     offset = off - section->getAddr();
   else
     offset = off;
 }
 
-inline ElfLocation::ElfLocation(unsigned int location, Elf *elf) {
+inline ElfLocation::ElfLocation(unsigned int location, Elf* elf) {
   section = elf->getSectionAt(location);
   offset = location - (section ? section->getAddr() : 0);
 }
 
 inline unsigned int ElfLocation::getValue() {
   return (section ? section->getAddr() : 0) + offset;
 }
 
-inline const char *ElfLocation::getBuffer() {
+inline const char* ElfLocation::getBuffer() {
   return section ? section->getData() + offset : nullptr;
 }
 
 inline unsigned int ElfSize::getValue() { return section->getSize(); }
 
 inline unsigned int ElfEntSize::getValue() { return section->getEntSize(); }
--- a/build/unix/elfhack/inject.c
+++ b/build/unix/elfhack/inject.c
@@ -25,64 +25,64 @@
 // to use the long_call attribute, which forces the compiler to generate code
 // that can call anywhere, but clang doesn't support the attribute yet
 // (https://bugs.llvm.org/show_bug.cgi?id=40623), and while the command-line
 // equivalent does exist, it's currently broken
 // (https://bugs.llvm.org/show_bug.cgi?id=40624). So we create a manual
 // trampoline, corresponding to the code GCC generates with long_call.
 #ifdef __arm__
 __attribute__((section(".text._init_trampoline"), naked)) int init_trampoline(
-    int argc, char **argv, char **env) {
+    int argc, char** argv, char** env) {
   __asm__ __volatile__(
       // thumb doesn't allow to use r12/ip with ldr, and thus would require an
       // additional push/pop to save/restore the modified register, which would
       // also change the call into a blx. It's simpler to switch to arm.
       ".arm\n"
       "  ldr ip, .LADDR\n"
       ".LAFTER:\n"
       "  add ip, pc, ip\n"
       "  bx ip\n"
       ".LADDR:\n"
       "  .word real_original_init-(.LAFTER+8)\n");
 }
 #endif
 
 extern __attribute__((visibility("hidden"))) void original_init(int argc,
-                                                                char **argv,
-                                                                char **env);
+                                                                char** argv,
+                                                                char** env);
 
 extern __attribute__((visibility("hidden"))) Elf32_Rel relhack[];
 extern __attribute__((visibility("hidden"))) Elf_Ehdr elf_header;
 
-extern __attribute__((visibility("hidden"))) int (*mprotect_cb)(void *addr,
+extern __attribute__((visibility("hidden"))) int (*mprotect_cb)(void* addr,
                                                                 size_t len,
                                                                 int prot);
 extern __attribute__((visibility("hidden"))) long (*sysconf_cb)(int name);
 extern __attribute__((visibility("hidden"))) char relro_start[];
 extern __attribute__((visibility("hidden"))) char relro_end[];
 
 static inline __attribute__((always_inline)) void do_relocations(void) {
-  Elf32_Rel *rel;
+  Elf32_Rel* rel;
   Elf_Addr *ptr, *start;
   for (rel = relhack; rel->r_offset; rel++) {
-    start = (Elf_Addr *)((intptr_t)&elf_header + rel->r_offset);
+    start = (Elf_Addr*)((intptr_t)&elf_header + rel->r_offset);
     for (ptr = start; ptr < &start[rel->r_info]; ptr++)
       *ptr += (intptr_t)&elf_header;
   }
 }
 
 __attribute__((section(".text._init_noinit"))) int init_noinit(int argc,
-                                                               char **argv,
-                                                               char **env) {
+                                                               char** argv,
+                                                               char** env) {
   do_relocations();
   return 0;
 }
 
-__attribute__((section(".text._init"))) int init(int argc, char **argv,
-                                                 char **env) {
+__attribute__((section(".text._init"))) int init(int argc, char** argv,
+                                                 char** env) {
   do_relocations();
   original_init(argc, argv, env);
   // Ensure there is no tail-call optimization, avoiding the use of the
   // B.W instruction in Thumb for the call above.
   return 0;
 }
 
 static inline __attribute__((always_inline)) void do_relocations_with_relro(
@@ -91,34 +91,34 @@ static inline __attribute__((always_inli
   uintptr_t aligned_relro_start = ((uintptr_t)relro_start) & ~(page_size - 1);
   // The relro segment may not end at a page boundary. If that's the case, the
   // remainder of the page needs to stay read-write, so the last page is never
   // set read-only. Thus the aligned relro end is page-rounded down.
   uintptr_t aligned_relro_end = ((uintptr_t)relro_end) & ~(page_size - 1);
   // By the time the injected code runs, the relro segment is read-only. But
   // we want to apply relocations in it, so we set it r/w first. We'll restore
   // it to read-only in relro_post.
-  mprotect_cb((void *)aligned_relro_start,
+  mprotect_cb((void*)aligned_relro_start,
               aligned_relro_end - aligned_relro_start, PROT_READ | PROT_WRITE);
 
   do_relocations();
 
-  mprotect_cb((void *)aligned_relro_start,
+  mprotect_cb((void*)aligned_relro_start,
               aligned_relro_end - aligned_relro_start, PROT_READ);
   // mprotect_cb and sysconf_cb are allocated in .bss, so we need to restore
   // them to a NULL value.
   mprotect_cb = NULL;
   sysconf_cb = NULL;
 }
 
 __attribute__((section(".text._init_noinit_relro"))) int init_noinit_relro(
-    int argc, char **argv, char **env) {
+    int argc, char** argv, char** env) {
   do_relocations_with_relro();
   return 0;
 }
 
 __attribute__((section(".text._init_relro"))) int init_relro(int argc,
-                                                             char **argv,
-                                                             char **env) {
+                                                             char** argv,
+                                                             char** env) {
   do_relocations_with_relro();
   original_init(argc, argv, env);
   return 0;
 }
--- a/build/unix/elfhack/test.c
+++ b/build/unix/elfhack/test.c
@@ -86,27 +86,27 @@ DEF(times)
 #  pragma GCC visibility push(default)
 #  include <stdlib.h>
 #  include <stdio.h>
 
 #  define DEF(w) static const char str_##w[] = #  w;
 #  include "test.c"
 #  undef DEF
 
-const char *strings[] = {
+const char* strings[] = {
 #  define DEF(w) str_##w,
 #  include "test.c"
 #  include "test.c"
 #  include "test.c"
 };
 
 /* Create a hole between two zones of relative relocations */
 const int hole[] = {42, 42, 42, 42};
 
-const char *strings2[] = {
+const char* strings2[] = {
 #  include "test.c"
 #  include "test.c"
 #  include "test.c"
 #  include "test.c"
 #  include "test.c"
 #  undef DEF
 };
 
--- a/caps/NullPrincipalURI.h
+++ b/caps/NullPrincipalURI.h
@@ -41,58 +41,58 @@ class NullPrincipalURI final : public ns
   virtual size_t SizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const override;
   virtual size_t SizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const override;
 
   // Returns null on failure.
   static already_AddRefed<NullPrincipalURI> Create();
 
  private:
   NullPrincipalURI();
-  NullPrincipalURI(const NullPrincipalURI &aOther);
+  NullPrincipalURI(const NullPrincipalURI& aOther);
 
   ~NullPrincipalURI() {}
 
   nsresult Init();
 
   nsAutoCStringN<NSID_LENGTH> mPath;
 
-  nsresult Clone(nsIURI **aURI);
-  nsresult SetSpecInternal(const nsACString &input);
-  nsresult SetScheme(const nsACString &input);
-  nsresult SetUserPass(const nsACString &input);
-  nsresult SetUsername(const nsACString &input);
-  nsresult SetPassword(const nsACString &input);
-  nsresult SetHostPort(const nsACString &aValue);
-  nsresult SetHost(const nsACString &input);
+  nsresult Clone(nsIURI** aURI);
+  nsresult SetSpecInternal(const nsACString& input);
+  nsresult SetScheme(const nsACString& input);
+  nsresult SetUserPass(const nsACString& input);
+  nsresult SetUsername(const nsACString& input);
+  nsresult SetPassword(const nsACString& input);
+  nsresult SetHostPort(const nsACString& aValue);
+  nsresult SetHost(const nsACString& input);
   nsresult SetPort(int32_t port);
-  nsresult SetPathQueryRef(const nsACString &input);
-  nsresult SetRef(const nsACString &input);
-  nsresult SetFilePath(const nsACString &input);
-  nsresult SetQuery(const nsACString &input);
-  nsresult SetQueryWithEncoding(const nsACString &input,
-                                const Encoding *encoding);
-  bool Deserialize(const mozilla::ipc::URIParams &);
+  nsresult SetPathQueryRef(const nsACString& input);
+  nsresult SetRef(const nsACString& input);
+  nsresult SetFilePath(const nsACString& input);
+  nsresult SetQuery(const nsACString& input);
+  nsresult SetQueryWithEncoding(const nsACString& input,
+                                const Encoding* encoding);
+  bool Deserialize(const mozilla::ipc::URIParams&);
 
  public:
   class Mutator final : public nsIURIMutator,
                         public BaseURIMutator<NullPrincipalURI> {
     NS_DECL_ISUPPORTS
     NS_FORWARD_SAFE_NSIURISETTERS_RET(mURI)
 
-    NS_IMETHOD Deserialize(const mozilla::ipc::URIParams &aParams) override {
+    NS_IMETHOD Deserialize(const mozilla::ipc::URIParams& aParams) override {
       return InitFromIPCParams(aParams);
     }
 
-    NS_IMETHOD Finalize(nsIURI **aURI) override {
+    NS_IMETHOD Finalize(nsIURI** aURI) override {
       mURI.forget(aURI);
       return NS_OK;
     }
 
-    NS_IMETHOD SetSpec(const nsACString &aSpec,
-                       nsIURIMutator **aMutator) override {
+    NS_IMETHOD SetSpec(const nsACString& aSpec,
+                       nsIURIMutator** aMutator) override {
       if (aMutator) {
         nsCOMPtr<nsIURIMutator> mutator = this;
         mutator.forget(aMutator);
       }
       return NS_ERROR_NOT_IMPLEMENTED;
     }
 
     explicit Mutator() {}
--- a/caps/tests/gtest/TestOriginAttributes.cpp
+++ b/caps/tests/gtest/TestOriginAttributes.cpp
@@ -4,28 +4,28 @@
 #include "gtest/gtest.h"
 #include "mozilla/BasePrincipal.h"
 #include "mozilla/Preferences.h"
 #include "nsNetUtil.h"
 
 using mozilla::OriginAttributes;
 using mozilla::Preferences;
 
-static void TestSuffix(const OriginAttributes &attrs) {
+static void TestSuffix(const OriginAttributes& attrs) {
   nsAutoCString suffix;
   attrs.CreateSuffix(suffix);
 
   OriginAttributes attrsFromSuffix;
   bool success = attrsFromSuffix.PopulateFromSuffix(suffix);
   EXPECT_TRUE(success);
 
   EXPECT_EQ(attrs, attrsFromSuffix);
 }
 
-static void TestFPD(const nsAString &spec, const nsAString &fpd) {
+static void TestFPD(const nsAString& spec, const nsAString& fpd) {
   OriginAttributes attrs;
   nsCOMPtr<nsIURI> url;
   ASSERT_EQ(NS_NewURI(getter_AddRefs(url), spec), NS_OK);
   attrs.SetFirstPartyDomain(true, url);
   EXPECT_TRUE(attrs.mFirstPartyDomain.Equals(fpd));
 }
 
 TEST(OriginAttributes, Suffix_default)
--- a/chrome/nsChromeProtocolHandler.cpp
+++ b/chrome/nsChromeProtocolHandler.cpp
@@ -33,51 +33,51 @@
 
 NS_IMPL_ISUPPORTS(nsChromeProtocolHandler, nsIProtocolHandler,
                   nsISupportsWeakReference)
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsIProtocolHandler methods:
 
 NS_IMETHODIMP
-nsChromeProtocolHandler::GetScheme(nsACString &result) {
+nsChromeProtocolHandler::GetScheme(nsACString& result) {
   result.AssignLiteral("chrome");
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsChromeProtocolHandler::GetDefaultPort(int32_t *result) {
+nsChromeProtocolHandler::GetDefaultPort(int32_t* result) {
   *result = -1;  // no port for chrome: URLs
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsChromeProtocolHandler::AllowPort(int32_t port, const char *scheme,
-                                   bool *_retval) {
+nsChromeProtocolHandler::AllowPort(int32_t port, const char* scheme,
+                                   bool* _retval) {
   // don't override anything.
   *_retval = false;
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsChromeProtocolHandler::GetProtocolFlags(uint32_t *result) {
+nsChromeProtocolHandler::GetProtocolFlags(uint32_t* result) {
   *result = URI_STD | URI_IS_UI_RESOURCE | URI_IS_LOCAL_RESOURCE;
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsChromeProtocolHandler::NewURI(const nsACString &aSpec, const char *aCharset,
-                                nsIURI *aBaseURI, nsIURI **result) {
+nsChromeProtocolHandler::NewURI(const nsACString& aSpec, const char* aCharset,
+                                nsIURI* aBaseURI, nsIURI** result) {
   return nsChromeProtocolHandler::CreateNewURI(aSpec, aCharset, aBaseURI,
                                                result);
 }
 
 /* static */ nsresult nsChromeProtocolHandler::CreateNewURI(
-    const nsACString &aSpec, const char *aCharset, nsIURI *aBaseURI,
-    nsIURI **result) {
+    const nsACString& aSpec, const char* aCharset, nsIURI* aBaseURI,
+    nsIURI** result) {
   // Chrome: URLs (currently) have no additional structure beyond that provided
   // by standard URLs, so there is no "outer" given to CreateInstance
   nsresult rv;
   nsCOMPtr<nsIURI> surl;
   nsCOMPtr<nsIURI> base(aBaseURI);
   rv = NS_MutateURI(new mozilla::net::nsStandardURL::Mutator())
            .Apply(NS_MutatorMethod(&nsIStandardURLMutator::Init,
                                    nsIStandardURL::URLTYPE_STANDARD, -1,
@@ -94,18 +94,18 @@ nsChromeProtocolHandler::NewURI(const ns
   rv = nsChromeRegistry::Canonify(surl);
   if (NS_FAILED(rv)) return rv;
 
   surl.forget(result);
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsChromeProtocolHandler::NewChannel(nsIURI *aURI, nsILoadInfo *aLoadInfo,
-                                    nsIChannel **aResult) {
+nsChromeProtocolHandler::NewChannel(nsIURI* aURI, nsILoadInfo* aLoadInfo,
+                                    nsIChannel** aResult) {
   nsresult rv;
 
   NS_ENSURE_ARG_POINTER(aURI);
   NS_ENSURE_ARG_POINTER(aLoadInfo);
 
   MOZ_ASSERT(aResult, "Null out param");
 
 #ifdef DEBUG
--- a/chrome/nsChromeProtocolHandler.h
+++ b/chrome/nsChromeProtocolHandler.h
@@ -22,16 +22,16 @@ class nsChromeProtocolHandler final : pu
  public:
   NS_DECL_THREADSAFE_ISUPPORTS
 
   // nsIProtocolHandler methods:
   NS_DECL_NSIPROTOCOLHANDLER
 
   // nsChromeProtocolHandler methods:
   nsChromeProtocolHandler() {}
-  static nsresult CreateNewURI(const nsACString &aSpec, const char *aCharset,
-                               nsIURI *aBaseURI, nsIURI **result);
+  static nsresult CreateNewURI(const nsACString& aSpec, const char* aCharset,
+                               nsIURI* aBaseURI, nsIURI** result);
 
  private:
   ~nsChromeProtocolHandler() {}
 };
 
 #endif /* nsChromeProtocolHandler_h___ */
--- a/config/nsinstall.c
+++ b/config/nsinstall.c
@@ -57,18 +57,18 @@ extern int fchmod(int fildes, mode_t mod
 static void usage(void) {
   fprintf(stderr,
           "usage: %s [-C cwd] [-L linkprefix] [-m mode] [-o owner] [-g group]\n"
           "       %*s [-DdltR] file [file ...] directory\n",
           program, (int)strlen(program), "");
   exit(2);
 }
 
-static int mkdirs(char *path, mode_t mode) {
-  char *cp;
+static int mkdirs(char* path, mode_t mode) {
+  char* cp;
   struct stat sb;
   int res;
   int l;
 
   /* strip trailing "/." */
   l = strlen(path);
   if (l > 1 && path[l - 1] == '.' && path[l - 2] == '/') path[l - 2] = 0;
 
@@ -86,42 +86,42 @@ static int mkdirs(char *path, mode_t mod
 
   res = mkdir(path, mode);
   if ((res != 0) && (errno == EEXIST))
     return 0;
   else
     return res;
 }
 
-static uid_t touid(char *owner) {
-  struct passwd *pw;
+static uid_t touid(char* owner) {
+  struct passwd* pw;
   uid_t uid;
-  char *cp;
+  char* cp;
 
   pw = getpwnam(owner);
   if (pw) return pw->pw_uid;
   uid = strtol(owner, &cp, 0);
   if (uid == 0 && cp == owner) fail("cannot find uid for %s", owner);
   return uid;
 }
 
-static gid_t togid(char *group) {
-  struct group *gr;
+static gid_t togid(char* group) {
+  struct group* gr;
   gid_t gid;
-  char *cp;
+  char* cp;
 
   gr = getgrnam(group);
   if (gr) return gr->gr_gid;
   gid = strtol(group, &cp, 0);
   if (gid == 0 && cp == group) fail("cannot find gid for %s", group);
   return gid;
 }
 
-static void copyfile(char *name, char *toname, mode_t mode, char *group,
-                     char *owner, int dotimes, uid_t uid, gid_t gid) {
+static void copyfile(char* name, char* toname, mode_t mode, char* group,
+                     char* owner, int dotimes, uid_t uid, gid_t gid) {
   int fromfd, tofd = -1, cc, wc, exists;
   char buf[BUFSIZ], *bp;
   struct stat sb, tosb;
   struct utimbuf utb;
 
   exists = (lstat(toname, &tosb) == 0);
 
   fromfd = open(name, O_RDONLY);
@@ -176,20 +176,20 @@ static void copyfile(char *name, char *t
   if (dotimes) {
     utb.actime = sb.st_atime;
     utb.modtime = sb.st_mtime;
     if (utime(toname, &utb) < 0) fail("cannot set times of %s", toname);
   }
 #endif
 }
 
-static void copydir(char *from, char *to, mode_t mode, char *group, char *owner,
+static void copydir(char* from, char* to, mode_t mode, char* group, char* owner,
                     int dotimes, uid_t uid, gid_t gid) {
-  DIR *dir;
-  struct dirent *ep;
+  DIR* dir;
+  struct dirent* ep;
   struct stat sb;
   char *base, *destdir, *direntry, *destentry;
 
   base = xbasename(from);
 
   /* create destination directory */
   destdir = xmalloc((unsigned int)(strlen(to) + 1 + strlen(base) + 1));
   sprintf(destdir, "%s%s%s", to, _DIRECTORY_SEPARATOR, base);
@@ -221,17 +221,17 @@ static void copydir(char *from, char *to
   }
 
   free(destdir);
   free(direntry);
   free(destentry);
   closedir(dir);
 }
 
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   int onlydir, dodir, dolink, dorelsymlink, dotimes, opt, len, lplen, tdlen,
       bnlen, exists;
   mode_t mode = 0755;
   char *linkprefix, *owner, *group, *cp, *cwd, *todir, *toname, *name, *base,
       *linkname, buf[BUFSIZ];
   uid_t uid;
   gid_t gid;
   struct stat sb, tosb, fromsb;
--- a/config/pathsub.c
+++ b/config/pathsub.c
@@ -22,19 +22,19 @@
 #ifdef USE_REENTRANT_LIBC
 #  include <libc_r.h>
 #endif
 
 #ifdef SUNOS4
 #  include "sunos4.h"
 #endif
 
-char *program;
+char* program;
 
-void fail(const char *format, ...) {
+void fail(const char* format, ...) {
   int error;
   va_list ap;
 
 #ifdef USE_REENTRANT_LIBC
   R_STRERROR_INIT_R();
 #endif
 
   error = errno;
@@ -50,17 +50,17 @@ void fail(const char *format, ...) {
     fprintf(stderr, ": %s", strerror(errno));
 #endif
   }
 
   putc('\n', stderr);
   exit(1);
 }
 
-char *getcomponent(char *path, char *name) {
+char* getcomponent(char* path, char* name) {
   if (*path == '\0') return 0;
   if (*path == '/') {
     *name++ = '/';
   } else {
     do {
       *name++ = *path++;
     } while (*path != '/' && *path != '\0');
   }
@@ -69,62 +69,62 @@ char *getcomponent(char *path, char *nam
   return path;
 }
 
 #ifdef LAME_READDIR
 #  include <sys/param.h>
 /*
 ** The static buffer in Unixware's readdir is too small.
 */
-struct dirent *readdir(DIR *d) {
-  static struct dirent *buf = NULL;
+struct dirent* readdir(DIR* d) {
+  static struct dirent* buf = NULL;
 
   if (buf == NULL)
-    buf = (struct dirent *)malloc(sizeof(struct dirent) + MAXPATHLEN);
+    buf = (struct dirent*)malloc(sizeof(struct dirent) + MAXPATHLEN);
   return (readdir_r(d, buf));
 }
 #endif
 
-char *ino2name(ino_t ino) {
-  DIR *dp;
-  struct dirent *ep;
-  char *name;
+char* ino2name(ino_t ino) {
+  DIR* dp;
+  struct dirent* ep;
+  char* name;
 
   dp = opendir("..");
   if (!dp) fail("cannot read parent directory");
   for (;;) {
     if (!(ep = readdir(dp))) fail("cannot find current directory");
     if (ep->d_ino == ino) break;
   }
   name = xstrdup(ep->d_name);
   closedir(dp);
   return name;
 }
 
-void *xmalloc(size_t size) {
-  void *p = malloc(size);
+void* xmalloc(size_t size) {
+  void* p = malloc(size);
   if (!p) fail("cannot allocate %u bytes", size);
   return p;
 }
 
-char *xstrdup(char *s) { return strcpy(xmalloc(strlen(s) + 1), s); }
+char* xstrdup(char* s) { return strcpy(xmalloc(strlen(s) + 1), s); }
 
-char *xbasename(char *path) {
-  char *cp;
+char* xbasename(char* path) {
+  char* cp;
 
   while ((cp = strrchr(path, '/')) && cp[1] == '\0') *cp = '\0';
   if (!cp) return path;
   return cp + 1;
 }
 
-void xchdir(const char *dir) {
+void xchdir(const char* dir) {
   if (chdir(dir) < 0) fail("cannot change directory to %s", dir);
 }
 
-int relatepaths(char *from, char *to, char *outpath) {
+int relatepaths(char* from, char* to, char* outpath) {
   char *cp, *cp2;
   int len;
   char buf[NAME_MAX];
 
   assert(*from == '/' && *to == '/');
   for (cp = to, cp2 = from; *cp == *cp2; cp++, cp2++)
     if (*cp == '\0') break;
   while (cp[-1] != '/') cp--, cp2--;
@@ -144,17 +144,17 @@ int relatepaths(char *from, char *to, ch
     while ((cp = getcomponent(cp, buf)) != 0) {
       sprintf(outpath + len, "%s/", buf);
       len += strlen(outpath + len);
     }
   }
   return len;
 }
 
-void reversepath(char *inpath, char *name, int len, char *outpath) {
+void reversepath(char* inpath, char* name, int len, char* outpath) {
   char *cp, *cp2;
   char buf[NAME_MAX];
   struct stat sb;
 
   cp = strcpy(outpath + PATH_MAX - (len + 1), name);
   cp2 = inpath;
   while ((cp2 = getcomponent(cp2, buf)) != 0) {
     if (strcmp(buf, ".") == 0) continue;
--- a/config/pathsub.h
+++ b/config/pathsub.h
@@ -18,25 +18,25 @@
 #endif
 
 /*
  * Just prevent stupidity
  */
 #undef NAME_MAX
 #define NAME_MAX 256
 
-extern char *program;
+extern char* program;
 
-extern void fail(const char *format, ...);
-extern char *getcomponent(char *path, char *name);
-extern char *ino2name(ino_t ino);
-extern void *xmalloc(size_t size);
-extern char *xstrdup(char *s);
-extern char *xbasename(char *path);
-extern void xchdir(const char *dir);
+extern void fail(const char* format, ...);
+extern char* getcomponent(char* path, char* name);
+extern char* ino2name(ino_t ino);
+extern void* xmalloc(size_t size);
+extern char* xstrdup(char* s);
+extern char* xbasename(char* path);
+extern void xchdir(const char* dir);
 
 /* Relate absolute pathnames from and to returning the result in outpath. */
-extern int relatepaths(char *from, char *to, char *outpath);
+extern int relatepaths(char* from, char* to, char* outpath);
 
 /* XXX changes current working directory -- caveat emptor */
-extern void reversepath(char *inpath, char *name, int len, char *outpath);
+extern void reversepath(char* inpath, char* name, int len, char* outpath);
 
 #endif /* pathsub_h___ */
--- a/devtools/client/inspector/fonts/test/browser.ini
+++ b/devtools/client/inspector/fonts/test/browser.ini
@@ -13,17 +13,17 @@ support-files =
   !/devtools/client/shared/test/shared-head.js
   !/devtools/client/shared/test/telemetry-test-helpers.js
   !/devtools/client/shared/test/test-actor.js
   !/devtools/client/shared/test/test-actor-registry.js
 
 [browser_fontinspector.js]
 [browser_fontinspector_copy-URL.js]
 skip-if = !e10s # too slow on !e10s, logging fully serialized actors (Bug 1446595)
-subsuite = clipboard
+tags = clipboard
 [browser_fontinspector_all-fonts.js]
 [browser_fontinspector_edit-previews.js]
 [browser_fontinspector_editor-font-size-conversion.js]
 [browser_fontinspector_editor-keywords.js]
 [browser_fontinspector_editor-letter-spacing-conversion.js]
 [browser_fontinspector_editor-values.js]
 [browser_fontinspector_expand-css-code.js]
 [browser_fontinspector_font-type-telemetry.js]
--- a/devtools/client/inspector/markup/test/browser.ini
+++ b/devtools/client/inspector/markup/test/browser.ini
@@ -100,19 +100,19 @@ skip-if = os == "mac" # Full keyboard na
 [browser_markup_anonymous_01.js]
 [browser_markup_anonymous_02.js]
 skip-if = (os == 'win' && processor == 'aarch64') # bug 1531584
 [browser_markup_anonymous_03.js]
 skip-if = (os == 'win' && processor == 'aarch64') # bug 1531584
 [browser_markup_anonymous_04.js]
 skip-if = (os == 'win' && processor == 'aarch64') # bug 1531584
 [browser_markup_copy_html.js]
-subsuite = clipboard
+tags = clipboard
 [browser_markup_copy_image_data.js]
-subsuite = clipboard
+tags = clipboard
 skip-if = (os == 'linux' && bits == 32 && debug) || (os == "win" && processor == "aarch64") # bug 1328915, disable linux32 debug devtools for timeouts, disabled on aarch64 due to 1531598
 [browser_markup_css_completion_style_attribute_01.js]
 [browser_markup_css_completion_style_attribute_02.js]
 [browser_markup_css_completion_style_attribute_03.js]
 [browser_markup_display_node_01.js]
 [browser_markup_display_node_02.js]
 [browser_markup_dragdrop_autoscroll_01.js]
 [browser_markup_dragdrop_autoscroll_02.js]
@@ -155,17 +155,17 @@ skip-if = true # Bug 1177550
 [browser_markup_flex_display_badge_telemetry.js]
 [browser_markup_grid_display_badge_01.js]
 [browser_markup_grid_display_badge_02.js]
 [browser_markup_grid_display_badge_telemetry.js]
 [browser_markup_links_01.js]
 [browser_markup_links_02.js]
 [browser_markup_links_03.js]
 [browser_markup_links_04.js]
-subsuite = clipboard
+tags = clipboard
 skip-if = (os == 'linux' && bits == 32 && debug) || (os == "win" && processor == "aarch64") # bug 1328915, disable linux32 debug devtools for timeouts, aarch64 due to 1531598
 [browser_markup_links_05.js]
 [browser_markup_links_06.js]
 [browser_markup_links_07.js]
 [browser_markup_load_01.js]
 skip-if = verify
 [browser_markup_html_edit_01.js]
 [browser_markup_html_edit_02.js]
@@ -194,17 +194,17 @@ skip-if = verify
 [browser_markup_screenshot_node_iframe.js]
 [browser_markup_screenshot_node_shadowdom.js]
 [browser_markup_scrollable_badge.js]
 [browser_markup_search_01.js]
 [browser_markup_shadowdom.js]
 [browser_markup_shadowdom_clickreveal.js]
 [browser_markup_shadowdom_clickreveal_scroll.js]
 [browser_markup_shadowdom_copy_paths.js]
-subsuite = clipboard
+tags = clipboard
 [browser_markup_shadowdom_delete.js]
 [browser_markup_shadowdom_dynamic.js]
 [browser_markup_shadowdom_hover.js]
 [browser_markup_shadowdom_marker_and_before_pseudos.js]
 [browser_markup_shadowdom_maxchildren.js]
 [browser_markup_shadowdom_mutations_shadow.js]
 [browser_markup_shadowdom_navigation.js]
 [browser_markup_shadowdom_nested_pick_inspect.js]
--- a/devtools/client/inspector/rules/models/element-style.js
+++ b/devtools/client/inspector/rules/models/element-style.js
@@ -1,28 +1,25 @@
 /* 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/. */
 
 "use strict";
 
-const Services = require("Services");
 const promise = require("promise");
 const Rule = require("devtools/client/inspector/rules/models/rule");
 const UserProperties = require("devtools/client/inspector/rules/models/user-properties");
 const { ELEMENT_STYLE } = require("devtools/shared/specs/styles");
 
 loader.lazyRequireGetter(this, "promiseWarn", "devtools/client/inspector/shared/utils", true);
 loader.lazyRequireGetter(this, "parseDeclarations", "devtools/shared/css/parsing-utils", true);
 loader.lazyRequireGetter(this, "parseNamedDeclarations", "devtools/shared/css/parsing-utils", true);
 loader.lazyRequireGetter(this, "parseSingleValue", "devtools/shared/css/parsing-utils", true);
 loader.lazyRequireGetter(this, "isCssVariable", "devtools/shared/fronts/css-properties", true);
 
-const PREF_INACTIVE_CSS_ENABLED = "devtools.inspector.inactive.css.enabled";
-
 /**
  * ElementStyle is responsible for the following:
  *   Keeps track of which properties are overridden.
  *   Maintains a list of Rule objects for a given element.
  */
 class ElementStyle {
   /**
    * @param  {Element} element
@@ -63,23 +60,16 @@ class ElementStyle {
 
     if (this.ruleView.isNewRulesView) {
       this.pageStyle.on("stylesheet-updated", this.onRefresh);
       this.ruleView.inspector.styleChangeTracker.on("style-changed", this.onRefresh);
       this.ruleView.selection.on("pseudoclass", this.onRefresh);
     }
   }
 
-  get unusedCssEnabled() {
-    if (!this._unusedCssEnabled) {
-      this._unusedCssEnabled = Services.prefs.getBoolPref(PREF_INACTIVE_CSS_ENABLED);
-    }
-    return this._unusedCssEnabled;
-  }
-
   destroy() {
     if (this.destroyed) {
       return;
     }
 
     this.destroyed = true;
 
     for (const rule of this.rules) {
@@ -130,17 +120,17 @@ class ElementStyle {
 
       this.rules = [];
 
       for (const entry of entries) {
         this._maybeAddRule(entry, existingRules);
       }
 
       // Mark overridden computed styles.
-      this.onRuleUpdated();
+      this.markOverriddenAll();
 
       this._sortRulesForPseudoElement();
 
       if (this.ruleView.isNewRulesView) {
         this.subscribeRulesToLocationChange();
       }
 
       // We're done with the previous list of rules.
@@ -247,38 +237,36 @@ class ElementStyle {
       return false;
     }
 
     this.rules.push(rule);
     return true;
   }
 
   /**
-   * Calls updateDeclarations with all supported pseudo elements
+   * Calls markOverridden with all supported pseudo elements
    */
-  onRuleUpdated() {
+  markOverriddenAll() {
     this.variables.clear();
-    this.updateDeclarations();
+    this.markOverridden();
 
     for (const pseudo of this.cssProperties.pseudoElements) {
-      this.updateDeclarations(pseudo);
+      this.markOverridden(pseudo);
     }
   }
 
   /**
-   * Mark the declarations for a given pseudo element with an overridden flag if
-   * an earlier property overrides it and update the editor to show it in the
-   * UI. If there is any inactive CSS we also update the editors state to show
-   * the inactive CSS icon.
+   * Mark the properties listed in this.rules for a given pseudo element
+   * with an overridden flag if an earlier property overrides it.
    *
    * @param  {String} pseudo
    *         Which pseudo element to flag as overridden.
    *         Empty string or undefined will default to no pseudo element.
    */
-  updateDeclarations(pseudo = "") {
+  markOverridden(pseudo = "") {
     // Gather all the text properties applied by these rules, ordered
     // from more- to less-specific. Text properties from keyframes rule are
     // excluded from being marked as overridden since a number of criteria such
     // as time, and animation overlay are required to be check in order to
     // determine if the property is overridden.
     const textProps = [];
     for (const rule of this.rules) {
       if ((rule.matchedSelectors.length > 0 ||
@@ -352,32 +340,26 @@ class ElementStyle {
         taken[computedProp.name] = computedProp;
 
         if (isCssVariable(computedProp.name)) {
           this.variables.set(computedProp.name, computedProp.value);
         }
       }
     }
 
-    // For each TextProperty, mark it overridden if all of its computed
-    // properties are marked overridden. Update the text property's associated
-    // editor, if any. This will clear the _overriddenDirty state on all
-    // computed properties. For each editor we also show or hide the inactive
-    // CSS icon as needed.
+    // For each TextProperty, mark it overridden if all of its
+    // computed properties are marked overridden. Update the text
+    // property's associated editor, if any. This will clear the
+    // _overriddenDirty state on all computed properties.
     for (const textProp of textProps) {
       // _updatePropertyOverridden will return true if the
       // overridden state has changed for the text property.
       if (this._updatePropertyOverridden(textProp)) {
         textProp.updateEditor();
       }
-
-      // For each editor show or hide the inactive CSS icon as needed.
-      if (textProp.editor && this.unusedCssEnabled) {
-        textProp.editor.updatePropertyState();
-      }
     }
   }
 
   /**
    * Adds a new declaration to the rule.
    *
    * @param  {String} ruleId
    *         The id of the Rule to be modified.
@@ -594,30 +576,30 @@ class ElementStyle {
 
       // Remove the old rule and insert the new rule according to where it appears
       // in the list of applied styles.
       this.rules.splice(oldIndex, 1);
       // If the selector no longer matches, then we leave the rule in
       // the same relative position.
       this.rules.splice(newIndex === -1 ? oldIndex : newIndex, 0, newRule);
 
-      // Recompute, mark and update the UI for any properties that are
-      // overridden or contain inactive CSS according to the new list of rules.
-      this.onRuleUpdated();
+      // Mark any properties that are overridden according to the new list of rules.
+      this.markOverriddenAll();
 
       // In order to keep the new rule in place of the old in the rules view, we need
       // to remove the rule again if the rule was inserted to its new index according
       // to the list of applied styles.
       // Note: you might think we would replicate the list-modification logic above,
       // but that is complicated due to the way the UI installs pseudo-element rules
       // and the like.
       if (newIndex !== -1) {
         this.rules.splice(newIndex, 1);
         this.rules.splice(oldIndex, 0, newRule);
       }
+
       this._changed();
     } catch (e) {
       console.error(e);
     }
   }
 
   /**
    * Subscribes all the rules to location changes.
--- a/devtools/client/inspector/rules/models/rule.js
+++ b/devtools/client/inspector/rules/models/rule.js
@@ -303,17 +303,17 @@ class Rule {
   }
 
   /**
    * Helper function for applyProperties that is called when the actor
    * does not support as-authored styles.  Store disabled properties
    * in the element style's store.
    */
   _applyPropertiesNoAuthored(modifications) {
-    this.elementStyle.onRuleUpdated();
+    this.elementStyle.markOverriddenAll();
 
     const disabledProps = [];
 
     for (const prop of this.textProps) {
       if (prop.invisible) {
         continue;
       }
       if (!prop.enabled) {
@@ -414,17 +414,17 @@ class Rule {
           const modifications = this.domRule.startModifyingProperties(
             this.cssProperties);
           modifier(modifications);
           if (this.domRule.canSetRuleText) {
             return this._applyPropertiesAuthored(modifications);
           }
           return this._applyPropertiesNoAuthored(modifications);
         }).then(() => {
-          this.elementStyle.onRuleUpdated();
+          this.elementStyle.markOverriddenAll();
 
           if (resultPromise === this._applyingModifications) {
             this._applyingModifications = null;
             this.elementStyle._changed();
           }
         }).catch(promiseWarn);
 
     this._applyingModifications = resultPromise;
--- a/devtools/client/inspector/rules/models/text-property.js
+++ b/devtools/client/inspector/rules/models/text-property.js
@@ -227,29 +227,16 @@ class TextProperty {
     // true.
     if (!this.rule.domRule.declarations[selfIndex]) {
       return true;
     }
 
     return this.rule.domRule.declarations[selfIndex].isValid;
   }
 
-  isUsed() {
-    const selfIndex = this.rule.textProps.indexOf(this);
-    const declarations = this.rule.domRule.declarations;
-
-    // StyleRuleActor's declarations may have a isUsed flag (if the server is the right
-    // version). Just return true if the information is missing.
-    if (!declarations || !declarations[selfIndex] || !declarations[selfIndex].isUsed) {
-      return { used: true };
-    }
-
-    return declarations[selfIndex].isUsed;
-  }
-
   /**
    * Validate the name of this property.
    *
    * @return {Boolean} true if the property name is valid, false otherwise.
    */
   isNameValid() {
     const selfIndex = this.rule.textProps.indexOf(this);
 
--- a/devtools/client/inspector/rules/test/browser.ini
+++ b/devtools/client/inspector/rules/test/browser.ini
@@ -104,17 +104,17 @@ skip-if = (verify && !debug && os == 'wi
 [browser_rules_completion-popup-hidden-after-navigation.js]
 [browser_rules_content_01.js]
 [browser_rules_content_02.js]
 [browser_rules_variables_01.js]
 [browser_rules_variables_02.js]
 skip-if = e10s && debug # Bug 1250058 - Docshell leak on debug e10s
 [browser_rules_variables_03-case-sensitive.js]
 [browser_rules_copy_styles.js]
-subsuite = clipboard
+tags = clipboard
 skip-if = (os == 'linux' && bits == 32 && debug) # bug 1328915, disable linux32 debug devtools for timeouts
 [browser_rules_cssom.js]
 [browser_rules_cubicbezier-appears-on-swatch-click.js]
 [browser_rules_cubicbezier-commit-on-ENTER.js]
 [browser_rules_cubicbezier-revert-on-ESC.js]
 [browser_rules_custom.js]
 [browser_rules_cycle-angle.js]
 [browser_rules_cycle-color.js]
@@ -190,18 +190,16 @@ skip-if = (os == "win" && debug) # bug 9
 [browser_rules_grid-toggle_03.js]
 [browser_rules_grid-toggle_04.js]
 [browser_rules_grid-toggle_05.js]
 [browser_rules_gridline-names-autocomplete.js]
 [browser_rules_guessIndentation.js]
 [browser_rules_highlight-element-rule.js]
 [browser_rules_highlight-property.js]
 [browser_rules_highlight-used-fonts.js]
-[browser_rules_inactive_css_flexbox.js]
-[browser_rules_inactive_css_grid.js]
 [browser_rules_inherited-properties_01.js]
 [browser_rules_inherited-properties_02.js]
 [browser_rules_inherited-properties_03.js]
 [browser_rules_inherited-properties_04.js]
 [browser_rules_inline-source-map.js]
 [browser_rules_inline-style-order.js]
 [browser_rules_invalid.js]
 [browser_rules_invalid-source-map.js]
@@ -250,21 +248,21 @@ skip-if = (os == "win" && debug) # bug 9
 [browser_rules_search-filter_04.js]
 [browser_rules_search-filter_05.js]
 [browser_rules_search-filter_06.js]
 [browser_rules_search-filter_07.js]
 [browser_rules_search-filter_08.js]
 [browser_rules_search-filter_09.js]
 [browser_rules_search-filter_10.js]
 [browser_rules_search-filter_context-menu.js]
-subsuite = clipboard
+tags = clipboard
 skip-if = (os == 'linux' && bits == 32 && debug) # bug 1328915, disable linux32 debug devtools for timeouts
 [browser_rules_search-filter_escape-keypress.js]
 [browser_rules_select-and-copy-styles.js]
-subsuite = clipboard
+tags = clipboard
 skip-if = (os == 'linux' && bits == 32 && debug) # bug 1328915, disable linux32 debug devtools for timeouts
 [browser_rules_selector-highlighter-on-navigate.js]
 [browser_rules_selector-highlighter_01.js]
 [browser_rules_selector-highlighter_02.js]
 [browser_rules_selector-highlighter_03.js]
 [browser_rules_selector-highlighter_04.js]
 [browser_rules_selector-highlighter_05.js]
 [browser_rules_selector_highlight.js]
deleted file mode 100644
--- a/devtools/client/inspector/rules/test/browser_rules_inactive_css_flexbox.js
+++ /dev/null
@@ -1,170 +0,0 @@
-/* vim: set ft=javascript ts=2 et sw=2 tw=80: */
-/* Any copyright is dedicated to the Public Domain.
- http://creativecommons.org/publicdomain/zero/1.0/ */
-
-"use strict";
-
-// Test inactive flex properties.
-
-const TEST_URI = `
-<head>
-  <style>
-    #container {
-      width: 200px;
-      height: 100px;
-      border: 1px solid #000;
-      align-content: space-between;
-      order: 1;
-    }
-
-    .flex-item {
-      flex-basis: auto;
-      flex-grow: 1;
-      flex-shrink: 1;
-      flex-direction: row;
-    }
-
-    #self-aligned {
-      align-self: stretch;
-    }
-  </style>
-</head>
-<body>
-    <h1>browser_rules_inactive_css_flexbox.js</h1>
-    <div id="container" style="display:flex">
-      <div class="flex-item item-1" style="order:1">1</div>
-      <div class="flex-item item-2" style="order:2">2</div>
-      <div class="flex-item item-3" style="order:3">3</div>
-    </div>
-    <div id="self-aligned"></div>
-</body>`;
-
-const BEFORE = [
-  {
-    selector: "#self-aligned",
-    inactiveDeclarations: [
-      {
-        l10n: "rule.inactive.css.not.grid.or.flex.item",
-        declaration: {
-          "align-self": "stretch",
-        },
-        ruleIndex: 1,
-      },
-    ],
-  },
-  {
-    selector: ".item-2",
-    activeDeclarations: [
-      {
-        declarations: {
-          "order": "2",
-        },
-        ruleIndex: 0,
-      },
-      {
-        declarations: {
-          "flex-basis": "auto",
-          "flex-grow": "1",
-          "flex-shrink": "1",
-        },
-        ruleIndex: 1,
-      },
-    ],
-    inactiveDeclarations: [
-      {
-        l10n: "rule.inactive.css.not.flex.container",
-        declaration: {
-          "flex-direction": "row",
-        },
-        ruleIndex: 1,
-      },
-    ],
-  },
-  {
-    selector: "#container",
-    activeDeclarations: [
-      {
-        declarations: {
-          "display": "flex",
-        },
-        ruleIndex: 0,
-      },
-      {
-        declarations: {
-          width: "200px",
-          height: "100px",
-          border: "1px solid #000",
-          "align-content": "space-between",
-        },
-        ruleIndex: 1,
-      },
-    ],
-    inactiveDeclarations: [
-      {
-        l10n: "rule.inactive.css.not.flex.item",
-        declaration: {
-          "order": "1",
-        },
-        ruleIndex: 1,
-      },
-    ],
-    waitFor: "inspector-updated",
-  },
-];
-
-const AFTER = [
-  {
-    selector: ".item-2",
-    inactiveDeclarations: [
-      {
-        l10n: "rule.inactive.css.not.flex.item",
-        declaration: {
-          "order": "2",
-        },
-        ruleIndex: 0,
-      },
-      {
-        l10n: "rule.inactive.css.not.flex.item",
-        declaration: {
-          "flex-basis": "auto",
-        },
-        ruleIndex: 1,
-      },
-      {
-        l10n: "rule.inactive.css.not.flex.item",
-        declaration: {
-          "flex-grow": "1",
-        },
-        ruleIndex: 1,
-      },
-      {
-        l10n: "rule.inactive.css.not.flex.item",
-        declaration: {
-          "flex-shrink": "1",
-        },
-        ruleIndex: 1,
-      },
-      {
-        l10n: "rule.inactive.css.not.flex.container",
-        declaration: {
-          "flex-direction": "row",
-        },
-        ruleIndex: 1,
-      },
-    ],
-  },
-];
-
-add_task(async function() {
-  await addTab("data:text/html;charset=utf-8," + encodeURIComponent(TEST_URI));
-  const {inspector, view} = await openRuleView();
-
-  await runInactiveCSSTests(view, inspector, BEFORE);
-
-  // Toggle `display:flex` to disabled.
-  await toggleDeclaration(inspector, view, 0, {
-    display: "flex",
-  });
-  await view.once("ruleview-refreshed");
-  await runInactiveCSSTests(view, inspector, AFTER);
-});
deleted file mode 100644
--- a/devtools/client/inspector/rules/test/browser_rules_inactive_css_grid.js
+++ /dev/null
@@ -1,170 +0,0 @@
-/* vim: set ft=javascript ts=2 et sw=2 tw=80: */
-/* Any copyright is dedicated to the Public Domain.
- http://creativecommons.org/publicdomain/zero/1.0/ */
-
-"use strict";
-
-// Test inactive grid properties.
-
-const TEST_URI = `
-<head>
-  <style>
-    #container {
-      width: 200px;
-      height: 100px;
-      border: 1px solid #000;
-      column-gap: 10px;
-      row-gap: 10px;
-      align-self: start;
-    }
-
-    .item-1 {
-      grid-column-start: 1;
-      grid-column-end: 3;
-      grid-row-start: 1;
-      grid-row-end: auto;
-      flex-direction: row
-    }
-
-    #self-aligned {
-      align-self: stretch;
-    }
-  </style>
-</head>
-<body>
-    <h1>browser_rules_inactive_css_grid.js</h1>
-    <div id="container" style="display:grid">
-      <div class="grid-item item-1">1</div>
-      <div class="grid-item item-2">2</div>
-      <div class="grid-item item-3">3</div>
-      <div class="grid-item item-4">4</div>
-    </div>
-    <div id="self-aligned"></div>
-</body>`;
-
-const BEFORE = [
-  {
-    selector: "#self-aligned",
-    inactiveDeclarations: [
-      {
-        l10n: "rule.inactive.css.not.grid.or.flex.item",
-        declaration: {
-          "align-self": "stretch",
-        },
-        ruleIndex: 1,
-      },
-    ],
-  },
-  {
-    selector: ".item-1",
-    activeDeclarations: [
-      {
-        declarations: {
-          "grid-column-start": "1",
-          "grid-column-end": "3",
-          "grid-row-start": "1",
-          "grid-row-end": "auto",
-        },
-        ruleIndex: 1,
-      },
-    ],
-    inactiveDeclarations: [
-      {
-        l10n: "rule.inactive.css.not.flex.container",
-        declaration: {
-          "flex-direction": "row",
-        },
-        ruleIndex: 1,
-      },
-    ],
-  },
-  {
-    selector: "#container",
-    activeDeclarations: [
-      {
-        declarations: {
-          display: "grid",
-        },
-        ruleIndex: 0,
-      },
-      {
-        declarations: {
-          width: "200px",
-          height: "100px",
-          border: "1px solid #000",
-          "column-gap": "10px",
-          "row-gap": "10px",
-        },
-        ruleIndex: 1,
-      },
-    ],
-    inactiveDeclarations: [
-      {
-        l10n: "rule.inactive.css.not.grid.or.flex.item",
-        declaration: {
-          "align-self": "start",
-        },
-        ruleIndex: 1,
-      },
-    ],
-    waitFor: "inspector-updated",
-  },
-];
-
-const AFTER = [
-  {
-    activeDeclarations: [
-      {
-        declarations: {
-          display: "grid",
-        },
-        ruleIndex: 0,
-      },
-      {
-        declarations: {
-          width: "200px",
-          height: "100px",
-          border: "1px solid #000",
-        },
-        ruleIndex: 1,
-      },
-    ],
-    inactiveDeclarations: [
-      {
-        l10n: "rule.inactive.css.not.grid.container",
-        declaration: {
-          "column-gap": "10px",
-        },
-        ruleIndex: 1,
-      },
-      {
-        l10n: "rule.inactive.css.not.grid.container",
-        declaration: {
-          "row-gap": "10px",
-        },
-        ruleIndex: 1,
-      },
-      {
-        l10n: "rule.inactive.css.not.grid.or.flex.item",
-        declaration: {
-          "align-self": "start",
-        },
-        ruleIndex: 1,
-      },
-    ],
-  },
-];
-
-add_task(async function() {
-  await addTab("data:text/html;charset=utf-8," + encodeURIComponent(TEST_URI));
-  const {inspector, view} = await openRuleView();
-
-  await runInactiveCSSTests(view, inspector, BEFORE);
-
-  // Toggle `display:grid` to disabled.
-  await toggleDeclaration(inspector, view, 0, {
-    display: "grid",
-  });
-  await view.once("ruleview-refreshed");
-  await runInactiveCSSTests(view, inspector, AFTER);
-});
--- a/devtools/client/inspector/rules/test/head.js
+++ b/devtools/client/inspector/rules/test/head.js
@@ -563,17 +563,17 @@ async function toggleClassPanelCheckBox(
   const onMutation = view.inspector.once("markupmutation");
   checkBox.click();
   info("Waiting for a markupmutation as a result of toggling this class");
   await onMutation;
 }
 
 /**
  * Verify the content of the class-panel.
- * @param {CssRuleView} view The rule-view instance
+ * @param {CssRuleView} view The rule-view isntance
  * @param {Array} classes The list of expected classes. Each item in this array is an
  * object with the following properties: {name: {String}, state: {Boolean}}
  */
 function checkClassPanelContent(view, classes) {
   const checkBoxNodeList = view.classPanel.querySelectorAll("[type=checkbox]");
   is(checkBoxNodeList.length, classes.length,
      "The panel contains the expected number of checkboxes");
 
@@ -601,209 +601,8 @@ async function openEyedropper(view, swat
 
   const dropperButton = tooltip.container.querySelector("#eyedropper-button");
 
   info("Click on the eyedropper icon");
   const onOpened = tooltip.once("eyedropper-opened");
   dropperButton.click();
   await onOpened;
 }
-
-/**
- * Gets a set of declarations for a rule index.
- *
- * @param {ruleView} view
- *        The rule-view instance.
- * @param {Number} ruleIndex
- *        The index we expect the rule to have in the rule-view.
- *
- * @returns A map containing stringified property declarations e.g.
- *          [
- *            {
- *              "color:red":
- *                {
- *                  propertyName: "color",
- *                  propertyValue: "red",
- *                  warnings: "This won't work",
- *                  used: true,
- *                }
- *            },
- *            ...
- *          ]
- */
-function getPropertiesForRuleIndex(view, ruleIndex) {
-  const declaration = new Map();
-  const ruleEditor = getRuleViewRuleEditor(view, ruleIndex);
-
-  for (const currProp of ruleEditor.rule.textProps) {
-    const icon = currProp.editor.unusedState;
-
-    declaration.set(`${currProp.name}:${currProp.value}`, {
-      propertyName: currProp.name,
-      propertyValue: currProp.value,
-      warnings: icon.title ? icon.title.split("\n") : [],
-      used: !currProp.editor.element.classList.contains("unused"),
-    });
-  }
-
-  return declaration;
-}
-
-/**
- * Toggle a declaration disabled or enabled.
- *
- * @param {InspectorPanel} inspector
- *        The instance of InspectorPanel currently loaded in the toolbox.
- * @param {ruleView} view
- *        The rule-view instance
- * @param {Number} ruleIndex
- *        The index of the CSS rule where we can find the declaration to be
- *        toggled.
- * @param {Object} declaration
- *        An object representing the declaration e.g. { color: "red" }.
- */
-async function toggleDeclaration(inspector, view, ruleIndex, declaration) {
-  const ruleEditor = getRuleViewRuleEditor(view, ruleIndex);
-  const [[ name, value ]] = Object.entries(declaration);
-
-  let textProp = null;
-  for (const currProp of ruleEditor.rule.textProps) {
-    if (currProp.name === name && currProp.value === value) {
-      textProp = currProp;
-      break;
-    }
-  }
-
-  const dec = `${name}:${value}`;
-  ok(textProp, `Declaration "${dec}" found`);
-
-  const newStatus = textProp.enabled ? "disabled" : "enabled";
-  info(`Toggling declaration "${dec}" of rule ${ruleIndex} to ${newStatus}`);
-
-  await togglePropStatus(view, textProp);
-}
-
-/**
- * Check that a declaration is marked inactive and that it has the expected
- * warning.
- *
- * @param {ruleView} view
- *        The rule-view instance.
- * @param {Number} ruleIndex
- *        The index we expect the rule to have in the rule-view.
- * @param {Object} declaration
- *        An object representing the declaration e.g. { color: "red" }.
- * @param {String} warningL10nString
- *        l10n string representing an expected warning.
- */
-function checkDeclarationIsInactive(view, ruleIndex, declaration, warningL10nString) {
-  const declarations = getPropertiesForRuleIndex(view, ruleIndex);
-  const [[ name, value ]] = Object.entries(declaration);
-  const dec = `${name}:${value}`;
-  const { used, warnings } = declarations.get(dec);
-
-  ok(!used, `"${dec}" is inactive`);
-  is(warnings.length, 1, `"${dec}" has a warning`);
-
-  const warning = INSPECTOR_L10N.getFormatStr(warningL10nString, name);
-  is(warnings[0], warning, `The warning on "${dec}" is correct`);
-}
-
-/**
- * Check that a declaration is marked active.
- *
- * @param {ruleView} view
- *        The rule-view instance.
- * @param {Number} ruleIndex
- *        The index we expect the rule to have in the rule-view.
- * @param {Object} declaration
- *        An object representing the declaration e.g. { color: "red" }.
- */
-function checkDeclarationIsActive(view, ruleIndex, declaration) {
-  const declarations = getPropertiesForRuleIndex(view, ruleIndex);
-  const [[ name, value ]] = Object.entries(declaration);
-  const dec = `${name}:${value}`;
-  const { used, warnings } = declarations.get(dec);
-
-  ok(used, `${dec} is active`);
-  is(warnings.length, 0, `${dec} has no warnings`);
-}
-
-/**
- * Inactive CSS test runner.
- *
- * @param {ruleView} view
- *        The rule-view instance.
- * @param {InspectorPanel} inspector
- *        The instance of InspectorPanel currently loaded in the toolbox.
- * @param {Array} tests
- *        An array of test object for this method to consume e.g.
- *          [
- *            {
- *              selector: "#flex-item",
- *              activeDeclarations: [
- *                {
- *                  declarations: {
- *                    "order": "2",
- *                  },
- *                  ruleIndex: 0,
- *                },
- *                {
- *                  declarations: {
- *                    "flex-basis": "auto",
- *                    "flex-grow": "1",
- *                    "flex-shrink": "1",
- *                  },
- *                  ruleIndex: 1,
- *                },
- *              ],
- *              inactiveDeclarations: [
- *                {
- *                  l10n: "rule.inactive.css.not.flex.container",
- *                  declaration: {
- *                    "flex-direction": "row",
- *                  },
- *                  ruleIndex: 1,
- *                },
- *              ],
- *              waitFor: "markupmutation",
- *            },
- *            ...
- *          ]
- */
-async function runInactiveCSSTests(view, inspector, tests) {
-  for (const test of tests) {
-    let event = null;
-
-    if (test.waitFor) {
-      event = inspector.once(test.waitFor);
-    }
-
-    if (test.selector) {
-      await selectNode(test.selector, inspector);
-    }
-
-    if (test.waitFor) {
-      await event;
-    }
-
-    if (test.activeDeclarations) {
-      // Check whether declarations are marked as used.
-      for (const activeDeclarations of test.activeDeclarations) {
-        for (const [name, value] of Object.entries(activeDeclarations.declarations)) {
-          checkDeclarationIsActive(view, activeDeclarations.ruleIndex, {
-            [name]: value,
-          });
-        }
-      }
-    }
-
-    if (test.inactiveDeclarations) {
-      for (const inactiveDeclaration of test.inactiveDeclarations) {
-        // Check that declaration is unused and has a warning.
-        checkDeclarationIsInactive(view,
-                                   inactiveDeclaration.ruleIndex,
-                                   inactiveDeclaration.declaration,
-                                   inactiveDeclaration.l10n);
-      }
-    }
-  }
-}
--- a/devtools/client/inspector/rules/views/rule-editor.js
+++ b/devtools/client/inspector/rules/views/rule-editor.js
@@ -696,17 +696,17 @@ RuleEditor.prototype = {
       if (newRuleIndex === -1) {
         newRuleIndex = oldIndex;
       }
 
       // Remove the old rule and insert the new rule.
       rules.splice(oldIndex, 1);
       rules.splice(newRuleIndex, 0, newRule);
       elementStyle._changed();
-      elementStyle.onRuleUpdated();
+      elementStyle.markOverriddenAll();
 
       // We install the new editor in place of the old -- you might
       // think we would replicate the list-modification logic above,
       // but that is complicated due to the way the UI installs
       // pseudo-element rules and the like.
       this.element.parentNode.replaceChild(editor.element, this.element);
 
       // Remove highlight for modified selector
--- a/devtools/client/inspector/rules/views/text-property-editor.js
+++ b/devtools/client/inspector/rules/views/text-property-editor.js
@@ -177,21 +177,16 @@ TextPropertyEditor.prototype = {
     appendText(this.valueContainer, ";");
 
     this.warning = createChild(this.container, "div", {
       class: "ruleview-warning",
       hidden: "",
       title: l10n("rule.warning.title"),
     });
 
-    this.unusedState = createChild(this.container, "div", {
-      class: "ruleview-unused-warning",
-      hidden: "",
-    });
-
     // Filter button that filters for the current property name and is
     // displayed when the property is overridden by another rule.
     this.filterProperty = createChild(this.container, "div", {
       class: "ruleview-overridden-rule-filter",
       hidden: "",
       title: l10n("rule.filterProperty.title"),
     });
 
@@ -596,18 +591,18 @@ TextPropertyEditor.prototype = {
     // - all of the computed properties have defined values. In case the current property
     //   value contains CSS variables, then the computed properties will be missing and we
     //   want to avoid showing them.
     return this.prop.computed.some(c => c.name !== this.prop.name) &&
            !this.prop.computed.every(c => !c.value);
   },
 
   /**
-   * Update the visibility of the enable checkbox, the warning indicator, the used
-   * indicator and the filter property, as well as the overridden state of the property.
+   * Update the visibility of the enable checkbox, the warning indicator and
+   * the filter property, as well as the overridden state of the property.
    */
   updatePropertyState: function() {
     if (this.prop.enabled) {
       this.enable.style.removeProperty("visibility");
       this.enable.setAttribute("checked", "");
     } else {
       this.enable.style.visibility = "visible";
       this.enable.removeAttribute("checked");
@@ -628,27 +623,16 @@ TextPropertyEditor.prototype = {
 
     if (!this.editing &&
         (this.prop.overridden || !this.prop.enabled ||
          !this.prop.isKnownProperty)) {
       this.element.classList.add("ruleview-overridden");
     } else {
       this.element.classList.remove("ruleview-overridden");
     }
-
-    const { used, reasons } = this.prop.isUsed();
-
-    if (this.editing || this.prop.overridden || !this.prop.enabled || used) {
-      this.element.classList.remove("unused");
-      this.unusedState.hidden = true;
-    } else {
-      this.element.classList.add("unused");
-      this.unusedState.title = reasons.join("\n");
-      this.unusedState.hidden = false;
-    }
   },
 
   /**
    * Update the indicator for computed styles. The computed styles themselves
    * are populated on demand, when they become visible.
    */
   _updateComputed: function() {
     this.computed.innerHTML = "";
--- a/devtools/client/inspector/shared/test/browser.ini
+++ b/devtools/client/inspector/shared/test/browser.ini
@@ -17,20 +17,20 @@ support-files =
   !/devtools/client/inspector/test/shared-head.js
   !/devtools/client/shared/test/shared-head.js
   !/devtools/client/shared/test/telemetry-test-helpers.js
   !/devtools/client/shared/test/test-actor.js
   !/devtools/client/shared/test/test-actor-registry.js
 
 [browser_styleinspector_context-menu-copy-color_01.js]
 [browser_styleinspector_context-menu-copy-color_02.js]
-subsuite = clipboard
+tags = clipboard
 skip-if = (os == 'linux' && bits == 32 && debug) # bug 1328915, disable linux32 debug devtools for timeouts
 [browser_styleinspector_context-menu-copy-urls.js]
-subsuite = clipboard
+tags = clipboard
 skip-if = (os == 'linux' && bits == 32 && debug) # bug 1328915, disable linux32 debug devtools for timeouts
 [browser_styleinspector_csslogic-content-stylesheets.js]
 skip-if = e10s && debug # Bug 1250058 (docshell leak when opening 2 toolboxes)
 [browser_styleinspector_output-parser.js]
 [browser_styleinspector_refresh_when_active.js]
 [browser_styleinspector_refresh_when_style_changes.js]
 [browser_styleinspector_tooltip-background-image.js]
 [browser_styleinspector_tooltip-closes-on-new-selection.js]
--- a/devtools/client/inspector/test/browser.ini
+++ b/devtools/client/inspector/test/browser.ini
@@ -93,17 +93,17 @@ skip-if = (os == 'win' && (debug||asan))
 [browser_inspector_highlighter-cssshape_06-translate.js]
 [browser_inspector_highlighter-cssshape_07.js]
 [browser_inspector_highlighter-cssshape_iframe_01.js]
 skip-if = (verify && debug)
 [browser_inspector_highlighter-csstransform_01.js]
 [browser_inspector_highlighter-csstransform_02.js]
 [browser_inspector_highlighter-embed.js]
 [browser_inspector_highlighter-eyedropper-clipboard.js]
-subsuite = clipboard
+tags = clipboard
 skip-if = (os == 'linux' && bits == 32 && debug) # bug 1328915, disable linux32 debug devtools for timeouts
 [browser_inspector_highlighter-eyedropper-csp.js]
 [browser_inspector_highlighter-eyedropper-events.js]
 skip-if = os == 'win' # bug 1413442
 [browser_inspector_highlighter-eyedropper-image.js]
 [browser_inspector_highlighter-eyedropper-label.js]
 [browser_inspector_highlighter-eyedropper-show-hide.js]
 [browser_inspector_highlighter-eyedropper-xul.js]
@@ -142,27 +142,27 @@ skip-if = (os == 'win' && !debug) # Bug 
 [browser_inspector_infobar_04.js]
 [browser_inspector_infobar_textnode.js]
 [browser_inspector_initialization.js]
 skip-if = (e10s && debug) # Bug 1250058 - Docshell leak on debug e10s
 [browser_inspector_inspect-object-element.js]
 [browser_inspector_inspect_node_contextmenu.js]
 [browser_inspector_invalidate.js]
 [browser_inspector_keyboard-shortcuts-copy-outerhtml.js]
-subsuite = clipboard
+tags = clipboard
 skip-if = (os == 'linux' && bits == 32 && debug) # bug 1328915, disable linux32 debug devtools for timeouts
 [browser_inspector_keyboard-shortcuts.js]
 [browser_inspector_menu-01-sensitivity.js]
-subsuite = clipboard
+tags = clipboard
 skip-if = (os == 'linux' && bits == 32 && debug) || (os == "win" && processor == "aarch64") # bug 1328915, disable linux32 debug devtools for timeouts, aarch64 due to 1531598
 [browser_inspector_menu-03-paste-items.js]
-subsuite = clipboard
+tags = clipboard
 skip-if = (os == 'linux' && bits == 32 && debug) # bug 1328915, disable linux32 debug devtools for timeouts
 [browser_inspector_menu-03-paste-items-svg.js]
-subsuite = clipboard
+tags = clipboard
 skip-if = (os == 'linux' && bits == 32 && debug) # bug 1328915, disable linux32 debug devtools for timeouts
 [browser_inspector_menu-04-use-in-console.js]
 [browser_inspector_menu-05-attribute-items.js]
 skip-if = (os == 'win' && processor == 'aarch64') # bug 1533492
 [browser_inspector_menu-06-other.js]
 [browser_inspector_navigation.js]
 [browser_inspector_navigate_to_errors.js]
 [browser_inspector_open_on_neterror.js]
@@ -184,17 +184,17 @@ skip-if = (os == 'win' && processor == '
 [browser_inspector_search-03.js]
 [browser_inspector_search-04.js]
 [browser_inspector_search-05.js]
 [browser_inspector_search-06.js]
 [browser_inspector_search-07.js]
 [browser_inspector_search-08.js]
 [browser_inspector_search-clear.js]
 [browser_inspector_search-filter_context-menu.js]
-subsuite = clipboard
+tags = clipboard
 skip-if = (os == 'linux' && bits == 32 && debug) # bug 1328915, disable linux32 debug devtools for timeouts
 [browser_inspector_search_keyboard_trap.js]
 [browser_inspector_search-label.js]
 [browser_inspector_search-reserved.js]
 [browser_inspector_search-selection.js]
 [browser_inspector_search-sidebar.js]
 [browser_inspector_search-suggests-ids-and-classes.js]
 [browser_inspector_select-docshell.js]
--- a/devtools/client/inspector/test/head.js
+++ b/devtools/client/inspector/test/head.js
@@ -770,30 +770,30 @@ async function assertTooltipShownOnHover
  * @param {CssRuleView|ComputedView|...} view
  *        The instance of an inspector panel
  * @param {DOMElement} target
  *        The DOM Element on which a tooltip should appear
  *
  * @return a promise that resolves with the tooltip object
  */
 async function assertShowPreviewTooltip(view, target) {
-  const name = "previewTooltip";
-
-  // Get the tooltip. If it does not exist one will be created.
-  const tooltip = view.tooltips.getTooltip(name);
-  ok(tooltip, `Tooltip '${name}' has been instantiated`);
-
-  const shown = tooltip.once("shown");
   const mouseEvent = new target.ownerDocument.defaultView.MouseEvent("mousemove", {
     bubbles: true,
   });
   target.dispatchEvent(mouseEvent);
 
-  info("Waiting for tooltip to be shown");
-  await shown;
+  const name = "previewTooltip";
+  ok(view.tooltips._instances.has(name),
+    `Tooltip '${name}' has been instantiated`);
+  const tooltip = view.tooltips.getTooltip(name);
+
+  if (!tooltip.isVisible()) {
+    info("Waiting for tooltip to be shown");
+    await tooltip.once("shown");
+  }
 
   ok(tooltip.isVisible(), `The tooltip '${name}' is visible`);
 
   return tooltip;
 }
 
 /**
  * Given a `tooltip` instance, fake a mouse event on `target` DOM element
--- a/devtools/client/jar.mn
+++ b/devtools/client/jar.mn
@@ -92,17 +92,16 @@ devtools.jar:
     skin/images/copy.svg (themes/images/copy.svg)
     skin/images/animation-fast-track.svg (themes/images/animation-fast-track.svg)
     skin/images/performance-details-waterfall.svg (themes/images/performance-details-waterfall.svg)
     skin/images/performance-details-call-tree.svg (themes/images/performance-details-call-tree.svg)
     skin/images/performance-details-flamegraph.svg (themes/images/performance-details-flamegraph.svg)
     skin/breadcrumbs.css (themes/breadcrumbs.css)
     skin/chart.css (themes/chart.css)
     skin/widgets.css (themes/widgets.css)
-    skin/images/alerticon-unused.svg (themes/images/alerticon-unused.svg)
     skin/rules.css (themes/rules.css)
     skin/images/command-paintflashing.svg (themes/images/command-paintflashing.svg)
     skin/images/command-screenshot.svg (themes/images/command-screenshot.svg)
     skin/images/command-responsivemode.svg (themes/images/command-responsivemode.svg)
     skin/images/command-replay.svg (themes/images/command-replay.svg)
     skin/images/command-pick.svg (themes/images/command-pick.svg)
     skin/images/command-pick-accessibility.svg (themes/images/command-pick-accessibility.svg)
     skin/images/command-frames.svg (themes/images/command-frames.svg)
--- a/devtools/client/jsonview/test/browser.ini
+++ b/devtools/client/jsonview/test/browser.ini
@@ -25,23 +25,23 @@ support-files =
 
 [browser_json_refresh.js]
 [browser_jsonview_bug_1380828.js]
 [browser_jsonview_chunked_json.js]
 support-files =
   chunked_json.sjs
 [browser_jsonview_content_type.js]
 [browser_jsonview_copy_headers.js]
-subsuite = clipboard
+tags = clipboard
 skip-if = (os == 'linux' && bits == 32 && debug) # bug 1328915, disable linux32 debug devtools for timeouts
 [browser_jsonview_copy_json.js]
-subsuite = clipboard
+tags = clipboard
 skip-if = (os == 'linux' && bits == 32 && debug) # bug 1328915, disable linux32 debug devtools for timeouts
 [browser_jsonview_copy_rawdata.js]
-subsuite = clipboard
+tags = clipboard
 skip-if = (os == 'linux' && bits == 32 && debug) # bug 1328915, disable linux32 debug devtools for timeouts
 [browser_jsonview_csp_json.js]
 [browser_jsonview_empty_object.js]
 [browser_jsonview_encoding.js]
 [browser_jsonview_filter.js]
 [browser_jsonview_ignore_charset.js]
 [browser_jsonview_invalid_json.js]
 [browser_jsonview_manifest.js]
--- a/devtools/client/locales/en-US/inspector.properties
+++ b/devtools/client/locales/en-US/inspector.properties
@@ -483,38 +483,8 @@ markupView.scrollableBadge.label=scroll
 
 # LOCALIZATION NOTE (markupView.scrollableBadge.tooltip): This is the tooltip that is displayed
 # when hovering over badges next to scrollable elements in the inspector.
 markupView.scrollableBadge.tooltip=This element has scrollable overflow.
 
 # LOCALIZATION NOTE (rulePreviewTooltip.noAssociatedRule): This is the text displayed inside
 # the RulePreviewTooltip when a rule cannot be found for a CSS property declaration.
 rulePreviewTooltip.noAssociatedRule=No associated rule
-
-# LOCALIZATION NOTE (rule.inactive.css.not.flex.container): These properties
-# contain the text displayed inside the Rule View’s Inactive CSS Tooltip when a
-# property is not active. %S will be replaced with a property name.
-rule.inactive.css.not.flex.container=“%S” has no effect on this element since it’s not a flex container (try adding “display:flex” or “display:inline-flex”)
-
-# LOCALIZATION NOTE (rule.inactive.css.not.flex.item): These properties
-# contain the text displayed inside the Rule View’s Inactive CSS Tooltip when a
-# property is not active. %S will be replaced with a property name.
-rule.inactive.css.not.flex.item=“%S” has no effect on this element since it’s not a flex item (try adding “display:flex” or “display:inline-flex” to the item’s parent)
-
-# LOCALIZATION NOTE (rule.inactive.css.not.grid.container): These properties
-# contain the text displayed inside the Rule View’s Inactive CSS Tooltip when a
-# property is not active. %S will be replaced with a property name.
-rule.inactive.css.not.grid.container=“%S” has no effect on this element since it’s not a grid container (try adding “display:grid” or “display:inline-grid”)
-
-# LOCALIZATION NOTE (rule.inactive.css.not.grid.item): These properties
-# contain the text displayed inside the Rule View’s Inactive CSS Tooltip when a
-# property is not active. %S will be replaced with a property name.
-rule.inactive.css.not.grid.item=“%S” has no effect on this element since it’s not a grid item (try adding “display:grid” or “display:inline-grid” to the item’s parent)
-
-# LOCALIZATION NOTE (rule.inactive.css.not.grid.or.flex.item): These properties
-# contain the text displayed inside the Rule View’s Inactive CSS Tooltip when a
-# property is not active. %S will be replaced with a property name.
-rule.inactive.css.not.grid.or.flex.item=“%S” has no effect on this element since it’s not a grid or flex item (try adding “display:grid”, “display:flex”, “display:inline-grid” or “display:inline-flex” to the item’s parent)
-
-# LOCALIZATION NOTE (rule.inactive.css.not.grid.or.flex.container): These properties
-# contain the text displayed inside the Rule View’s Inactive CSS Tooltip when a
-# property is not active. %S will be replaced with a property name.
-rule.inactive.css.not.grid.or.flex.container=“%S” has no effect on this element since it’s neither a flex container nor a grid container (try adding “display:grid” or “display:flex”)
--- a/devtools/client/netmonitor/src/har/test/browser.ini
+++ b/devtools/client/netmonitor/src/har/test/browser.ini
@@ -1,11 +1,11 @@
 [DEFAULT]
-tags = devtools
-subsuite = clipboard
+tags = devtools clipboard
+subsuite = devtools
 skip-if = (os == 'linux' && bits == 32 && debug) # bug 1328915, disable linux32 debug devtools for timeouts
 support-files =
   head.js
   html_har_import-test-page.html
   html_har_post-data-test-page.html
   sjs_cache-test-server.sjs
   sjs_cookies-test-server.sjs
   !/devtools/client/netmonitor/test/head.js
--- a/devtools/client/netmonitor/test/browser.ini
+++ b/devtools/client/netmonitor/test/browser.ini
@@ -94,36 +94,36 @@ skip-if = (verify && !debug && (os == 'l
 [browser_net_columns_time.js]
 [browser_net_complex-params.js]
 skip-if = (verify && !debug && (os == 'win'))
 [browser_net_content-type.js]
 skip-if = (verify && !debug && (os == 'mac'))
 [browser_net_brotli.js]
 [browser_net_curl-utils.js]
 [browser_net_copy_image_as_data_uri.js]
-subsuite = clipboard
+tags = clipboard
 [browser_net_copy_svg_image_as_data_uri.js]
-subsuite = clipboard
+tags = clipboard
 [browser_net_copy_url.js]
-subsuite = clipboard
+tags = clipboard
 [browser_net_propertiesview-copy.js]
-subsuite = clipboard
+tags = clipboard
 [browser_net_copy_params.js]
-subsuite = clipboard
+tags = clipboard
 skip-if = (verify && !debug && (os == 'mac')) # bug 1328915, disable linux32 debug devtools for timeouts
 [browser_net_copy_response.js]
-subsuite = clipboard
+tags = clipboard
 [browser_net_copy_headers.js]
-subsuite = clipboard
+tags = clipboard
 [browser_net_cookies_sorted.js]
 skip-if = (verify && debug && os == 'win')
 [browser_net_copy_as_curl.js]
-subsuite = clipboard
+tags = clipboard
 [browser_net_copy_as_fetch.js]
-subsuite = clipboard
+tags = clipboard
 [browser_net_use_as_fetch.js]
 [browser_net_cors_requests.js]
 [browser_net_cyrillic-01.js]
 [browser_net_cyrillic-02.js]
 [browser_net_frame.js]
 skip-if = (os == 'mac') || (os == 'win' && os_version == '10.0') # Bug 1479782
 [browser_net_header-docs.js]
 [browser_net_edit_resend_cancel.js]
--- a/devtools/client/preferences/devtools-client.js
+++ b/devtools/client/preferences/devtools-client.js
@@ -45,22 +45,16 @@ pref("devtools.inspector.show_pseudo_ele
 // The default size for image preview tooltips in the rule-view/computed-view/markup-view
 pref("devtools.inspector.imagePreviewTooltipSize", 300);
 // Enable user agent style inspection in rule-view
 pref("devtools.inspector.showUserAgentStyles", false);
 // Show all native anonymous content
 pref("devtools.inspector.showAllAnonymousContent", false);
 // Show user agent shadow roots
 pref("devtools.inspector.showUserAgentShadowRoots", false);
-// Enable Inactive CSS detection
-#if defined(NIGHTLY_BUILD)
-pref("devtools.inspector.inactive.css.enabled", true);
-#else
-pref("devtools.inspector.inactive.css.enabled", false);
-#endif
 // Enable the new Rules View
 pref("devtools.inspector.new-rulesview.enabled", false);
 
 // Grid highlighter preferences
 pref("devtools.gridinspector.gridOutlineMaxColumns", 50);
 pref("devtools.gridinspector.gridOutlineMaxRows", 50);
 pref("devtools.gridinspector.showGridAreas", false);
 pref("devtools.gridinspector.showGridLineNumbers", false);
--- a/devtools/client/shared/webpack/shims/test/mochitest.ini
+++ b/devtools/client/shared/webpack/shims/test/mochitest.ini
@@ -1,6 +1,7 @@
 [DEFAULT]
 support-files =
 
 [test_clipboard.html]
-subsuite = clipboard
+tags = clipboard
+subsuite = devtools
 skip-if = (os == 'linux' && bits == 32 && debug) # bug 1328915, disable linux32 debug devtools for timeouts
deleted file mode 100644
--- a/devtools/client/themes/images/alerticon-unused.svg
+++ /dev/null
@@ -1,8 +0,0 @@
-<!-- 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/. -->
-<svg xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 16 16">
-  <path stroke="context-stroke" fill="none" d="M15.5 8.5C15.5 12.36 12.36 15.5 8.5 15.5C4.63 15.5 1.5 12.36 1.5 8.5C1.5 4.64 4.63 1.5 8.5 1.5C12.36 1.5 15.5 4.64 15.5 8.5Z"/>
-  <path fill="context-fill" d="M8.98 7.47C9.52 7.47 9.96 7.91 9.96 8.45C9.96 9.42 9.96 11.33 9.96 12.29C9.96 12.83 9.52 13.27 8.98 13.27C8.59 13.27 8.4 13.27 8.01 13.27C7.47 13.27 7.03 12.83 7.03 12.29C7.03 11.33 7.03 9.42 7.03 8.45C7.03 7.91 7.47 7.47 8.01 7.47C8.4 7.47 8.59 7.47 8.98 7.47Z"/>
-  <path fill="context-fill" d="M9.96 5.36C9.96 6.16 9.3 6.81 8.49 6.81C7.69 6.81 7.03 6.16 7.03 5.36C7.03 4.57 7.69 3.92 8.49 3.92C9.3 3.92 9.96 4.57 9.96 5.36Z"/>
-</svg>
--- a/devtools/client/themes/rules.css
+++ b/devtools/client/themes/rules.css
@@ -2,41 +2,38 @@
  * 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/. */
 
 /* CSS Variables specific to this panel that aren't defined by the themes */
 :root {
   --rule-highlight-background-color: var(--theme-highlight-yellow);
   --rule-header-background-color: var(--theme-toolbar-background);
   --rule-pseudo-class-text-color: var(--yellow-70) ;
-
   /* This should be --yellow-50 but since we need an opacity of 0.4, we hard-code the
   resulting color here for now. */
   --rule-property-highlight-background-color: #FFF697;
 }
 
 :root.theme-dark {
   --rule-highlight-background-color: #521C76;
   --rule-header-background-color: #222225;
   --rule-pseudo-class-text-color: var(--yellow-50);
-
   /* This should be --yellow-50 but since we need an opacity of 0.3, we hard-code the
   resulting color here for now. */
   --rule-property-highlight-background-color: #605913;
 }
 
 /* Rule View Tabpanel */
 
 #sidebar-panel-ruleview {
   margin: 0;
   display: flex;
   flex-direction: column;
   width: 100%;
   height: 100%;
-
   /* Override the min-width from .inspector-tabpanel, as the rule panel can support small
      widths */
   min-width: 100px;
 }
 
 /* Rule View Toolbar */
 
 #ruleview-toolbar-container {
@@ -45,17 +42,17 @@
   padding: 0;
 }
 
 #ruleview-toolbar {
   display: flex;
 }
 
 #ruleview-toolbar > .devtools-searchbox:first-child {
-  padding-inline-start: 0;
+  padding-inline-start: 0px;
 }
 
 #ruleview-command-toolbar {
   display: flex;
 }
 
 .ruleview-reveal-panel {
   background: var(--rule-header-background-color);
@@ -189,18 +186,16 @@
   cursor: pointer;
 }
 
 .ruleview-computedlist,
 .ruleview-expandable-container[hidden],
 .ruleview-overridden-items[hidden],
 .ruleview-overridden-rule-filter[hidden],
 .ruleview-warning[hidden],
-.ruleview-unused-warning[hidden],
-.ruleview-used[hidden],
 .ruleview-overridden .ruleview-grid {
   display: none;
 }
 
 .ruleview-computedlist[user-open],
 .ruleview-computedlist[filter-open],
 .ruleview-overridden-items {
   display: block;
@@ -259,17 +254,17 @@
   cursor: pointer;
 }
 
 .ruleview-expandable-header:hover {
   background-color: var(--theme-toolbar-background-hover);
 }
 
 .ruleview-rule-pseudo-element {
-  padding-left: 20px;
+  padding-left:20px;
   border-left: solid 10px;
 }
 
 .ruleview-rule {
   border-bottom: 1px solid var(--theme-splitter-color);
   padding: 2px 4px;
 }
 
@@ -317,21 +312,16 @@
 .ruleview-rule.uneditable .ruleview-propertyvaluecontainer >
 .ruleview-propertyvalue,
 .ruleview-rule[uneditable=true] .ruleview-namecontainer > .ruleview-propertyname,
 .ruleview-rule[uneditable=true] .ruleview-propertyvaluecontainer >
 .ruleview-propertyvalue {
   border-bottom-color: transparent;
 }
 
-.ruleview-property.unused .ruleview-namecontainer,
-.ruleview-property.unused .ruleview-propertyvaluecontainer {
-  opacity: 0.5;
-}
-
 .ruleview-overridden-rule-filter {
   display: inline-block;
   width: 14px;
   height: 14px;
   margin-inline-start: 3px;
   background-image: url(chrome://devtools/skin/images/filter-small.svg);
   background-position: center;
   background-repeat: no-repeat;
@@ -364,41 +354,27 @@
   position: relative;
   float: left;
   left: -38px;
   box-sizing: content-box;
   border-left: 10px solid transparent;
   background-clip: content-box;
 }
 
-.ruleview-warning,
-.ruleview-unused-warning {
+.ruleview-warning {
   display: inline-block;
   width: 12px;
   height: 12px;
   margin-inline-start: 5px;
   background-image: url(chrome://devtools/skin/images/alert.svg);
   background-size: cover;
   -moz-context-properties: fill;
   fill: var(--yellow-60);
 }
 
-.ruleview-unused-warning {
-  background-image: url(chrome://devtools/skin/images/alerticon-unused.svg);
-  background-color: var(--theme-sidebar-background);
-  -moz-context-properties: fill, stroke;
-  fill: var(--theme-icon-dimmed-color);
-  stroke: var(--theme-icon-dimmed-color);
-}
-
-.ruleview-unused-warning:hover {
-  fill: var(--theme-icon-color);
-  stroke: var(--theme-icon-color);
-}
-
 .ruleview-rule:not(:hover) .ruleview-enableproperty {
   visibility: hidden;
 }
 
 .ruleview-expander {
   vertical-align: middle;
 }
 
@@ -437,21 +413,21 @@
   position: relative;
 }
 
 .ruleview-overridden-item::before,
 .ruleview-overridden-item::after {
   content: "";
   position: absolute;
   display: block;
-  border: 0 solid var(--theme-text-color-alt);
+  border: 0px solid var(--theme-text-color-alt);
 }
 
 .ruleview-overridden-item::before {
-  top: 0;
+  top: 0px;
   left: -15px;
   height: 0.8em;
   width: 10px;
   border-left-width: 0.5px;
   border-bottom-width: 0.5px;
 }
 
 .ruleview-overridden-item::after {
@@ -474,17 +450,16 @@
 .ruleview-flex,
 .ruleview-grid,
 .ruleview-shapeswatch,
 .ruleview-swatch {
   cursor: pointer;
   width: 1em;
   height: 1em;
   vertical-align: middle;
-
   /* align the swatch with its value */
   margin-top: -1px;
   margin-inline-end: 5px;
   display: inline-block;
   position: relative;
 }
 
 /* Icon swatches not using the .ruleview-swatch class (flex, grid, shape) */
--- a/devtools/client/webconsole/test/mochitest/browser.ini
+++ b/devtools/client/webconsole/test/mochitest/browser.ini
@@ -224,29 +224,29 @@ skip-if = (os == "win" && processor == "
 [browser_jsterm_hide_when_devtools_chrome_enabled_false.js]
 [browser_jsterm_history.js]
 [browser_jsterm_history_arrow_keys.js]
 [browser_jsterm_history_nav.js]
 [browser_jsterm_history_persist.js]
 [browser_jsterm_inspect.js]
 [browser_jsterm_instance_of.js]
 [browser_jsterm_middle_click_paste.js]
-subsuite = clipboard
+tags = clipboard
 [browser_jsterm_multiline.js]
 [browser_jsterm_no_input_and_tab_key_pressed.js]
 skip-if = (os == "win" && processor == "aarch64") # disabled on aarch64 due to 1531573
 [browser_jsterm_null_undefined.js]
 [browser_jsterm_popup_close_on_tab_switch.js]
 [browser_jsterm_screenshot_command_clipboard.js]
-subsuite = clipboard
+tags = clipboard
 [browser_jsterm_screenshot_command_user.js]
-subsuite = clipboard
+tags = clipboard
 [browser_jsterm_screenshot_command_file.js]
 [browser_jsterm_selfxss.js]
-subsuite = clipboard
+tags = clipboard
 [browser_jsterm_syntax_highlight_output.js]
 skip-if = (os == "win" && processor == "aarch64") # disabled on aarch64 due to 1531574
 [browser_webconsole_allow_mixedcontent_securityerrors.js]
 tags = mcb
 [browser_webconsole_batching.js]
 [browser_webconsole_block_mixedcontent_securityerrors.js]
 tags = mcb
 [browser_webconsole_cached_messages.js]
@@ -267,27 +267,27 @@ skip-if = true # Bug 1405250
 [browser_webconsole_console_group.js]
 [browser_webconsole_console_logging_workers_api.js]
 skip-if = e10s # SharedWorkers console events are not received on the current process because they could run on any process.
 [browser_webconsole_console_table.js]
 [browser_webconsole_console_timeStamp.js]
 [browser_webconsole_console_trace_distinct.js]
 [browser_webconsole_console_trace_duplicates.js]
 [browser_webconsole_context_menu_export_console_output_clipboard.js]
-subsuite = clipboard
+tags = clipboard
 [browser_webconsole_context_menu_copy_entire_message.js]
-subsuite = clipboard
+tags = clipboard
 skip-if = (os == 'linux' && bits == 32 && debug) # bug 1328915, disable linux32 debug devtools for timeouts
 [browser_webconsole_context_menu_copy_link_location.js]
-subsuite = clipboard
+tags = clipboard
 skip-if = (os == 'linux' && bits == 32 && debug) || (os == 'linux') # bug 1328915, disable linux32 debug devtools for timeouts, bug 1473120
 [browser_webconsole_context_menu_copy_message_with_framework_stacktrace.js]
-subsuite = clipboard
+tags = clipboard
 [browser_webconsole_context_menu_copy_object.js]
-subsuite = clipboard
+tags = clipboard
 [browser_webconsole_context_menu_object_in_sidebar.js]
 [browser_webconsole_context_menu_open_url.js]
 [browser_webconsole_context_menu_store_as_global.js]
 [browser_webconsole_cors_errors.js]
 [browser_webconsole_csp_ignore_reflected_xss_message.js]
 [browser_webconsole_csp_violation.js]
 [browser_webconsole_cspro.js]
 [browser_webconsole_document_focus.js]
@@ -355,19 +355,19 @@ skip-if = true  # Bug 1438979
 [browser_webconsole_object_inspector_key_sorting.js]
 [browser_webconsole_object_inspector_local_session_storage.js]
 [browser_webconsole_object_inspector_selected_text.js]
 [browser_webconsole_object_inspector_scroll.js]
 [browser_webconsole_object_inspector_while_debugging_and_inspecting.js]
 [browser_webconsole_observer_notifications.js]
 [browser_webconsole_optimized_out_vars.js]
 [browser_webconsole_output_copy.js]
-subsuite = clipboard
+tags = clipboard
 [browser_webconsole_output_copy_newlines.js]
-subsuite = clipboard
+tags = clipboard
 [browser_webconsole_output_order.js]
 [browser_webconsole_persist.js]
 [browser_webconsole_primitive_stacktrace.js]
 [browser_webconsole_reopen_closed_tab.js]
 [browser_webconsole_repeat_different_objects.js]
 [browser_webconsole_reverse_search.js]
 [browser_webconsole_reverse_search_initial_value.js]
 [browser_webconsole_reverse_search_keyboard_navigation.js]
--- a/devtools/platform/nsJSInspector.cpp
+++ b/devtools/platform/nsJSInspector.cpp
@@ -57,17 +57,17 @@ nsJSInspector::nsJSInspector()
 nsJSInspector::~nsJSInspector() {
   MOZ_ASSERT(mRequestors.Length() == 0);
   MOZ_ASSERT(mLastRequestor.isNull());
   mozilla::DropJSObjects(this);
 }
 
 NS_IMETHODIMP
 nsJSInspector::EnterNestedEventLoop(JS::Handle<JS::Value> requestor,
-                                    uint32_t *out) {
+                                    uint32_t* out) {
   nsresult rv = NS_OK;
 
   mLastRequestor = requestor;
   mRequestors.AppendElement(requestor);
   mozilla::HoldJSObjects(this);
 
   mozilla::dom::AutoNoJSAPI nojsapi;
 
@@ -83,34 +83,34 @@ nsJSInspector::EnterNestedEventLoop(JS::
     mLastRequestor = mRequestors.ElementAt(--mNestedLoopLevel);
   }
 
   *out = mNestedLoopLevel;
   return rv;
 }
 
 NS_IMETHODIMP
-nsJSInspector::ExitNestedEventLoop(uint32_t *out) {
+nsJSInspector::ExitNestedEventLoop(uint32_t* out) {
   if (mNestedLoopLevel > 0) {
     mRequestors.RemoveElementAt(--mNestedLoopLevel);
     if (mNestedLoopLevel > 0)
       mLastRequestor = mRequestors.ElementAt(mNestedLoopLevel - 1);
     else
       mLastRequestor = JS::NullValue();
   } else {
     return NS_ERROR_FAILURE;
   }
 
   *out = mNestedLoopLevel;
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
-nsJSInspector::GetEventLoopNestLevel(uint32_t *out) {
+nsJSInspector::GetEventLoopNestLevel(uint32_t* out) {
   *out = mNestedLoopLevel;
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsJSInspector::GetLastNestRequestor(JS::MutableHandle<JS::Value> out) {
   out.set(mLastRequestor);
   return NS_OK;
--- a/devtools/server/actors/styles.js
+++ b/devtools/server/actors/styles.js
@@ -16,18 +16,16 @@ const TrackChangeEmitter = require("devt
 const {pageStyleSpec, styleRuleSpec, ELEMENT_STYLE} = require("devtools/shared/specs/styles");
 
 loader.lazyRequireGetter(this, "CssLogic", "devtools/server/actors/inspector/css-logic", true);
 loader.lazyRequireGetter(this, "SharedCssLogic", "devtools/shared/inspector/css-logic");
 loader.lazyRequireGetter(this, "getDefinedGeometryProperties",
   "devtools/server/actors/highlighters/geometry-editor", true);
 loader.lazyRequireGetter(this, "isCssPropertyKnown",
   "devtools/server/actors/css-properties", true);
-loader.lazyRequireGetter(this, "inactivePropertyHelper",
-  "devtools/server/actors/utils/inactive-property-helper", true);
 loader.lazyRequireGetter(this, "parseNamedDeclarations",
   "devtools/shared/css/parsing-utils", true);
 loader.lazyRequireGetter(this, "prettifyCSS",
   "devtools/shared/inspector/css-logic", true);
 loader.lazyRequireGetter(this, "UPDATE_PRESERVING_RULES",
   "devtools/server/actors/stylesheets", true);
 loader.lazyRequireGetter(this, "UPDATE_GENERAL",
   "devtools/server/actors/stylesheets", true);
@@ -1280,28 +1278,24 @@ var StyleRuleActor = protocol.ActorClass
     // and so that we can safely determine if a declaration is valid rather than
     // have the client guess it.
     if (form.authoredText || form.cssText) {
       // authoredText may be an empty string when deleting all properties; it's ok to use.
       const cssText = (typeof form.authoredText === "string")
         ? form.authoredText
         : form.cssText;
       const declarations = parseNamedDeclarations(isCssPropertyKnown, cssText, true);
-      const el = this.pageStyle.cssLogic.viewedElement;
-      const style = this.pageStyle.cssLogic.computedStyle;
 
       // We need to grab CSS from the window, since calling supports() on the
       // one from the current global will fail due to not being an HTML global.
       const CSS = this.pageStyle.inspector.targetActor.window.CSS;
       form.declarations = declarations.map(decl => {
         // Use the 1-arg CSS.supports() call so that we also accept !important
         // in the value.
         decl.isValid = CSS.supports(`${decl.name}:${decl.value}`);
-        decl.isUsed = inactivePropertyHelper.isPropertyUsed(
-          el, style, this.rawRule, decl.name);
         // Check property name. All valid CSS properties support "initial" as a value.
         decl.isNameValid = CSS.supports(decl.name, "initial");
         return decl;
       });
       // Cache parsed declarations so we don't needlessly re-parse authoredText every time
       // we need need to check previous property names and values when tracking changes.
       this._declarations = declarations;
     }
deleted file mode 100644
--- a/devtools/server/actors/utils/inactive-property-helper.js
+++ /dev/null
@@ -1,366 +0,0 @@
-/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
-/* vim: set ts=2 et sw=2 tw=80: */
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-"use strict";
-
-const Services = require("Services");
-const { LocalizationHelper } = require("devtools/shared/l10n");
-
-const PREF_UNUSED_CSS_ENABLED = "devtools.inspector.inactive.css.enabled";
-const INSPECTOR_L10N =
-  new LocalizationHelper("devtools/client/locales/inspector.properties");
-
-class InactivePropertyHelper {
-  /**
-   * A list of rules for when CSS properties have no effect.
-   *
-   * In certain situations, CSS properties do not have any effect. A common
-   * example is trying to set a width on an inline element like a <span>.
-   *
-   * There are so many properties in CSS that it's difficult to remember which
-   * ones do and don't apply in certain situations. Some are straight-forward
-   * like `flex-wrap` only applying to an element that has `display:flex`.
-   * Others are less trivial like setting something other than a color on a
-   * `:visited` pseudo-class.
-   *
-   * This file contains "rules" in the form of objects with the following
-   * properties:
-   * {
-   *   invalidProperties (see note):
-   *     Array of CSS property names that are inactive if the rule matches.
-   *   validProperties (see note):
-   *     Array of CSS property names that are active if the rule matches.
-   *   when:
-   *     The rule itself, a JS function used to identify the conditions
-   *     indicating whether a property is valid or not.
-   *
-   *   error:
-   *     A JS function that returns a custom error message explaining why the
-   *     property is inactive in this situation. This function takes a single
-   *     argument: the property name.
-   * }
-   *
-   * NOTE: validProperties and invalidProperties are mutually exclusive.
-   *
-   * The main export is `isPropertyUsed()`, which can be used to check if a
-   * property is used or not, and why.
-   */
-  get VALIDATORS() {
-    return [
-      // Flex container property used on non-flex container.
-      {
-        invalidProperties: [
-          "flex-direction",
-          "flex-flow",
-          "flex-wrap",
-        ],
-        when: () => !this.flexContainer,
-        error: property => msg("rule.inactive.css.not.flex.container", property),
-      },
-      // Flex item property used on non-flex item.
-      {
-        invalidProperties: [
-          "flex",
-          "flex-basis",
-          "flex-grow",
-          "flex-shrink",
-          "order",
-        ],
-        when: () => !this.flexItem,
-        error: property => msg("rule.inactive.css.not.flex.item", property),
-      },
-      // Grid container property used on non-grid container.
-      {
-        invalidProperties: [
-          "grid-auto-columns",
-          "grid-auto-flow",
-          "grid-auto-rows",
-          "grid-template",
-          "grid-gap",
-          "row-gap",
-          "column-gap",
-          "justify-items",
-        ],
-        when: () => !this.gridContainer,
-        error: property => msg("rule.inactive.css.not.grid.container", property),
-      },
-      // Grid item property used on non-grid item.
-      {
-        invalidProperties: [
-          "grid-area",
-          "grid-column",
-          "grid-column-end",
-          "grid-column-start",
-          "grid-row",
-          "grid-row-end",
-          "grid-row-start",
-          "justify-self",
-        ],
-        when: () => !this.gridItem,
-        error: property => msg("rule.inactive.css.not.grid.item", property),
-      },
-      // Grid and flex item properties used on non-grid or non-flex item.
-      {
-        invalidProperties: [
-          "align-self",
-        ],
-        when: () => !this.gridItem && !this.flexItem,
-        error: property => msg("rule.inactive.css.not.grid.or.flex.item", property),
-      },
-      // Grid and flex container properties used on non-grid or non-flex container.
-      {
-        invalidProperties: [
-          "align-content",
-          "align-items",
-          "justify-content",
-        ],
-        when: () => !this.gridContainer && !this.flexContainer,
-        error: property => msg("rule.inactive.css.not.grid.or.flex.container", property),
-      },
-    ];
-  }
-
-  get unusedCssEnabled() {
-    if (!this._unusedCssEnabled) {
-      this._unusedCssEnabled = Services.prefs.getBoolPref(PREF_UNUSED_CSS_ENABLED);
-    }
-    return this._unusedCssEnabled;
-  }
-
-  /**
-   * Is this CSS property having any effect on this element?
-   *
-   * @param {DOMNode} el
-   *        The DOM element.
-   * @param {Style} elStyle
-   *        The computed style for this DOMNode.
-   * @param {DOMRule} cssRule
-   *        The CSS rule the property is defined in.
-   * @param {String} property
-   *        The CSS property name.
-   *
-   * @return {Object} object
-   * @return {Boolean} object.used
-   *         true if the property is used.
-   * @return {Array} object.reasons
-   *         A string array listing the reasons a property isn't used.
-   */
-  isPropertyUsed(el, elStyle, cssRule, property) {
-    if (!this.unusedCssEnabled) {
-      return {used: true};
-    }
-
-    const errors = [];
-
-    this.VALIDATORS.forEach(validator => {
-      // First check if this rule cares about this property.
-      let isRuleConcerned = false;
-
-      if (validator.invalidProperties) {
-        isRuleConcerned = validator.invalidProperties === "*" ||
-                          validator.invalidProperties.includes(property);
-      } else if (validator.validProperties) {
-        isRuleConcerned = !validator.validProperties.includes(property);
-      }
-
-      if (!isRuleConcerned) {
-        return;
-      }
-
-      this.select(el, elStyle, cssRule, property);
-
-      // And then run the validator, gathering the error message if the
-      // validator passes.
-      if (validator.when()) {
-        const error = validator.error(property);
-
-        if (typeof error === "string") {
-          errors.push(validator.error(property));
-        }
-      }
-    });
-
-    return {
-      used: !errors.length,
-      reasons: errors,
-    };
-  }
-
-  /**
-   * Focus on a node.
-   *
-   * @param {DOMNode} node
-   *        Node to focus on.
-   */
-  select(node, style, cssRule, property) {
-    this._node = node;
-    this._cssRule = cssRule;
-    this._property = property;
-    this._style = style;
-  }
-
-  /**
-   * Provide a public reference to node.
-   */
-  get node() {
-    return this._node;
-  }
-
-  /**
-   * Cache and provide node's computed style.
-   */
-  get style() {
-    return this._style;
-  }
-
-  /**
-   * Check if the current node's propName is set to one of the values passed in
-   * the values array.
-   *
-   * @param {String} propName
-   *        Property name to check.
-   * @param {Array} values
-   *        Values to compare against.
-   */
-  checkStyle(propName, values) {
-    return this.checkStyleForNode(this.node, propName, values);
-  }
-
-  /**
-   * Check if a node's propName is set to one of the values passed in the values
-   * array.
-   *
-   * @param {DOMNode} node
-   *        The node to check.
-   * @param {String} propName
-   *        Property name to check.
-   * @param {Array} values
-   *        Values to compare against.
-   */
-  checkStyleForNode(node, propName, values) {
-    return values.some(value => this.style[propName] === value);
-  }
-
-  /**
-   * Check if the current node is a flex container i.e. a node that has a style
-   * of `display:flex` or `display:inline-flex`.
-   */
-  get flexContainer() {
-    return this.checkStyle("display", ["flex", "inline-flex"]);
-  }
-
-  /**
-   * Check if the current node is a flex item.
-   */
-  get flexItem() {
-    return this.isFlexItem(this.node);
-  }
-
-  /**
-   * Check if the current node is a grid container i.e. a node that has a style
-   * of `display:grid` or `display:inline-grid`.
-   */
-  get gridContainer() {
-    return this.checkStyle("display", ["grid", "inline-grid"]);
-  }
-
-  /**
-   * Check if the current node is a grid item.
-   */
-  get gridItem() {
-    return this.isGridItem(this.node);
-  }
-
-  /**
-   * Check if a node is a flex item.
-   *
-   * @param {DOMNode} node
-   *        The node to check.
-   */
-  isFlexItem(node) {
-    return !!node.parentFlexElement;
-  }
-
-  /**
-   * Check if a node is a flex container.
-   *
-   * @param {DOMNode} node
-   *        The node to check.
-   */
-  isFlexContainer(node) {
-    return !!node.getAsFlexContainer();
-  }
-
-  /**
-   * Check if a node is a grid container.
-   *
-   * @param {DOMNode} node
-   *        The node to check.
-   */
-  isGridContainer(node) {
-    return !!node.getGridFragments().length > 0;
-  }
-
-  /**
-   * Check if a node is a grid item.
-   *
-   * @param {DOMNode} node
-   *        The node to check.
-   */
-  isGridItem(node) {
-    return !!this.getParentGridElement(this.node);
-  }
-
-  getParentGridElement(node) {
-    if (node.nodeType === node.ELEMENT_NODE) {
-      const display = this.style.display;
-
-      if (!display || display === "none" || display === "contents") {
-        // Doesn't generate a box, not a grid item.
-        return null;
-      }
-      const position = this.style.position;
-      if (position === "absolute" ||
-          position === "fixed" ||
-          this.style.cssFloat !== "none") {
-        // Out of flow, not a grid item.
-        return null;
-      }
-    } else if (node.nodeType !== node.TEXT_NODE) {
-      return null;
-    }
-
-    for (let p = node.flattenedTreeParentNode; p; p = p.flattenedTreeParentNode) {
-      const style = node.ownerGlobal.getComputedStyle(p);
-      const display = style.display;
-
-      if (display.includes("grid") && !!p.getGridFragments().length > 0) {
-        // It's a grid item!
-        return p;
-      }
-      if (display !== "contents") {
-        return null; // Not a grid item, for sure.
-      }
-      // display: contents, walk to the parent
-    }
-    return null;
-  }
-}
-
-/**
- * Helper function that gets localized strings.
- *
- * @param  {String} propName
- *         The property name to use. This property name must exist in the
- *         `inspector.properties` file).
- * @param  {*} values
- *         Values to be used as replacement strings.
- */
-function msg(...args) {
-  return INSPECTOR_L10N.getFormatStr(...args);
-}
-
-exports.inactivePropertyHelper = new InactivePropertyHelper();
--- a/devtools/server/actors/utils/moz.build
+++ b/devtools/server/actors/utils/moz.build
@@ -8,16 +8,15 @@ DevToolsModules(
     'accessibility.js',
     'actor-registry-utils.js',
     'actor-registry.js',
     'breakpoint-actor-map.js',
     'css-grid-utils.js',
     'dbg-source.js',
     'event-breakpoints.js',
     'event-loop.js',
-    'inactive-property-helper.js',
     'make-debugger.js',
     'shapes-utils.js',
     'stack.js',
     'TabSources.js',
     'track-change-emitter.js',
     'walker-search.js',
 )
--- a/docshell/base/nsDocShell.cpp
+++ b/docshell/base/nsDocShell.cpp
@@ -663,16 +663,26 @@ nsDocShell::GetInterface(const nsIID& aI
     return nsDocLoader::GetInterface(aIID, aSink);
   }
 
   NS_IF_ADDREF(((nsISupports*)*aSink));
   return *aSink ? NS_OK : NS_NOINTERFACE;
 }
 
 NS_IMETHODIMP
+nsDocShell::SetCancelContentJSEpoch(int32_t aEpoch) {
+  // Note: this gets called fairly early (before a pageload actually starts).
+  // We could probably defer this even longer.
+  nsCOMPtr<nsIBrowserChild> browserChild = GetBrowserChild();
+  static_cast<BrowserChild*>(browserChild.get())
+      ->SetCancelContentJSEpoch(aEpoch);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
 nsDocShell::LoadURI(nsDocShellLoadState* aLoadState) {
   MOZ_ASSERT(aLoadState, "Must have a valid load state!");