Issue #1624 - Add missing error handling and bail on null specifier.

.eslintignore

@@ -187,6 +187,28 @@ devtools/client/framework/test/code_ugly*
 devtools/server/tests/unit/babel_and_browserify_script_with_source_map.js
 devtools/server/tests/unit/setBreakpoint*
 
+# mobile/android/ exclusions
+mobile/android/tests/
+
+# Uses `#filter substitution`
+mobile/android/b2gdroid/app/b2gdroid.js
+mobile/android/app/mobile.js
+mobile/android/chrome/content/healthreport-prefs.js
+
+# Uses `#expand`
+mobile/android/chrome/content/about.js
+
+# Not much JS to lint and non-standard at that
+mobile/android/installer/
+mobile/android/locales/
+
+# Non-standard `(catch ex if ...)`
+mobile/android/chrome/content/browser.js
+mobile/android/components/Snippets.js
+
+# Bug 1178739: Ignore this file as a quick fix for "Illegal yield expression"
+mobile/android/modules/HomeProvider.jsm
+
 # services/ exclusions
 
 # Uses `#filter substitution`

.gitignore

@@ -91,6 +91,9 @@ GPATH
 # Git clone directory for updating web-platform-tests
 testing/web-platform/sync/
 
+# Android Gradle artifacts.
+mobile/android/gradle/.gradle
+
 # XCode project cruft
 embedding/ios/GoannaEmbed/GoannaEmbed.xcodeproj/project.xcworkspace/xcuserdata
 embedding/ios/GoannaEmbed/GoannaEmbed.xcodeproj/xcuserdata

CLOBBER

@@ -22,4 +22,4 @@
 # changes to stick? As of bug 928195, this shouldn't be necessary! Please
 # don't change CLOBBER for WebIDL changes any more.
 
-Clobber for NSS update
+Clobber for CSS flow-root implementation

accessible/base/Platform.h

@@ -35,10 +35,10 @@ EPlatformDisabledState PlatformDisabledState();
 void PreInit();
 #endif
 
-#if defined(MOZ_ACCESSIBILITY_ATK)
+#if defined(MOZ_ACCESSIBILITY_ATK) || defined(XP_MACOSX)
 /**
  * Is platform accessibility enabled.
- * Only used on linux with atk.
+ * Only used on linux with atk and MacOS for now.
  */
 bool ShouldA11yBeEnabled();
 #endif

accessible/base/moz.build

@@ -96,6 +96,10 @@ elif CONFIG['MOZ_WIDGET_TOOLKIT'] == 'windows':
         '/accessible/windows/ia2',
         '/accessible/windows/msaa',
     ]
+elif CONFIG['MOZ_WIDGET_TOOLKIT'] == 'cocoa':
+    LOCAL_INCLUDES += [
+        '/accessible/mac',
+    ]
 else:
     LOCAL_INCLUDES += [
         '/accessible/other',

accessible/generic/moz.build

@@ -52,6 +52,10 @@ elif CONFIG['MOZ_WIDGET_TOOLKIT'] == 'windows':
         '/accessible/windows/ia2',
         '/accessible/windows/msaa',
     ]
+elif CONFIG['MOZ_WIDGET_TOOLKIT'] == 'cocoa':
+    LOCAL_INCLUDES += [
+        '/accessible/mac',
+    ]
 else:
     LOCAL_INCLUDES += [
         '/accessible/other',

accessible/html/moz.build

@@ -32,6 +32,10 @@ elif CONFIG['MOZ_WIDGET_TOOLKIT'] == 'windows':
         '/accessible/windows/ia2',
         '/accessible/windows/msaa',
     ]
+elif CONFIG['MOZ_WIDGET_TOOLKIT'] == 'cocoa':
+    LOCAL_INCLUDES += [
+        '/accessible/mac',
+    ]
 else:
     LOCAL_INCLUDES += [
         '/accessible/other',

accessible/ipc/moz.build

@@ -19,6 +19,10 @@ else:
         LOCAL_INCLUDES += [
             '/accessible/atk',
         ]
+    elif CONFIG['MOZ_WIDGET_TOOLKIT'] == 'cocoa':
+        LOCAL_INCLUDES += [
+            '/accessible/mac',
+        ]
     else:
         LOCAL_INCLUDES += [
             '/accessible/other',

accessible/ipc/other/moz.build

@@ -28,6 +28,10 @@ if CONFIG['ACCESSIBILITY']:
         LOCAL_INCLUDES += [
             '/accessible/atk',
         ]
+    elif CONFIG['MOZ_WIDGET_TOOLKIT'] == 'cocoa':
+        LOCAL_INCLUDES += [
+            '/accessible/mac',
+        ]
     else:
         LOCAL_INCLUDES += [
             '/accessible/other',

accessible/jsat/AccessFu.jsm

@@ -64,7 +64,9 @@ this.AccessFu = { // jshint ignore:line
     if (this._enabled) {
       this._disable();
     }
-    if (Utils.win.navigator.mozSettings) {
+    if (Utils.MozBuildApp === 'mobile/android') {
+      Services.obs.removeObserver(this, 'Accessibility:Settings');
+    } else if (Utils.win.navigator.mozSettings) {
       Utils.win.navigator.mozSettings.removeObserver(
         SCREENREADER_SETTING, this.handleEvent);
     }
@@ -583,7 +585,11 @@ var Output = {
 
   get androidBridge() {
     delete this.androidBridge;
-    this.androidBridge = null;
+    if (Utils.MozBuildApp === 'mobile/android') {
+      this.androidBridge = Services.androidBridge;
+    } else {
+      this.androidBridge = null;
+    }
     return this.androidBridge;
   },
 
@@ -809,6 +815,12 @@ var Input = {
             target.blur();
           }
         }
+
+        if (Utils.MozBuildApp == 'mobile/android') {
+          // Return focus to native Android browser chrome.
+          Services.androidBridge.handleGeckoMessage(
+              { type: 'ToggleChrome:Focus' });
+        }
         break;
       case aEvent.DOM_VK_RETURN:
         if (this.editState.editing) {
@@ -825,9 +837,18 @@ var Input = {
   },
 
   moveToPoint: function moveToPoint(aRule, aX, aY) {
-    let win = Utils.win;
-    Utils.winUtils.sendMouseEvent('mousemove',
-      aX - win.mozInnerScreenX, aY - win.mozInnerScreenY, 0, 0, 0);
+    // XXX: Bug 1013408 - There is no alignment between the chrome window's
+    // viewport size and the content viewport size in Android. This makes
+    // sending mouse events beyond its bounds impossible.
+    if (Utils.MozBuildApp === 'mobile/android') {
+      let mm = Utils.getMessageManager(Utils.CurrentBrowser);
+      mm.sendAsyncMessage('AccessFu:MoveToPoint',
+        {rule: aRule, x: aX, y: aY, origin: 'top'});
+    } else {
+      let win = Utils.win;
+      Utils.winUtils.sendMouseEvent('mousemove',
+        aX - win.mozInnerScreenX, aY - win.mozInnerScreenY, 0, 0, 0);
+    }
   },
 
   moveCursor: function moveCursor(aAction, aRule, aInputType, aAdjustRange) {

accessible/jsat/Gestures.jsm

@@ -76,6 +76,8 @@ const EDGE = 0.1;
 const TIMEOUT_MULTIPLIER = 1;
 // A single pointer down/up sequence periodically precedes the tripple swipe
 // gesture on Android. This delay acounts for that.
+const IS_ANDROID = Utils.MozBuildApp === 'mobile/android' &&
+  Utils.AndroidSdkVersion >= 14;
 
 /**
  * A point object containing distance travelled data.
@@ -204,7 +206,7 @@ this.GestureTracker = { // jshint ignore:line
     if (aDetail.type !== 'pointerdown') {
       return;
     }
-    let GestureConstructor = aGesture || Tap;
+    let GestureConstructor = aGesture || (IS_ANDROID ? DoubleTap : Tap);
     this._create(GestureConstructor);
     this._update(aDetail, aTimeStamp);
   },

accessible/jsat/Presentation.jsm

@@ -680,6 +680,7 @@ this.Presentation = { // jshint ignore:line
   get presenters() {
     delete this.presenters;
     let presenterMap = {
+      'mobile/android': [VisualPresenter, AndroidPresenter],
       'b2g': [VisualPresenter, B2GPresenter],
       'browser': [VisualPresenter, B2GPresenter, AndroidPresenter]
     };

accessible/jsat/Utils.jsm

@@ -33,7 +33,9 @@ this.Utils = { // jshint ignore:line
   _buildAppMap: {
     '{3c2e2abc-06d4-11e1-ac3b-374f68613e61}': 'b2g',
     '{d1bfe7d9-c01e-4237-998b-7b5f960a4314}': 'graphene',
-    '{ec8030f7-c20a-464f-9b0e-13a3a9e97384}': 'browser'
+    '{ec8030f7-c20a-464f-9b0e-13a3a9e97384}': 'browser',
+    '{aa3c5121-dab2-40e2-81ca-7ea25febc110}': 'mobile/android',
+    '{a23983c0-fd0e-11dc-95ff-0800200c9a66}': 'mobile/xul'
   },
 
   init: function Utils_init(aWindow) {

accessible/mac/ARIAGridAccessibleWrap.h

@@ -0,0 +1,22 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:expandtab:shiftwidth=2:tabstop=2:
+ */
+/* 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/. */
+
+#ifndef MOZILLA_A11Y_ARIAGRIDACCESSIBLEWRAP_H
+#define MOZILLA_A11Y_ARIAGRIDACCESSIBLEWRAP_H
+
+#include "ARIAGridAccessible.h"
+
+namespace mozilla {
+namespace a11y {
+
+typedef class ARIAGridAccessible ARIAGridAccessibleWrap;
+typedef class ARIAGridCellAccessible ARIAGridCellAccessibleWrap;
+
+} // namespace a11y
+} // namespace mozilla
+
+#endif

accessible/mac/AccessibleWrap.h

@@ -0,0 +1,103 @@
+/* -*- Mode: Objective-C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+/* For documentation of the accessibility architecture,
+ * see http://lxr.mozilla.org/seamonkey/source/accessible/accessible-docs.html
+ */
+
+#ifndef _AccessibleWrap_H_
+#define _AccessibleWrap_H_
+
+#include <objc/objc.h>
+
+#include "Accessible.h"
+#include "States.h"
+
+#include "nsCOMPtr.h"
+
+#include "nsTArray.h"
+
+#if defined(__OBJC__)
+@class mozAccessible;
+#endif
+
+namespace mozilla {
+namespace a11y {
+
+class AccessibleWrap : public Accessible
+{
+public: // construction, destruction
+  AccessibleWrap(nsIContent* aContent, DocAccessible* aDoc);
+  virtual ~AccessibleWrap();
+
+  /**
+   * Get the native Obj-C object (mozAccessible).
+   */
+  virtual void GetNativeInterface(void** aOutAccessible) override;
+
+  /**
+   * The objective-c |Class| type that this accessible's native object
+   * should be instantied with.   used on runtime to determine the
+   * right type for this accessible's associated native object.
+   */
+  virtual Class GetNativeType ();
+
+  virtual void Shutdown () override;
+
+  virtual bool InsertChildAt(uint32_t aIdx, Accessible* aChild) override;
+  virtual bool RemoveChild(Accessible* aAccessible) override;
+
+  virtual nsresult HandleAccEvent(AccEvent* aEvent) override;
+
+protected:
+
+  /**
+   * Return true if the parent doesn't have children to expose to AT.
+   */
+  bool AncestorIsFlat();
+
+  /**
+   * Get the native object. Create it if needed.
+   */
+#if defined(__OBJC__)
+  mozAccessible* GetNativeObject();
+#else
+  id GetNativeObject();
+#endif
+
+private:
+
+  /**
+   * Our native object. Private because its creation is done lazily.
+   * Don't access it directly. Ever. Unless you are GetNativeObject() or
+   * Shutdown()
+   */
+#if defined(__OBJC__)
+  // if we are in Objective-C, we use the actual Obj-C class.
+  mozAccessible* mNativeObject;
+#else
+  id mNativeObject;
+#endif
+
+  /**
+   * We have created our native. This does not mean there is one.
+   * This can never go back to false.
+   * We need it because checking whether we need a native object cost time.
+   */
+  bool mNativeInited;
+};
+
+#if defined(__OBJC__)
+  void FireNativeEvent(mozAccessible* aNativeAcc, uint32_t aEventType);
+#else
+  void FireNativeEvent(id aNativeAcc, uint32_t aEventType);
+#endif
+
+Class GetTypeFromRole(roles::Role aRole);
+
+} // namespace a11y
+} // namespace mozilla
+
+#endif

accessible/mac/AccessibleWrap.mm

@@ -0,0 +1,256 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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 "DocAccessible.h"
+#include "nsObjCExceptions.h"
+
+#include "Accessible-inl.h"
+#include "nsAccUtils.h"
+#include "Role.h"
+
+#import "mozAccessible.h"
+#import "mozActionElements.h"
+#import "mozHTMLAccessible.h"
+#import "mozTableAccessible.h"
+#import "mozTextAccessible.h"
+
+using namespace mozilla;
+using namespace mozilla::a11y;
+
+AccessibleWrap::
+  AccessibleWrap(nsIContent* aContent, DocAccessible* aDoc) :
+  Accessible(aContent, aDoc), mNativeObject(nil),
+  mNativeInited(false)
+{
+}
+
+AccessibleWrap::~AccessibleWrap()
+{
+}
+
+mozAccessible*
+AccessibleWrap::GetNativeObject()
+{
+  NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL;
+
+  if (!mNativeInited && !mNativeObject && !IsDefunct() && !AncestorIsFlat()) {
+    uintptr_t accWrap = reinterpret_cast<uintptr_t>(this);
+    mNativeObject = [[GetNativeType() alloc] initWithAccessible:accWrap];
+  }
+
+  mNativeInited = true;
+
+  return mNativeObject;
+
+  NS_OBJC_END_TRY_ABORT_BLOCK_NIL;
+}
+
+void
+AccessibleWrap::GetNativeInterface(void** aOutInterface)
+{
+  *aOutInterface = static_cast<void*>(GetNativeObject());
+}
+
+// overridden in subclasses to create the right kind of object. by default we create a generic
+// 'mozAccessible' node.
+Class
+AccessibleWrap::GetNativeType ()
+{
+  NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL;
+
+  if (IsXULTabpanels())
+    return [mozPaneAccessible class];
+
+  if (IsTable())
+    return [mozTableAccessible class];
+
+  if (IsTableRow())
+    return [mozTableRowAccessible class];
+
+  if (IsTableCell())
+    return [mozTableCellAccessible class];
+
+  return GetTypeFromRole(Role());
+
+  NS_OBJC_END_TRY_ABORT_BLOCK_NIL;
+}
+
+// this method is very important. it is fired when an accessible object "dies". after this point
+// the object might still be around (because some 3rd party still has a ref to it), but it is
+// in fact 'dead'.
+void
+AccessibleWrap::Shutdown ()
+{
+  // this ensure we will not try to re-create the native object.
+  mNativeInited = true;
+
+  // we really intend to access the member directly.
+  if (mNativeObject) {
+    [mNativeObject expire];
+    [mNativeObject release];
+    mNativeObject = nil;
+  }
+
+  Accessible::Shutdown();
+}
+
+nsresult
+AccessibleWrap::HandleAccEvent(AccEvent* aEvent)
+{
+  NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT;
+
+  nsresult rv = Accessible::HandleAccEvent(aEvent);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (IPCAccessibilityActive()) {
+    return NS_OK;
+  }
+
+  uint32_t eventType = aEvent->GetEventType();
+
+  // ignore everything but focus-changed, value-changed, caret, selection
+  // and document load complete events for now.
+  if (eventType != nsIAccessibleEvent::EVENT_FOCUS &&
+      eventType != nsIAccessibleEvent::EVENT_VALUE_CHANGE &&
+      eventType != nsIAccessibleEvent::EVENT_TEXT_VALUE_CHANGE &&
+      eventType != nsIAccessibleEvent::EVENT_TEXT_CARET_MOVED &&
+      eventType != nsIAccessibleEvent::EVENT_TEXT_SELECTION_CHANGED &&
+      eventType != nsIAccessibleEvent::EVENT_DOCUMENT_LOAD_COMPLETE)
+    return NS_OK;
+
+  Accessible* accessible = aEvent->GetAccessible();
+  NS_ENSURE_STATE(accessible);
+
+  mozAccessible *nativeAcc = nil;
+  accessible->GetNativeInterface((void**)&nativeAcc);
+  if (!nativeAcc)
+    return NS_ERROR_FAILURE;
+
+  FireNativeEvent(nativeAcc, eventType);
+
+  return NS_OK;
+
+  NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT;
+}
+
+bool
+AccessibleWrap::InsertChildAt(uint32_t aIdx, Accessible* aAccessible)
+{
+  bool inserted = Accessible::InsertChildAt(aIdx, aAccessible);
+  if (inserted && mNativeObject)
+    [mNativeObject appendChild:aAccessible];
+
+  return inserted;
+}
+
+bool
+AccessibleWrap::RemoveChild(Accessible* aAccessible)
+{
+  bool removed = Accessible::RemoveChild(aAccessible);
+
+  if (removed && mNativeObject)
+    [mNativeObject invalidateChildren];
+
+  return removed;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// AccessibleWrap protected
+
+bool
+AccessibleWrap::AncestorIsFlat()
+{
+  // We don't create a native object if we're child of a "flat" accessible;
+  // for example, on OS X buttons shouldn't have any children, because that
+  // makes the OS confused.
+  //
+  // To maintain a scripting environment where the XPCOM accessible hierarchy
+  // look the same on all platforms, we still let the C++ objects be created
+  // though.
+
+  Accessible* parent = Parent();
+  while (parent) {
+    if (nsAccUtils::MustPrune(parent))
+      return true;
+
+    parent = parent->Parent();
+  }
+  // no parent was flat
+  return false;
+}
+
+void
+a11y::FireNativeEvent(mozAccessible* aNativeAcc, uint32_t aEventType)
+{
+  NS_OBJC_BEGIN_TRY_ABORT_BLOCK;
+
+  switch (aEventType) {
+    case nsIAccessibleEvent::EVENT_FOCUS:
+      [aNativeAcc didReceiveFocus];
+      break;
+    case nsIAccessibleEvent::EVENT_VALUE_CHANGE:
+    case nsIAccessibleEvent::EVENT_TEXT_VALUE_CHANGE:
+      [aNativeAcc valueDidChange];
+      break;
+    case nsIAccessibleEvent::EVENT_TEXT_CARET_MOVED:
+    case nsIAccessibleEvent::EVENT_TEXT_SELECTION_CHANGED:
+      [aNativeAcc selectedTextDidChange];
+      break;
+    case nsIAccessibleEvent::EVENT_DOCUMENT_LOAD_COMPLETE:
+      [aNativeAcc documentLoadComplete];
+      break;
+  }
+
+  NS_OBJC_END_TRY_ABORT_BLOCK;
+}
+
+Class
+a11y::GetTypeFromRole(roles::Role aRole)
+{
+  NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL;
+
+  switch (aRole) {
+    case roles::COMBOBOX:
+    case roles::PUSHBUTTON:
+    case roles::SPLITBUTTON:
+    case roles::TOGGLE_BUTTON:
+    {
+        return [mozButtonAccessible class];
+    }
+
+    case roles::PAGETAB:
+      return [mozButtonAccessible class];
+
+    case roles::CHECKBUTTON:
+      return [mozCheckboxAccessible class];
+
+    case roles::HEADING:
+      return [mozHeadingAccessible class];
+
+    case roles::PAGETABLIST:
+      return [mozTabsAccessible class];
+
+    case roles::ENTRY:
+    case roles::STATICTEXT:
+    case roles::CAPTION:
+    case roles::ACCEL_LABEL:
+    case roles::PASSWORD_TEXT:
+      // normal textfield (static or editable)
+      return [mozTextAccessible class];
+
+    case roles::TEXT_LEAF:
+      return [mozTextLeafAccessible class];
+
+    case roles::LINK:
+      return [mozLinkAccessible class];
+
+    default:
+      return [mozAccessible class];
+  }
+
+  return nil;
+
+  NS_OBJC_END_TRY_ABORT_BLOCK_NIL;
+}

accessible/mac/ApplicationAccessibleWrap.h

@@ -0,0 +1,22 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* vim:expandtab:shiftwidth=4:tabstop=4:
+ */
+/* 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/. */
+
+#ifndef mozilla_a11y_ApplicationAccessibleWrap_h__
+#define mozilla_a11y_ApplicationAccessibleWrap_h__
+
+#include "ApplicationAccessible.h"
+
+namespace mozilla {
+namespace a11y {
+
+typedef ApplicationAccessible ApplicationAccessibleWrap;
+
+} // namespace a11y
+} // namespace mozilla
+
+#endif
+

accessible/mac/DocAccessibleWrap.h

@@ -0,0 +1,25 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+#ifndef mozilla_a11y_DocAccessibleWrap_h__
+#define mozilla_a11y_DocAccessibleWrap_h__
+
+#include "DocAccessible.h"
+
+namespace mozilla {
+namespace a11y {
+
+class DocAccessibleWrap : public DocAccessible
+{
+public:
+  DocAccessibleWrap(nsIDocument* aDocument, nsIPresShell* aPresShell);
+  virtual ~DocAccessibleWrap();
+
+};
+
+} // namespace a11y
+} // namespace mozilla
+
+#endif

accessible/mac/DocAccessibleWrap.mm

@@ -0,0 +1,21 @@
+/* -*- Mode: C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ * 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 "DocAccessibleWrap.h"
+
+#import "mozAccessible.h"
+
+using namespace mozilla::a11y;
+
+DocAccessibleWrap::
+  DocAccessibleWrap(nsIDocument* aDocument, nsIPresShell* aPresShell) :
+  DocAccessible(aDocument, aPresShell)
+{
+}
+
+DocAccessibleWrap::~DocAccessibleWrap()
+{
+}
+

accessible/mac/HTMLTableAccessibleWrap.h

@@ -0,0 +1,24 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:expandtab:shiftwidth=2:tabstop=2:
+ */
+/* 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/. */
+
+#ifndef mozilla_a11y_HTMLTableAccessibleWrap_h__
+#define mozilla_a11y_HTMLTableAccessibleWrap_h__
+
+#include "HTMLTableAccessible.h"
+
+namespace mozilla {
+namespace a11y {
+
+typedef class HTMLTableAccessible HTMLTableAccessibleWrap;
+typedef class HTMLTableCellAccessible HTMLTableCellAccessibleWrap;
+typedef class HTMLTableHeaderCellAccessible HTMLTableHeaderCellAccessibleWrap;
+
+} // namespace a11y
+} // namespace mozilla
+
+#endif
+

accessible/mac/HyperTextAccessibleWrap.h

@@ -0,0 +1,20 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+#ifndef mozilla_a11y_HyperTextAccessibleWrap_h__
+#define mozilla_a11y_HyperTextAccessibleWrap_h__
+
+#include "HyperTextAccessible.h"
+
+namespace mozilla {
+namespace a11y {
+
+typedef class HyperTextAccessible HyperTextAccessibleWrap;
+
+} // namespace a11y
+} // namespace mozilla
+
+#endif
+

accessible/mac/ImageAccessibleWrap.h

@@ -0,0 +1,22 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:expandtab:shiftwidth=2:tabstop=2:
+ */
+/* 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/. */
+
+#ifndef mozilla_a11y_ImageAccessibleWrap_h__
+#define mozilla_a11y_ImageAccessibleWrap_h__
+
+#include "ImageAccessible.h"
+
+namespace mozilla {
+namespace a11y {
+
+typedef class ImageAccessible ImageAccessibleWrap;
+
+} // namespace a11y
+} // namespace mozilla
+
+#endif
+

accessible/mac/MacUtils.h

@@ -0,0 +1,26 @@
+/* -*- Mode: Objective-C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+#ifndef _MacUtils_H_
+#define _MacUtils_H_
+
+@class NSString;
+class nsString;
+
+namespace mozilla {
+namespace a11y {
+namespace utils {
+
+/**
+ * Get a localized string from the string bundle.
+ * Return nil if not found.
+ */
+NSString* LocalizedString(const nsString& aString);
+
+}
+}
+}
+
+#endif

accessible/mac/MacUtils.mm

@@ -0,0 +1,32 @@
+/* -*- Mode: Objective-C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+#import "MacUtils.h"
+
+#include "Accessible.h"
+
+#include "nsCocoaUtils.h"
+
+namespace mozilla {
+namespace a11y {
+namespace utils {
+
+/**
+ * Get a localized string from the a11y string bundle.
+ * Return nil if not found.
+ */
+NSString*
+LocalizedString(const nsString& aString)
+{
+  nsString text;
+
+  Accessible::TranslateString(aString, text);
+
+  return text.IsEmpty() ? nil : nsCocoaUtils::ToNSString(text);
+}
+
+}
+}
+}

accessible/mac/Platform.mm

@@ -0,0 +1,174 @@
+/* -*- Mode: Objective-C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+#import <Cocoa/Cocoa.h>
+
+#include "Platform.h"
+#include "ProxyAccessible.h"
+#include "DocAccessibleParent.h"
+#include "mozTableAccessible.h"
+
+#include "nsAppShell.h"
+
+namespace mozilla {
+namespace a11y {
+
+// Mac a11y whitelisting
+static bool sA11yShouldBeEnabled = false;
+
+bool
+ShouldA11yBeEnabled()
+{
+  EPlatformDisabledState disabledState = PlatformDisabledState();
+  return (disabledState == ePlatformIsForceEnabled) || ((disabledState == ePlatformIsEnabled) && sA11yShouldBeEnabled);
+}
+
+void
+PlatformInit()
+{
+}
+
+void
+PlatformShutdown()
+{
+}
+
+void
+ProxyCreated(ProxyAccessible* aProxy, uint32_t)
+{
+  // Pass in dummy state for now as retrieving proxy state requires IPC.
+  // Note that we can use ProxyAccessible::IsTable* functions here because they
+  // do not use IPC calls but that might change after bug 1210477.
+  Class type;
+  if (aProxy->IsTable())
+    type = [mozTableAccessible class];
+  else if (aProxy->IsTableRow())
+    type = [mozTableRowAccessible class];
+  else if (aProxy->IsTableCell())
+    type = [mozTableCellAccessible class];
+  else
+    type = GetTypeFromRole(aProxy->Role());
+
+  uintptr_t accWrap = reinterpret_cast<uintptr_t>(aProxy) | IS_PROXY;
+  mozAccessible* mozWrapper = [[type alloc] initWithAccessible:accWrap];
+  aProxy->SetWrapper(reinterpret_cast<uintptr_t>(mozWrapper));
+
+  mozAccessible* nativeParent = nullptr;
+  if (aProxy->IsDoc() && aProxy->AsDoc()->IsTopLevel()) {
+    // If proxy is top level, the parent we need to invalidate the children of
+    // will be a non-remote accessible.
+    Accessible* outerDoc = aProxy->OuterDocOfRemoteBrowser();
+    if (outerDoc) {
+      nativeParent = GetNativeFromGeckoAccessible(outerDoc);
+    }
+  } else {
+    // Non-top level proxies need proxy parents' children invalidated.
+    ProxyAccessible* parent = aProxy->Parent();
+    nativeParent = GetNativeFromProxy(parent);
+    NS_ASSERTION(parent, "a non-top-level proxy is missing a parent?");
+  }
+
+  if (nativeParent) {
+    [nativeParent invalidateChildren];
+  }
+}
+
+void
+ProxyDestroyed(ProxyAccessible* aProxy)
+{
+  mozAccessible* nativeParent = nil;
+  if (aProxy->IsDoc() && aProxy->AsDoc()->IsTopLevel()) {
+    // Invalidate native parent in parent process's children on proxy destruction
+    Accessible* outerDoc = aProxy->OuterDocOfRemoteBrowser();
+    if (outerDoc) {
+      nativeParent = GetNativeFromGeckoAccessible(outerDoc);
+    }
+  } else {
+    if (!aProxy->Document()->IsShutdown()) {
+      // Only do if the document has not been shut down, else parent will return
+      // garbage since we don't shut down children from top down.
+      ProxyAccessible* parent = aProxy->Parent();
+      // Invalidate proxy parent's children.
+      if (parent) {
+        nativeParent = GetNativeFromProxy(parent);
+      }
+    }
+  }
+
+  mozAccessible* wrapper = GetNativeFromProxy(aProxy);
+  [wrapper expire];
+  [wrapper release];
+  aProxy->SetWrapper(0);
+
+  if (nativeParent) {
+    [nativeParent invalidateChildren];
+  }
+}
+
+void
+ProxyEvent(ProxyAccessible* aProxy, uint32_t aEventType)
+{
+  // ignore everything but focus-changed, value-changed, caret and selection
+  // events for now.
+  if (aEventType != nsIAccessibleEvent::EVENT_FOCUS &&
+      aEventType != nsIAccessibleEvent::EVENT_VALUE_CHANGE &&
+      aEventType != nsIAccessibleEvent::EVENT_TEXT_VALUE_CHANGE &&
+      aEventType != nsIAccessibleEvent::EVENT_TEXT_CARET_MOVED &&
+      aEventType != nsIAccessibleEvent::EVENT_TEXT_SELECTION_CHANGED)
+    return;
+
+  mozAccessible* wrapper = GetNativeFromProxy(aProxy);
+  if (wrapper)
+    FireNativeEvent(wrapper, aEventType);
+}
+
+void
+ProxyStateChangeEvent(ProxyAccessible* aProxy, uint64_t, bool)
+{
+  // mac doesn't care about state change events
+}
+
+void
+ProxyCaretMoveEvent(ProxyAccessible* aTarget, int32_t aOffset)
+{
+  mozAccessible* wrapper = GetNativeFromProxy(aTarget);
+  if (wrapper)
+    [wrapper selectedTextDidChange];
+}
+
+void
+ProxyTextChangeEvent(ProxyAccessible*, const nsString&, int32_t, uint32_t,
+                     bool, bool)
+{
+}
+
+void
+ProxyShowHideEvent(ProxyAccessible*, ProxyAccessible*, bool, bool)
+{
+}
+
+void
+ProxySelectionEvent(ProxyAccessible*, ProxyAccessible*, uint32_t)
+{
+}
+} // namespace a11y
+} // namespace mozilla
+
+@interface GeckoNSApplication(a11y)
+-(void)accessibilitySetValue:(id)value forAttribute:(NSString*)attribute;
+@end
+
+@implementation GeckoNSApplication(a11y)
+
+-(void)accessibilitySetValue:(id)value forAttribute:(NSString*)attribute
+{
+  if ([attribute isEqualToString:@"AXEnhancedUserInterface"])
+    mozilla::a11y::sA11yShouldBeEnabled = ([value intValue] == 1);
+
+  return [super accessibilitySetValue:value forAttribute:attribute];
+}
+
+@end
+

accessible/mac/RootAccessibleWrap.h

@@ -0,0 +1,34 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+/* For documentation of the accessibility architecture,
+ * see http://lxr.mozilla.org/seamonkey/source/accessible/accessible-docs.html
+ */
+
+#ifndef mozilla_a11y_RootAccessibleWrap_h__
+#define mozilla_a11y_RootAccessibleWrap_h__
+
+#include "RootAccessible.h"
+
+namespace mozilla {
+namespace a11y {
+
+class RootAccessibleWrap : public RootAccessible
+{
+public:
+  RootAccessibleWrap(nsIDocument* aDocument, nsIPresShell* aPresShell);
+  virtual ~RootAccessibleWrap();
+
+    Class GetNativeType ();
+
+    // let's our native accessible get in touch with the
+    // native cocoa view that is our accessible parent.
+    void GetNativeWidget (void **aOutView);
+};
+
+} // namespace a11y
+} // namespace mozilla
+
+#endif

accessible/mac/RootAccessibleWrap.mm

@@ -0,0 +1,53 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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 "RootAccessibleWrap.h"
+
+#include "mozDocAccessible.h"
+
+#include "nsCOMPtr.h"
+#include "nsObjCExceptions.h"
+#include "nsIFrame.h"
+#include "nsView.h"
+#include "nsIWidget.h"
+
+using namespace mozilla::a11y;
+
+RootAccessibleWrap::
+  RootAccessibleWrap(nsIDocument* aDocument, nsIPresShell* aPresShell) :
+  RootAccessible(aDocument, aPresShell)
+{
+}
+
+RootAccessibleWrap::~RootAccessibleWrap()
+{
+}
+
+Class
+RootAccessibleWrap::GetNativeType()
+{
+  NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL;
+
+  return [mozRootAccessible class];
+
+  NS_OBJC_END_TRY_ABORT_BLOCK_NIL;
+}
+
+void
+RootAccessibleWrap::GetNativeWidget(void** aOutView)
+{
+  nsIFrame *frame = GetFrame();
+  if (frame) {
+    nsView *view = frame->GetView();
+    if (view) {
+      nsIWidget *widget = view->GetWidget();
+      if (widget) {
+        *aOutView = (void**)widget->GetNativeData (NS_NATIVE_WIDGET);
+        NS_ASSERTION (*aOutView,
+                      "Couldn't get the native NSView parent we need to connect the accessibility hierarchy!");
+      }
+    }
+  }
+}

accessible/mac/TextLeafAccessibleWrap.h

@@ -0,0 +1,19 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+#ifndef mozilla_a11y_TextLeafAccessibleWrap_h__
+#define mozilla_a11y_TextLeafAccessibleWrap_h__
+
+#include "TextLeafAccessible.h"
+
+namespace mozilla {
+namespace a11y {
+
+typedef class TextLeafAccessible TextLeafAccessibleWrap;
+
+} // namespace a11y
+} // namespace mozilla
+
+#endif

accessible/mac/XULListboxAccessibleWrap.h

@@ -0,0 +1,20 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+#ifndef mozilla_a11y_XULListboxAccessibleWrap_h__
+#define mozilla_a11y_XULListboxAccessibleWrap_h__
+
+#include "XULListboxAccessible.h"
+
+namespace mozilla {
+namespace a11y {
+
+typedef class XULListboxAccessible XULListboxAccessibleWrap;
+typedef class XULListCellAccessible XULListCellAccessibleWrap;
+
+} // namespace a11y
+} // namespace mozilla
+
+#endif

accessible/mac/XULMenuAccessibleWrap.h

@@ -0,0 +1,19 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+#ifndef mozilla_a11y_XULMenuAccessibleWrap_h__
+#define mozilla_a11y_XULMenuAccessibleWrap_h__
+
+#include "XULMenuAccessible.h"
+
+namespace mozilla {
+namespace a11y {
+
+typedef class XULMenuitemAccessible XULMenuitemAccessibleWrap;
+
+} // namespace a11y
+} // namespace mozilla
+
+#endif

accessible/mac/XULTreeGridAccessibleWrap.h

@@ -0,0 +1,20 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+#ifndef mozilla_a11y_XULTreeGridAccessibleWrap_h__
+#define mozilla_a11y_XULTreeGridAccessibleWrap_h__
+
+#include "XULTreeGridAccessible.h"
+
+namespace mozilla {
+namespace a11y {
+
+typedef class XULTreeGridAccessible XULTreeGridAccessibleWrap;
+typedef class XULTreeGridCellAccessible XULTreeGridCellAccessibleWrap;
+
+} // namespace a11y
+} // namespace mozilla
+
+#endif

accessible/mac/moz.build

@@ -0,0 +1,44 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# 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/.
+
+EXPORTS += [
+    'mozAccessibleProtocol.h',
+]
+
+EXPORTS.mozilla.a11y += [
+    'AccessibleWrap.h',
+    'HyperTextAccessibleWrap.h',
+]
+
+SOURCES += [
+    'AccessibleWrap.mm',
+    'DocAccessibleWrap.mm',
+    'MacUtils.mm',
+    'mozAccessible.mm',
+    'mozActionElements.mm',
+    'mozDocAccessible.mm',
+    'mozHTMLAccessible.mm',
+    'mozTableAccessible.mm',
+    'mozTextAccessible.mm',
+    'Platform.mm',
+    'RootAccessibleWrap.mm',
+]
+
+LOCAL_INCLUDES += [
+    '/accessible/base',
+    '/accessible/generic',
+    '/accessible/html',
+    '/accessible/ipc',
+    '/accessible/ipc/other',
+    '/accessible/xul',
+    '/layout/generic',
+    '/layout/xul',
+    '/widget',
+    '/widget/cocoa',
+]
+
+FINAL_LIBRARY = 'xul'
+
+include('/ipc/chromium/chromium-config.mozbuild')

accessible/mac/mozAccessible.h

@@ -0,0 +1,181 @@
+/* -*- Mode: Objective-C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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 "AccessibleWrap.h"
+#include "ProxyAccessible.h"
+
+#import <Cocoa/Cocoa.h>
+
+#import "mozAccessibleProtocol.h"
+
+@class mozRootAccessible;
+
+/**
+ * All mozAccessibles are either abstract objects (that correspond to XUL
+ * widgets, HTML frames, etc) or are attached to a certain view; for example
+ * a document view. When we hand an object off to an AT, we always want
+ * to give it the represented view, in the latter case.
+ */
+
+namespace mozilla {
+namespace a11y {
+
+inline id <mozAccessible>
+GetObjectOrRepresentedView(id <mozAccessible> aObject)
+{
+  return [aObject hasRepresentedView] ? [aObject representedView] : aObject;
+}
+
+inline mozAccessible*
+GetNativeFromGeckoAccessible(Accessible* aAccessible)
+{
+  mozAccessible* native = nil;
+  aAccessible->GetNativeInterface((void**)&native);
+  return native;
+}
+
+inline mozAccessible*
+GetNativeFromProxy(const ProxyAccessible* aProxy)
+{
+  return reinterpret_cast<mozAccessible*>(aProxy->GetWrapper());
+}
+
+} // a11y
+} // mozilla
+
+// This is OR'd with the Accessible owner to indicate the wrap-ee is a proxy.
+static const uintptr_t IS_PROXY = 1;
+
+@interface mozAccessible : NSObject <mozAccessible>
+{
+  /**
+   * Weak reference; it owns us.
+   */
+  uintptr_t mGeckoAccessible;
+
+  /**
+   * Strong ref to array of children
+   */
+  NSMutableArray* mChildren;
+
+  /**
+   * Weak reference to the parent
+   */
+  mozAccessible* mParent;
+
+  /**
+   * The role of our gecko accessible.
+   */
+  mozilla::a11y::role        mRole;
+}
+
+// return the Accessible for this mozAccessible if it exists.
+- (mozilla::a11y::AccessibleWrap*)getGeckoAccessible;
+
+// return the ProxyAccessible for this mozAccessible if it exists.
+- (mozilla::a11y::ProxyAccessible*)getProxyAccessible;
+
+// inits with the gecko owner.
+- (id)initWithAccessible:(uintptr_t)aGeckoObj;
+
+// our accessible parent (AXParent)
+- (id <mozAccessible>)parent;
+
+// a lazy cache of our accessible children (AXChildren). updated
+- (NSArray*)children;
+
+// returns the size of this accessible.
+- (NSValue*)size;
+
+// returns the position, in cocoa coordinates.
+- (NSValue*)position;
+
+// can be overridden to report another role name.
+- (NSString*)role;
+
+// a subrole is a more specialized variant of the role. for example,
+// the role might be "textfield", while the subrole is "password textfield".
+- (NSString*)subrole;
+
+// Return the role description, as there are a few exceptions.
+- (NSString*)roleDescription;
+
+// returns the native window we're inside.
+- (NSWindow*)window;
+
+// the value of this element.
+- (id)value;
+
+// name that is associated with this accessible (for buttons, etc)
+- (NSString*)title;
+
+// the accessible description (help text) of this particular instance.
+- (NSString*)help;
+
+- (BOOL)isEnabled;
+
+// information about focus.
+- (BOOL)isFocused;
+- (BOOL)canBeFocused;
+
+// returns NO if for some reason we were unable to focus the element.
+- (BOOL)focus;
+
+// notifications sent out to listening accessible providers.
+- (void)didReceiveFocus;
+- (void)valueDidChange;
+- (void)selectedTextDidChange;
+- (void)documentLoadComplete;
+
+// internal method to retrieve a child at a given index.
+- (id)childAt:(uint32_t)i;
+
+#pragma mark -
+
+// invalidates and removes all our children from our cached array.
+- (void)invalidateChildren;
+
+/**
+ * Append a child if they are already cached.
+ */
+- (void)appendChild:(mozilla::a11y::Accessible*)aAccessible;
+
+// makes ourselves "expired". after this point, we might be around if someone
+// has retained us (e.g., a third-party), but we really contain no information.
+- (void)expire;
+- (BOOL)isExpired;
+
+#ifdef DEBUG
+- (void)printHierarchy;
+- (void)printHierarchyWithLevel:(unsigned)numSpaces;
+
+- (void)sanityCheckChildren;
+- (void)sanityCheckChildren:(NSArray*)theChildren;
+#endif
+
+// ---- NSAccessibility methods ---- //
+
+// whether to skip this element when traversing the accessibility
+// hierarchy.
+- (BOOL)accessibilityIsIgnored;
+
+// called by third-parties to determine the deepest child element under the mouse
+- (id)accessibilityHitTest:(NSPoint)point;
+
+// returns the deepest unignored focused accessible element
+- (id)accessibilityFocusedUIElement;
+
+// a mozAccessible needs to at least provide links to its parent and
+// children.
+- (NSArray*)accessibilityAttributeNames;
+
+// value for the specified attribute
+- (id)accessibilityAttributeValue:(NSString*)attribute;
+
+- (BOOL)accessibilityIsAttributeSettable:(NSString*)attribute;
+- (void)accessibilitySetValue:(id)value forAttribute:(NSString*)attribute;
+
+@end
+

accessible/mac/mozAccessibleProtocol.h

@@ -0,0 +1,69 @@
+/* -*- Mode: Objective-C; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+#import <Cocoa/Cocoa.h>
+
+#import "mozView.h"
+
+/* This protocol's primary use is so widget/cocoa can talk back to us
+   properly.
+
+   ChildView owns the topmost mozRootAccessible, and needs to take care of setting up
+   that parent/child relationship.
+
+   This protocol is thus used to make sure it knows it's talking to us, and not
+   just some random |id|.
+*/
+
+@protocol mozAccessible
+
+// returns whether this accessible is the root accessible. there is one
+// root accessible per window.
+- (BOOL)isRoot;
+
+// some mozAccessibles implement accessibility support in place of another object. for example,
+// ChildView gets its support from us.
+//
+// instead of returning a mozAccessible to the OS when it wants an object, we need to pass the view we represent, so the
+// OS doesn't get confused and think we return some random object.
+- (BOOL)hasRepresentedView;
+- (id)representedView;
+
+#ifdef DEBUG
+// debug utility that will print the native accessibility tree, starting
+// at this node.
+- (void)printHierarchy;
+#endif
+
+/*** general ***/
+
+// returns the accessible at the specified point.
+- (id)accessibilityHitTest:(NSPoint)point;
+
+// whether this element is flagged as ignored.
+- (BOOL)accessibilityIsIgnored;
+
+// currently focused UI element (possibly a child accessible)
+- (id)accessibilityFocusedUIElement;
+
+/*** attributes ***/
+
+// all supported attributes
+- (NSArray*)accessibilityAttributeNames;
+
+// value for given attribute.
+- (id)accessibilityAttributeValue:(NSString*)attribute;
+
+// whether a particular attribute can be modified
+- (BOOL)accessibilityIsAttributeSettable:(NSString*)attribute;
+
+/*** actions ***/
+
+- (NSArray*)accessibilityActionNames;
+- (NSString*)accessibilityActionDescription:(NSString*)action;
+- (void)accessibilityPerformAction:(NSString*)action;
+
+@end
+

accessible/mac/mozActionElements.h

@@ -0,0 +1,37 @@
+/* -*- Mode: Objective-C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+#import <Cocoa/Cocoa.h>
+#import "mozAccessible.h"
+
+/* Simple subclasses for things like checkboxes, buttons, etc. */
+
+@interface mozButtonAccessible : mozAccessible
+ {
+ }
+- (BOOL)hasPopup;
+- (void)click;
+- (BOOL)isTab;
+@end
+
+@interface mozCheckboxAccessible : mozButtonAccessible
+// returns one of the constants defined in CheckboxValue
+- (int)isChecked;
+@end
+
+/* Class for tabs - not individual tabs */
+@interface mozTabsAccessible : mozAccessible
+{
+  NSMutableArray* mTabs;
+}
+-(id)tabs;
+@end
+
+/**
+ * Accessible for a PANE
+ */
+@interface mozPaneAccessible : mozAccessible
+
+@end

accessible/mac/mozActionElements.mm

@@ -0,0 +1,340 @@
+/* -*- Mode: Objective-C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+#import "mozActionElements.h"
+
+#import "MacUtils.h"
+#include "Accessible-inl.h"
+#include "DocAccessible.h"
+#include "XULTabAccessible.h"
+
+#include "nsDeckFrame.h"
+#include "nsObjCExceptions.h"
+
+using namespace mozilla::a11y;
+
+enum CheckboxValue {
+  // these constants correspond to the values in the OS
+  kUnchecked = 0,
+  kChecked = 1,
+  kMixed = 2
+};
+
+@implementation mozButtonAccessible
+
+- (NSArray*)accessibilityAttributeNames
+{
+  NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL;
+
+  static NSArray *attributes = nil;
+  if (!attributes) {
+    attributes = [[NSArray alloc] initWithObjects:NSAccessibilityParentAttribute, // required
+                                                  NSAccessibilityRoleAttribute, // required
+                                                  NSAccessibilityRoleDescriptionAttribute,
+                                                  NSAccessibilityPositionAttribute, // required
+                                                  NSAccessibilitySizeAttribute, // required
+                                                  NSAccessibilityWindowAttribute, // required
+                                                  NSAccessibilityPositionAttribute, // required
+                                                  NSAccessibilityTopLevelUIElementAttribute, // required
+                                                  NSAccessibilityHelpAttribute,
+                                                  NSAccessibilityEnabledAttribute, // required
+                                                  NSAccessibilityFocusedAttribute, // required
+                                                  NSAccessibilityTitleAttribute, // required
+                                                  NSAccessibilityChildrenAttribute,
+                                                  NSAccessibilityDescriptionAttribute,
+#if DEBUG
+                                                  @"AXMozDescription",
+#endif
+                                                  nil];
+  }
+  return attributes;
+
+  NS_OBJC_END_TRY_ABORT_BLOCK_NIL;
+}
+
+- (id)accessibilityAttributeValue:(NSString *)attribute
+{
+  NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL;
+
+  if ([attribute isEqualToString:NSAccessibilityChildrenAttribute]) {
+    if ([self hasPopup])
+      return [self children];
+    return nil;
+  }
+
+  if ([attribute isEqualToString:NSAccessibilityRoleDescriptionAttribute]) {
+    if ([self isTab])
+      return utils::LocalizedString(NS_LITERAL_STRING("tab"));
+
+    return NSAccessibilityRoleDescription([self role], nil);
+  }
+
+  return [super accessibilityAttributeValue:attribute];
+
+  NS_OBJC_END_TRY_ABORT_BLOCK_NIL;
+}
+
+- (BOOL)accessibilityIsIgnored
+{
+  return ![self getGeckoAccessible] && ![self getProxyAccessible];
+}
+
+- (NSArray*)accessibilityActionNames
+{
+  NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL;
+
+  if ([self isEnabled]) {
+    if ([self hasPopup])
+      return [NSArray arrayWithObjects:NSAccessibilityPressAction,
+              NSAccessibilityShowMenuAction,
+              nil];
+    return [NSArray arrayWithObject:NSAccessibilityPressAction];
+  }
+  return nil;
+
+  NS_OBJC_END_TRY_ABORT_BLOCK_NIL;
+}
+
+- (NSString*)accessibilityActionDescription:(NSString*)action
+{
+  NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL;
+
+  if ([action isEqualToString:NSAccessibilityPressAction]) {
+    if ([self isTab])
+      return utils::LocalizedString(NS_LITERAL_STRING("switch"));
+
+    return @"press button"; // XXX: localize this later?
+  }
+
+  if ([self hasPopup]) {
+    if ([action isEqualToString:NSAccessibilityShowMenuAction])
+      return @"show menu";
+  }
+
+  return nil;
+
+  NS_OBJC_END_TRY_ABORT_BLOCK_NIL;
+}
+
+- (void)accessibilityPerformAction:(NSString*)action
+{
+  NS_OBJC_BEGIN_TRY_ABORT_BLOCK;
+
+  if ([self isEnabled] && [action isEqualToString:NSAccessibilityPressAction]) {
+    // TODO: this should bring up the menu, but currently doesn't.
+    //       once msaa and atk have merged better, they will implement
+    //       the action needed to show the menu.
+    [self click];
+  }
+
+  NS_OBJC_END_TRY_ABORT_BLOCK;
+}
+
+- (void)click
+{
+  // both buttons and checkboxes have only one action. we should really stop using arbitrary
+  // arrays with actions, and define constants for these actions.
+  if (AccessibleWrap* accWrap = [self getGeckoAccessible])
+    accWrap->DoAction(0);
+  else if (ProxyAccessible* proxy = [self getProxyAccessible])
+    proxy->DoAction(0);
+}
+
+- (BOOL)isTab
+{
+  if (AccessibleWrap* accWrap = [self getGeckoAccessible])
+    return accWrap->Role() == roles::PAGETAB;
+
+  if (ProxyAccessible* proxy = [self getProxyAccessible])
+    return proxy->Role() == roles::PAGETAB;
+
+  return false;
+}
+
+- (BOOL)hasPopup
+{
+  if (AccessibleWrap* accWrap = [self getGeckoAccessible])
+    return accWrap->NativeState() & states::HASPOPUP;
+
+  if (ProxyAccessible* proxy = [self getProxyAccessible])
+    return proxy->NativeState() & states::HASPOPUP;
+
+  return false;
+}
+
+@end
+
+@implementation mozCheckboxAccessible
+
+- (NSString*)accessibilityActionDescription:(NSString*)action
+{
+  NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL;
+
+  if ([action isEqualToString:NSAccessibilityPressAction]) {
+    if ([self isChecked] != kUnchecked)
+      return @"uncheck checkbox"; // XXX: localize this later?
+
+    return @"check checkbox"; // XXX: localize this later?
+  }
+
+  return nil;
+
+  NS_OBJC_END_TRY_ABORT_BLOCK_NIL;
+}
+
+- (int)isChecked
+{
+  uint64_t state = 0;
+  if (AccessibleWrap* accWrap = [self getGeckoAccessible])
+    state = accWrap->NativeState();
+  else if (ProxyAccessible* proxy = [self getProxyAccessible])
+    state = proxy->NativeState();
+
+  // check if we're checked or in a mixed state
+  if (state & states::CHECKED) {
+    return (state & states::MIXED) ? kMixed : kChecked;
+  }
+
+  return kUnchecked;
+}
+
+- (id)value
+{
+  NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL;
+
+  return [NSNumber numberWithInt:[self isChecked]];
+
+  NS_OBJC_END_TRY_ABORT_BLOCK_NIL;
+}
+
+@end
+
+@implementation mozTabsAccessible
+
+- (void)dealloc
+{
+  [mTabs release];
+
+  [super dealloc];
+}
+
+- (NSArray*)accessibilityAttributeNames
+{
+  // standard attributes that are shared and supported by root accessible (AXMain) elements.
+  static NSMutableArray* attributes = nil;
+
+  if (!attributes) {
+    attributes = [[super accessibilityAttributeNames] mutableCopy];
+    [attributes addObject:NSAccessibilityContentsAttribute];
+    [attributes addObject:NSAccessibilityTabsAttribute];
+  }
+
+  return attributes;
+}
+
+- (id)accessibilityAttributeValue:(NSString *)attribute
+{
+  if ([attribute isEqualToString:NSAccessibilityContentsAttribute])
+    return [super children];
+  if ([attribute isEqualToString:NSAccessibilityTabsAttribute])
+    return [self tabs];
+
+  return [super accessibilityAttributeValue:attribute];
+}
+
+/**
+ * Returns the selected tab (the mozAccessible)
+ */
+- (id)value
+{
+  mozAccessible* nativeAcc = nil;
+  if (AccessibleWrap* accWrap = [self getGeckoAccessible]) {
+    if (Accessible* accTab = accWrap->GetSelectedItem(0)) {
+      accTab->GetNativeInterface((void**)&nativeAcc);
+    }
+  } else if (ProxyAccessible* proxy = [self getProxyAccessible]) {
+    if (ProxyAccessible* proxyTab = proxy->GetSelectedItem(0)) {
+      nativeAcc = GetNativeFromProxy(proxyTab);
+    }
+  }
+
+  return nativeAcc;
+}
+
+/**
+ * Return the mozAccessibles that are the tabs.
+ */
+- (id)tabs
+{
+  if (mTabs)
+    return mTabs;
+
+  NSArray* children = [self children];
+  NSEnumerator* enumerator = [children objectEnumerator];
+  mTabs = [[NSMutableArray alloc] init];
+
+  id obj;
+  while ((obj = [enumerator nextObject]))
+    if ([obj isTab])
+      [mTabs addObject:obj];
+
+  return mTabs;
+}
+
+- (void)invalidateChildren
+{
+  [super invalidateChildren];
+
+  [mTabs release];
+  mTabs = nil;
+}
+
+@end
+
+@implementation mozPaneAccessible
+
+- (NSUInteger)accessibilityArrayAttributeCount:(NSString*)attribute
+{
+  AccessibleWrap* accWrap = [self getGeckoAccessible];
+  ProxyAccessible* proxy = [self getProxyAccessible];
+  if (!accWrap && !proxy)
+    return 0;
+
+  // By default this calls -[[mozAccessible children] count].
+  // Since we don't cache mChildren. This is faster.
+  if ([attribute isEqualToString:NSAccessibilityChildrenAttribute]) {
+    if (accWrap)
+      return accWrap->ChildCount() ? 1 : 0;
+
+    return proxy->ChildrenCount() ? 1 : 0;
+  }
+
+  return [super accessibilityArrayAttributeCount:attribute];
+}
+
+- (NSArray*)children
+{
+  if (![self getGeckoAccessible])
+    return nil;
+
+  nsDeckFrame* deckFrame = do_QueryFrame([self getGeckoAccessible]->GetFrame());
+  nsIFrame* selectedFrame = deckFrame ? deckFrame->GetSelectedBox() : nullptr;
+
+  Accessible* selectedAcc = nullptr;
+  if (selectedFrame) {
+    nsINode* node = selectedFrame->GetContent();
+    selectedAcc = [self getGeckoAccessible]->Document()->GetAccessible(node);
+  }
+
+  if (selectedAcc) {
+    mozAccessible *curNative = GetNativeFromGeckoAccessible(selectedAcc);
+    if (curNative)
+      return [NSArray arrayWithObjects:GetObjectOrRepresentedView(curNative), nil];
+  }
+
+  return nil;
+}
+
+@end

accessible/mac/mozDocAccessible.h

@@ -0,0 +1,31 @@
+/* -*- Mode: Objective-C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+#import <Cocoa/Cocoa.h>
+#import "mozAccessible.h"
+
+// our protocol that we implement (so cocoa widgets can talk to us)
+#import "mozAccessibleProtocol.h"
+
+/*
+  The root accessible. There is one per window.
+  Created by the RootAccessibleWrap.
+*/
+@interface mozRootAccessible : mozAccessible
+{
+  // the mozView that we're representing.
+  // all outside communication goes through the mozView.
+  // in reality, it's just piping all calls to us, and we're
+  // doing its dirty work!
+  //
+  // whenever someone asks who we are (e.g., a child asking
+  // for its parent, or our parent asking for its child), we'll
+  // respond the mozView. it is absolutely necessary for third-
+  // party tools that we do this!
+  //
+  // /hwaara
+  id <mozView, mozAccessible> mParallelView; // weak ref
+}
+@end

accessible/mac/mozDocAccessible.mm

@@ -0,0 +1,111 @@
+/* -*- Mode: Objective-C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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 "RootAccessibleWrap.h"
+
+#import "mozDocAccessible.h"
+
+#import "mozView.h"
+
+// This must be included last:
+#include "nsObjCExceptions.h"
+
+using namespace mozilla::a11y;
+
+static id <mozAccessible, mozView>
+getNativeViewFromRootAccessible(Accessible* aAccessible)
+{
+  RootAccessibleWrap* root =
+    static_cast<RootAccessibleWrap*>(aAccessible->AsRoot());
+  id <mozAccessible, mozView> nativeView = nil;
+  root->GetNativeWidget ((void**)&nativeView);
+  return nativeView;
+}
+
+#pragma mark -
+
+@implementation mozRootAccessible
+
+- (NSArray*)accessibilityAttributeNames
+{
+  NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL;
+
+  // if we're expired, we don't support any attributes.
+  if (![self getGeckoAccessible])
+    return [NSArray array];
+
+  // standard attributes that are shared and supported by root accessible (AXMain) elements.
+  static NSMutableArray* attributes = nil;
+
+  if (!attributes) {
+    attributes = [[super accessibilityAttributeNames] mutableCopy];
+    [attributes addObject:NSAccessibilityMainAttribute];
+    [attributes addObject:NSAccessibilityMinimizedAttribute];
+  }
+
+  return attributes;
+
+  NS_OBJC_END_TRY_ABORT_BLOCK_NIL;
+}
+
+- (id)accessibilityAttributeValue:(NSString *)attribute
+{
+  NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL;
+
+  if ([attribute isEqualToString:NSAccessibilityMainAttribute])
+    return [NSNumber numberWithBool:[[self window] isMainWindow]];
+  if ([attribute isEqualToString:NSAccessibilityMinimizedAttribute])
+    return [NSNumber numberWithBool:[[self window] isMiniaturized]];
+
+  return [super accessibilityAttributeValue:attribute];
+
+  NS_OBJC_END_TRY_ABORT_BLOCK_NIL;
+}
+
+
+// return the AXParent that our parallell NSView tells us about.
+- (id)parent
+{
+  NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL;
+
+  if (!mParallelView)
+    mParallelView = (id<mozView, mozAccessible>)[self representedView];
+
+  if (mParallelView)
+    return [mParallelView accessibilityAttributeValue:NSAccessibilityParentAttribute];
+
+  NSAssert(mParallelView, @"we're a root accessible w/o native view?");
+  return [super parent];
+
+  NS_OBJC_END_TRY_ABORT_BLOCK_NIL;
+}
+
+- (BOOL)hasRepresentedView
+{
+  return YES;
+}
+
+// this will return our parallell NSView. see mozDocAccessible.h
+- (id)representedView
+{
+  NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL;
+
+  if (mParallelView)
+    return (id)mParallelView;
+
+  mParallelView = getNativeViewFromRootAccessible ([self getGeckoAccessible]);
+
+  NSAssert(mParallelView, @"can't return root accessible's native parallel view.");
+  return mParallelView;
+
+  NS_OBJC_END_TRY_ABORT_BLOCK_NIL;
+}
+
+- (BOOL)isRoot
+{
+  return YES;
+}
+
+@end

accessible/mac/mozHTMLAccessible.h

@@ -0,0 +1,16 @@
+/* -*- Mode: Objective-C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:expandtab:shiftwidth=2:tabstop=2:
+ */
+/* 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/. */
+
+#import "mozAccessible.h"
+
+@interface mozHeadingAccessible : mozAccessible
+
+@end
+
+@interface mozLinkAccessible : mozAccessible
+
+@end

accessible/mac/mozHTMLAccessible.mm

@@ -0,0 +1,141 @@
+/* -*- Mode: Objective-C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:expandtab:shiftwidth=2:tabstop=2:
+ */
+/* 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/. */
+
+#import "mozHTMLAccessible.h"
+
+#import "Accessible-inl.h"
+#import "HyperTextAccessible.h"
+
+#import "nsCocoaUtils.h"
+
+using namespace mozilla::a11y;
+
+@implementation mozHeadingAccessible
+
+- (NSString*)title
+{
+  nsAutoString title;
+  if (AccessibleWrap* accWrap = [self getGeckoAccessible]) {
+    mozilla::ErrorResult rv;
+    // XXX use the flattening API when there are available
+    // see bug 768298
+    accWrap->GetContent()->GetTextContent(title, rv);
+  } else if (ProxyAccessible* proxy = [self getProxyAccessible]) {
+    proxy->Title(title);
+  }
+
+  return nsCocoaUtils::ToNSString(title);
+}
+
+- (id)value
+{
+  uint32_t level = 0;
+  if (AccessibleWrap* accWrap = [self getGeckoAccessible]) {
+    level = accWrap->GetLevelInternal();
+  } else if (ProxyAccessible* proxy = [self getProxyAccessible]) {
+    level = proxy->GetLevelInternal();
+  }
+
+  return [NSNumber numberWithInt:level];
+}
+
+@end
+
+@interface mozLinkAccessible ()
+-(NSURL*)url;
+@end
+
+@implementation mozLinkAccessible
+
+- (NSArray*)accessibilityAttributeNames
+{
+  // if we're expired, we don't support any attributes.
+  if (![self getGeckoAccessible] && ![self getProxyAccessible])
+    return [NSArray array];
+
+  static NSMutableArray* attributes = nil;
+
+  if (!attributes) {
+    attributes = [[super accessibilityAttributeNames] mutableCopy];
+    [attributes addObject:NSAccessibilityURLAttribute];
+  }
+
+  return attributes;
+}
+
+- (id)accessibilityAttributeValue:(NSString *)attribute
+{
+  if ([attribute isEqualToString:NSAccessibilityURLAttribute])
+    return [self url];
+
+  return [super accessibilityAttributeValue:attribute];
+}
+
+- (NSArray*)accessibilityActionNames
+{
+    // if we're expired, we don't support any attributes.
+  if (![self getGeckoAccessible] && ![self getProxyAccessible])
+    return [NSArray array];
+
+  static NSArray* actionNames = nil;
+
+  if (!actionNames) {
+    actionNames = [[NSArray alloc] initWithObjects:NSAccessibilityPressAction,
+                                   nil];
+  }
+
+  return actionNames;
+}
+
+- (void)accessibilityPerformAction:(NSString*)action
+{
+  AccessibleWrap* accWrap = [self getGeckoAccessible];
+  ProxyAccessible* proxy = [self getProxyAccessible];
+  if (!accWrap && !proxy) {
+    return;
+  }
+
+  if ([action isEqualToString:NSAccessibilityPressAction]) {
+    if (accWrap) {
+      accWrap->DoAction(0);
+    } else if (proxy) {
+      proxy->DoAction(0);
+    }
+    return;
+  }
+
+  [super accessibilityPerformAction:action];
+
+}
+
+- (NSString*)customDescription
+{
+  return @"";
+}
+
+- (NSString*)value
+{
+  return @"";
+}
+
+- (NSURL*)url
+{
+  nsAutoString value;
+  if (AccessibleWrap* accWrap = [self getGeckoAccessible]) {
+    accWrap->Value(value);
+  } else if (ProxyAccessible* proxy = [self getProxyAccessible]) {
+    proxy->Value(value);
+  }
+
+  NSString* urlString = value.IsEmpty() ? nil : nsCocoaUtils::ToNSString(value);
+  if (!urlString)
+    return nil;
+
+  return [NSURL URLWithString:urlString];
+}
+
+@end

accessible/mac/mozTableAccessible.h

@@ -0,0 +1,28 @@
+/* -*- Mode: Objective-C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:expandtab:shiftwidth=2:tabstop=2:
+ */
+/* 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/. */
+
+#import "mozAccessible.h"
+
+@interface mozTablePartAccessible : mozAccessible
+- (BOOL)isLayoutTablePart;
+- (NSString*)role;
+@end
+
+@interface mozTableAccessible : mozTablePartAccessible
+- (NSArray*)additionalAccessibilityAttributeNames;
+- (id)accessibilityAttributeValue:(NSString*)attribute;
+@end
+
+@interface mozTableRowAccessible : mozTablePartAccessible
+- (NSArray*)additionalAccessibilityAttributeNames;
+- (id)accessibilityAttributeValue:(NSString*)attribute;
+@end
+
+@interface mozTableCellAccessible : mozTablePartAccessible
+- (NSArray*)additionalAccessibilityAttributeNames;
+- (id)accessibilityAttributeValue:(NSString*)attribute;
+@end

accessible/mac/mozTableAccessible.mm

@@ -0,0 +1,281 @@
+/* -*- Mode: Objective-C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:expandtab:shiftwidth=2:tabstop=2:
+ */
+/* 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/. */
+
+#import "Accessible-inl.h"
+#import "mozTableAccessible.h"
+#import "TableAccessible.h"
+#import "TableCellAccessible.h"
+#import "nsCocoaUtils.h"
+
+using namespace mozilla::a11y;
+
+// convert an array of Gecko accessibles to an NSArray of native accessibles
+static inline NSMutableArray*
+ConvertToNSArray(nsTArray<Accessible*>& aArray)
+{
+  NSMutableArray* nativeArray = [[NSMutableArray alloc] init];
+
+  // iterate through the list, and get each native accessible.
+  size_t totalCount = aArray.Length();
+  for (size_t i = 0; i < totalCount; i++) {
+    Accessible* curAccessible = aArray.ElementAt(i);
+    mozAccessible* curNative = GetNativeFromGeckoAccessible(curAccessible);
+    if (curNative)
+      [nativeArray addObject:GetObjectOrRepresentedView(curNative)];
+  }
+
+  return nativeArray;
+}
+
+// convert an array of Gecko proxy accessibles to an NSArray of native accessibles
+static inline NSMutableArray*
+ConvertToNSArray(nsTArray<ProxyAccessible*>& aArray)
+{
+  NSMutableArray* nativeArray = [[NSMutableArray alloc] init];
+
+  // iterate through the list, and get each native accessible.
+  size_t totalCount = aArray.Length();
+  for (size_t i = 0; i < totalCount; i++) {
+    ProxyAccessible* curAccessible = aArray.ElementAt(i);
+    mozAccessible* curNative = GetNativeFromProxy(curAccessible);
+    if (curNative)
+      [nativeArray addObject:GetObjectOrRepresentedView(curNative)];
+  }
+
+  return nativeArray;
+}
+
+@implementation mozTablePartAccessible
+- (BOOL)isLayoutTablePart;
+{
+  if (Accessible* accWrap = [self getGeckoAccessible]) {
+    while (accWrap) {
+      if (accWrap->IsTable()) {
+        return accWrap->AsTable()->IsProbablyLayoutTable();
+      }
+      accWrap = accWrap->Parent();
+    }
+    return false;
+  }
+
+  if (ProxyAccessible* proxy = [self getProxyAccessible]) {
+    while (proxy) {
+      if (proxy->IsTable()) {
+        return proxy->TableIsProbablyForLayout();
+      }
+      proxy = proxy->Parent();
+    }
+  }
+
+  return false;
+}
+
+- (NSString*)role
+{
+  return [self isLayoutTablePart] ? NSAccessibilityGroupRole : [super role];
+}
+@end
+
+@implementation mozTableAccessible
+- (NSArray*)additionalAccessibilityAttributeNames
+{
+  NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL;
+
+  NSArray* additionalAttributes = [super additionalAccessibilityAttributeNames];
+  if ([self isLayoutTablePart]) {
+    return additionalAttributes;
+  }
+
+  static NSArray* tableAttrs = nil;
+  if (!tableAttrs) {
+    NSMutableArray* tempArray = [NSMutableArray new];
+    [tempArray addObject:NSAccessibilityRowCountAttribute];
+    [tempArray addObject:NSAccessibilityColumnCountAttribute];
+    [tempArray addObject:NSAccessibilityRowsAttribute];
+    tableAttrs = [[NSArray alloc] initWithArray:tempArray];
+    [tempArray release];
+  }
+
+  return [additionalAttributes arrayByAddingObjectsFromArray:tableAttrs];
+
+  NS_OBJC_END_TRY_ABORT_BLOCK_NIL;
+}
+
+- (id)accessibilityAttributeValue:(NSString*)attribute
+{
+  if (AccessibleWrap* accWrap = [self getGeckoAccessible]) {
+    TableAccessible* table = accWrap->AsTable();
+    if ([attribute isEqualToString:NSAccessibilityRowCountAttribute])
+      return @(table->RowCount());
+    if ([attribute isEqualToString:NSAccessibilityColumnCountAttribute])
+      return @(table->ColCount());
+    if ([attribute isEqualToString:NSAccessibilityRowsAttribute]) {
+      // Create a new array with the list of table rows.
+      NSMutableArray* nativeArray = [[NSMutableArray alloc] init];
+      uint32_t totalCount = accWrap->ChildCount();
+      for (uint32_t i = 0; i < totalCount; i++) {
+        if (accWrap->GetChildAt(i)->IsTableRow()) {
+          mozAccessible* curNative =
+            GetNativeFromGeckoAccessible(accWrap->GetChildAt(i));
+          if (curNative)
+            [nativeArray addObject:GetObjectOrRepresentedView(curNative)];
+        }
+      }
+      return nativeArray;
+    }
+  } else if (ProxyAccessible* proxy = [self getProxyAccessible]) {
+    if ([attribute isEqualToString:NSAccessibilityRowCountAttribute])
+      return @(proxy->TableRowCount());
+    if ([attribute isEqualToString:NSAccessibilityColumnCountAttribute])
+      return @(proxy->TableColumnCount());
+    if ([attribute isEqualToString:NSAccessibilityRowsAttribute]) {
+      // Create a new array with the list of table rows.
+      NSMutableArray* nativeArray = [[NSMutableArray alloc] init];
+      uint32_t totalCount = proxy->ChildrenCount();
+      for (uint32_t i = 0; i < totalCount; i++) {
+        if (proxy->ChildAt(i)->IsTableRow()) {
+          mozAccessible* curNative =
+            GetNativeFromProxy(proxy->ChildAt(i));
+          if (curNative)
+            [nativeArray addObject:GetObjectOrRepresentedView(curNative)];
+        }
+      }
+      return nativeArray;
+    }
+  }
+
+  return [super accessibilityAttributeValue:attribute];
+}
+@end
+
+@implementation mozTableRowAccessible
+- (NSArray*)additionalAccessibilityAttributeNames
+{
+  NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL;
+
+  NSArray* additionalAttributes = [super additionalAccessibilityAttributeNames];
+  if ([self isLayoutTablePart]) {
+    return additionalAttributes;
+  }
+
+  static NSArray* tableRowAttrs = nil;
+  if (!tableRowAttrs) {
+    NSMutableArray* tempArray = [NSMutableArray new];
+    [tempArray addObject:NSAccessibilityIndexAttribute];
+    tableRowAttrs = [[NSArray alloc] initWithArray:tempArray];
+    [tempArray release];
+  }
+
+  return [additionalAttributes arrayByAddingObjectsFromArray:tableRowAttrs];
+
+  NS_OBJC_END_TRY_ABORT_BLOCK_NIL;
+}
+
+- (id)accessibilityAttributeValue:(NSString*)attribute
+{
+  if (AccessibleWrap* accWrap = [self getGeckoAccessible]) {
+    if ([attribute isEqualToString:NSAccessibilityIndexAttribute]) {
+      // Count the number of rows before that one to obtain the row index.
+      uint32_t index = 0;
+      Accessible* parent = accWrap->Parent();
+      if (parent) {
+        for (int32_t i = accWrap->IndexInParent() - 1; i >= 0; i--) {
+          if (parent->GetChildAt(i)->IsTableRow()) {
+            index++;
+          }
+        }
+      }
+      return [NSNumber numberWithUnsignedInteger:index];
+    }
+  } else if (ProxyAccessible* proxy = [self getProxyAccessible]) {
+    if ([attribute isEqualToString:NSAccessibilityIndexAttribute]) {
+      // Count the number of rows before that one to obtain the row index.
+      uint32_t index = 0;
+      ProxyAccessible* parent = proxy->Parent();
+      if (parent) {
+        for (int32_t i = proxy->IndexInParent() - 1; i >= 0; i--) {
+          if (parent->ChildAt(i)->IsTableRow()) {
+            index++;
+          }
+        }
+      }
+      return [NSNumber numberWithUnsignedInteger:index];
+    }
+  }
+
+  return [super accessibilityAttributeValue:attribute];
+}
+@end
+
+@implementation mozTableCellAccessible
+- (NSArray*)additionalAccessibilityAttributeNames
+{
+  NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL;
+
+  NSArray* additionalAttributes = [super additionalAccessibilityAttributeNames];
+  if ([self isLayoutTablePart]) {
+    return additionalAttributes;
+  }
+
+  static NSArray* tableCellAttrs = nil;
+  if (!tableCellAttrs) {
+    NSMutableArray* tempArray = [NSMutableArray new];
+    [tempArray addObject:NSAccessibilityRowIndexRangeAttribute];
+    [tempArray addObject:NSAccessibilityColumnIndexRangeAttribute];
+    [tempArray addObject:NSAccessibilityRowHeaderUIElementsAttribute];
+    [tempArray addObject:NSAccessibilityColumnHeaderUIElementsAttribute];
+    tableCellAttrs = [[NSArray alloc] initWithArray:tempArray];
+    [tempArray release];
+  }
+
+  return [additionalAttributes arrayByAddingObjectsFromArray:tableCellAttrs];
+
+  NS_OBJC_END_TRY_ABORT_BLOCK_NIL;
+}
+
+- (id)accessibilityAttributeValue:(NSString*)attribute
+{
+  if (AccessibleWrap* accWrap = [self getGeckoAccessible]) {
+    TableCellAccessible* cell = accWrap->AsTableCell();
+    if ([attribute isEqualToString:NSAccessibilityRowIndexRangeAttribute])
+      return [NSValue valueWithRange:NSMakeRange(cell->RowIdx(),
+                                                 cell->RowExtent())];
+    if ([attribute isEqualToString:NSAccessibilityColumnIndexRangeAttribute])
+      return [NSValue valueWithRange:NSMakeRange(cell->ColIdx(),
+                                                 cell->ColExtent())];
+    if ([attribute isEqualToString:NSAccessibilityRowHeaderUIElementsAttribute]) {
+      AutoTArray<Accessible*, 10> headerCells;
+      cell->RowHeaderCells(&headerCells);
+      return ConvertToNSArray(headerCells);
+    }
+    if ([attribute isEqualToString:NSAccessibilityColumnHeaderUIElementsAttribute]) {
+      AutoTArray<Accessible*, 10> headerCells;
+      cell->ColHeaderCells(&headerCells);
+      return ConvertToNSArray(headerCells);
+    }
+  } else if (ProxyAccessible* proxy = [self getProxyAccessible]) {
+    if ([attribute isEqualToString:NSAccessibilityRowIndexRangeAttribute])
+      return [NSValue valueWithRange:NSMakeRange(proxy->RowIdx(),
+                                                 proxy->RowExtent())];
+    if ([attribute isEqualToString:NSAccessibilityColumnIndexRangeAttribute])
+      return [NSValue valueWithRange:NSMakeRange(proxy->ColIdx(),
+                                                 proxy->ColExtent())];
+    if ([attribute isEqualToString:NSAccessibilityRowHeaderUIElementsAttribute]) {
+      nsTArray<ProxyAccessible*> headerCells;
+      proxy->RowHeaderCells(&headerCells);
+      return ConvertToNSArray(headerCells);
+    }
+    if ([attribute isEqualToString:NSAccessibilityColumnHeaderUIElementsAttribute]) {
+      nsTArray<ProxyAccessible*> headerCells;
+      proxy->ColHeaderCells(&headerCells);
+      return ConvertToNSArray(headerCells);
+    }
+  }
+
+  return [super accessibilityAttributeValue:attribute];
+}
+@end

accessible/mac/mozTextAccessible.h

@@ -0,0 +1,17 @@
+/* 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/. */
+
+#import "mozAccessible.h"
+
+#import "HyperTextAccessible.h"
+
+@interface mozTextAccessible : mozAccessible
+{
+}
+@end
+
+@interface mozTextLeafAccessible : mozAccessible
+{
+}
+@end

accessible/mac/mozTextAccessible.mm

@@ -0,0 +1,627 @@
+/* -*- Mode: Objective-C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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 "Accessible-inl.h"
+#include "HyperTextAccessible-inl.h"
+#include "TextLeafAccessible.h"
+
+#include "nsCocoaUtils.h"
+#include "nsObjCExceptions.h"
+
+#import "mozTextAccessible.h"
+
+using namespace mozilla;
+using namespace mozilla::a11y;
+
+inline bool
+ToNSRange(id aValue, NSRange* aRange)
+{
+  NS_PRECONDITION(aRange, "aRange is nil");
+
+  if ([aValue isKindOfClass:[NSValue class]] &&
+      strcmp([(NSValue*)aValue objCType], @encode(NSRange)) == 0) {
+    *aRange = [aValue rangeValue];
+    return true;
+  }
+
+  return false;
+}
+
+inline NSString*
+ToNSString(id aValue)
+{
+  if ([aValue isKindOfClass:[NSString class]]) {
+    return aValue;
+  }
+
+  return nil;
+}
+
+@interface mozTextAccessible ()
+- (NSString*)subrole;
+- (NSString*)selectedText;
+- (NSValue*)selectedTextRange;
+- (NSValue*)visibleCharacterRange;
+- (long)textLength;
+- (BOOL)isReadOnly;
+- (NSNumber*)caretLineNumber;
+- (void)setText:(NSString*)newText;
+- (NSString*)text;
+- (NSString*)stringFromRange:(NSRange*)range;
+@end
+
+@implementation mozTextAccessible
+
+- (BOOL)accessibilityIsIgnored
+{
+  return ![self getGeckoAccessible] && ![self getProxyAccessible];
+}
+
+- (NSArray*)accessibilityAttributeNames
+{
+  NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL;
+
+  static NSMutableArray* supportedAttributes = nil;
+  if (!supportedAttributes) {
+    // text-specific attributes to supplement the standard one
+    supportedAttributes = [[NSMutableArray alloc] initWithObjects:
+      NSAccessibilitySelectedTextAttribute, // required
+      NSAccessibilitySelectedTextRangeAttribute, // required
+      NSAccessibilityNumberOfCharactersAttribute, // required
+      NSAccessibilityVisibleCharacterRangeAttribute, // required
+      NSAccessibilityInsertionPointLineNumberAttribute,
+      @"AXRequired",
+      @"AXInvalid",
+      nil
+    ];
+    [supportedAttributes addObjectsFromArray:[super accessibilityAttributeNames]];
+  }
+  return supportedAttributes;
+
+  NS_OBJC_END_TRY_ABORT_BLOCK_NIL;
+}
+
+- (id)accessibilityAttributeValue:(NSString*)attribute
+{
+  NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL;
+
+  if ([attribute isEqualToString:NSAccessibilityNumberOfCharactersAttribute])
+    return [NSNumber numberWithInt:[self textLength]];
+
+  if ([attribute isEqualToString:NSAccessibilityInsertionPointLineNumberAttribute])
+    return [self caretLineNumber];
+
+  if ([attribute isEqualToString:NSAccessibilitySelectedTextRangeAttribute])
+    return [self selectedTextRange];
+
+  if ([attribute isEqualToString:NSAccessibilitySelectedTextAttribute])
+    return [self selectedText];
+
+  if ([attribute isEqualToString:NSAccessibilityTitleAttribute])
+    return @"";
+
+  if ([attribute isEqualToString:NSAccessibilityValueAttribute]) {
+    // Apple's SpeechSynthesisServer expects AXValue to return an AXStaticText
+    // object's AXSelectedText attribute. See bug 674612 for details.
+    // Also if there is no selected text, we return the full text.
+    // See bug 369710 for details.
+    if ([[self role] isEqualToString:NSAccessibilityStaticTextRole]) {
+      NSString* selectedText = [self selectedText];
+      return (selectedText && [selectedText length]) ? selectedText : [self text];
+    }
+
+    return [self text];
+  }
+
+  if (AccessibleWrap* accWrap = [self getGeckoAccessible]) {
+    if ([attribute isEqualToString:@"AXRequired"]) {
+      return [NSNumber numberWithBool:!!(accWrap->State() & states::REQUIRED)];
+    }
+
+    if ([attribute isEqualToString:@"AXInvalid"]) {
+      return [NSNumber numberWithBool:!!(accWrap->State() & states::INVALID)];
+    }
+  } else if (ProxyAccessible* proxy = [self getProxyAccessible]) {
+    if ([attribute isEqualToString:@"AXRequired"]) {
+      return [NSNumber numberWithBool:!!(proxy->State() & states::REQUIRED)];
+    }
+
+    if ([attribute isEqualToString:@"AXInvalid"]) {
+      return [NSNumber numberWithBool:!!(proxy->State() & states::INVALID)];
+    }
+  }
+
+  if ([attribute isEqualToString:NSAccessibilityVisibleCharacterRangeAttribute])
+    return [self visibleCharacterRange];
+
+  // let mozAccessible handle all other attributes
+  return [super accessibilityAttributeValue:attribute];
+
+  NS_OBJC_END_TRY_ABORT_BLOCK_NIL;
+}
+
+- (NSArray*)accessibilityParameterizedAttributeNames
+{
+  static NSArray* supportedParametrizedAttributes = nil;
+  // text specific parametrized attributes
+  if (!supportedParametrizedAttributes) {
+    supportedParametrizedAttributes = [[NSArray alloc] initWithObjects:
+      NSAccessibilityStringForRangeParameterizedAttribute,
+      NSAccessibilityLineForIndexParameterizedAttribute,
+      NSAccessibilityRangeForLineParameterizedAttribute,
+      NSAccessibilityAttributedStringForRangeParameterizedAttribute,
+      NSAccessibilityBoundsForRangeParameterizedAttribute,
+#if DEBUG
+      NSAccessibilityRangeForPositionParameterizedAttribute,
+      NSAccessibilityRangeForIndexParameterizedAttribute,
+      NSAccessibilityRTFForRangeParameterizedAttribute,
+      NSAccessibilityStyleRangeForIndexParameterizedAttribute,
+#endif
+      nil
+    ];
+  }
+  return supportedParametrizedAttributes;
+}
+
+- (id)accessibilityAttributeValue:(NSString*)attribute forParameter:(id)parameter
+{
+  AccessibleWrap* accWrap = [self getGeckoAccessible];
+  ProxyAccessible* proxy = [self getProxyAccessible];
+
+  HyperTextAccessible* textAcc = accWrap? accWrap->AsHyperText() : nullptr;
+  if (!textAcc && !proxy)
+    return nil;
+
+  if ([attribute isEqualToString:NSAccessibilityStringForRangeParameterizedAttribute]) {
+    NSRange range;
+    if (!ToNSRange(parameter, &range)) {
+#if DEBUG
+      NSLog(@"%@: range not set", attribute);
+#endif
+      return @"";
+    }
+
+    return [self stringFromRange:&range];
+  }
+
+  if ([attribute isEqualToString:NSAccessibilityRangeForLineParameterizedAttribute]) {
+    // XXX: actually get the integer value for the line #
+    return [NSValue valueWithRange:NSMakeRange(0, [self textLength])];
+  }
+
+  if ([attribute isEqualToString:NSAccessibilityAttributedStringForRangeParameterizedAttribute]) {
+    NSRange range;
+    if (!ToNSRange(parameter, &range)) {
+#if DEBUG
+      NSLog(@"%@: range not set", attribute);
+#endif
+      return @"";
+    }
+
+    return [[[NSAttributedString alloc] initWithString:[self stringFromRange:&range]] autorelease];
+  }
+
+  if ([attribute isEqualToString:NSAccessibilityLineForIndexParameterizedAttribute]) {
+    // XXX: actually return the line #
+    return [NSNumber numberWithInt:0];
+  }
+
+  if ([attribute isEqualToString:NSAccessibilityBoundsForRangeParameterizedAttribute]) {
+    NSRange range;
+    if (!ToNSRange(parameter, &range)) {
+#if DEBUG
+      NSLog(@"%@:no range", attribute);
+#endif
+      return nil;
+    }
+
+    int32_t start = range.location;
+    int32_t end = start + range.length;
+    DesktopIntRect bounds;
+    if (textAcc) {
+      bounds =
+        DesktopIntRect::FromUnknownRect(textAcc->TextBounds(start, end));
+    } else if (proxy) {
+      bounds =
+        DesktopIntRect::FromUnknownRect(proxy->TextBounds(start, end));
+    }
+
+    return [NSValue valueWithRect:nsCocoaUtils::GeckoRectToCocoaRect(bounds)];
+  }
+
+#if DEBUG
+  NSLog(@"unhandled attribute:%@ forParameter:%@", attribute, parameter);
+#endif
+
+  return nil;
+}
+
+- (BOOL)accessibilityIsAttributeSettable:(NSString*)attribute
+{
+  NS_OBJC_BEGIN_TRY_ABORT_BLOCK_RETURN;
+
+  if ([attribute isEqualToString:NSAccessibilityValueAttribute])
+    return ![self isReadOnly];
+
+  if ([attribute isEqualToString:NSAccessibilitySelectedTextAttribute] ||
+      [attribute isEqualToString:NSAccessibilitySelectedTextRangeAttribute] ||
+      [attribute isEqualToString:NSAccessibilityVisibleCharacterRangeAttribute])
+    return YES;
+
+  return [super accessibilityIsAttributeSettable:attribute];
+
+  NS_OBJC_END_TRY_ABORT_BLOCK_RETURN(NO);
+}
+
+- (void)accessibilitySetValue:(id)value forAttribute:(NSString *)attribute
+{
+  NS_OBJC_BEGIN_TRY_ABORT_BLOCK;
+
+  AccessibleWrap* accWrap = [self getGeckoAccessible];
+  ProxyAccessible* proxy = [self getProxyAccessible];
+
+  HyperTextAccessible* textAcc = accWrap? accWrap->AsHyperText() : nullptr;
+  if (!textAcc && !proxy)
+    return;
+
+  if ([attribute isEqualToString:NSAccessibilityValueAttribute]) {
+    [self setText:ToNSString(value)];
+
+    return;
+  }
+
+  if ([attribute isEqualToString:NSAccessibilitySelectedTextAttribute]) {
+    NSString* stringValue = ToNSString(value);
+    if (!stringValue)
+      return;
+
+    int32_t start = 0, end = 0;
+    nsString text;
+    if (textAcc) {
+      textAcc->SelectionBoundsAt(0, &start, &end);
+      textAcc->DeleteText(start, end - start);
+      nsCocoaUtils::GetStringForNSString(stringValue, text);
+      textAcc->InsertText(text, start);
+    } else if (proxy) {
+      nsString data;
+      proxy->SelectionBoundsAt(0, data, &start, &end);
+      proxy->DeleteText(start, end - start);
+      nsCocoaUtils::GetStringForNSString(stringValue, text);
+      proxy->InsertText(text, start);
+    }
+  }
+
+  if ([attribute isEqualToString:NSAccessibilitySelectedTextRangeAttribute]) {
+    NSRange range;
+    if (!ToNSRange(value, &range))
+      return;
+
+    if (textAcc) {
+      textAcc->SetSelectionBoundsAt(0, range.location,
+                                    range.location + range.length);
+    } else if (proxy) {
+      proxy->SetSelectionBoundsAt(0, range.location,
+                                  range.location + range.length);
+    }
+    return;
+  }
+
+  if ([attribute isEqualToString:NSAccessibilityVisibleCharacterRangeAttribute]) {
+    NSRange range;
+    if (!ToNSRange(value, &range))
+      return;
+
+    if (textAcc) {
+      textAcc->ScrollSubstringTo(range.location, range.location + range.length,
+                                 nsIAccessibleScrollType::SCROLL_TYPE_TOP_EDGE);
+    } else if (proxy) {
+      proxy->ScrollSubstringTo(range.location, range.location + range.length,
+                               nsIAccessibleScrollType::SCROLL_TYPE_TOP_EDGE);
+    }
+    return;
+  }
+
+  [super accessibilitySetValue:value forAttribute:attribute];
+
+  NS_OBJC_END_TRY_ABORT_BLOCK;
+}
+
+- (NSString*)subrole
+{
+  if(mRole == roles::PASSWORD_TEXT)
+    return NSAccessibilitySecureTextFieldSubrole;
+
+  return nil;
+}
+
+#pragma mark -
+
+- (BOOL)isReadOnly
+{
+  NS_OBJC_BEGIN_TRY_ABORT_BLOCK_RETURN;
+
+  if ([[self role] isEqualToString:NSAccessibilityStaticTextRole])
+    return YES;
+
+  AccessibleWrap* accWrap = [self getGeckoAccessible];
+  HyperTextAccessible* textAcc = accWrap? accWrap->AsHyperText() : nullptr;
+  if (textAcc)
+    return (accWrap->State() & states::READONLY) == 0;
+
+  if (ProxyAccessible* proxy = [self getProxyAccessible])
+    return (proxy->State() & states::READONLY) == 0;
+
+  return NO;
+
+  NS_OBJC_END_TRY_ABORT_BLOCK_RETURN(NO);
+}
+
+- (NSNumber*)caretLineNumber
+{
+  AccessibleWrap* accWrap = [self getGeckoAccessible];
+  HyperTextAccessible* textAcc = accWrap? accWrap->AsHyperText() : nullptr;
+
+  int32_t lineNumber = -1;
+  if (textAcc) {
+    lineNumber = textAcc->CaretLineNumber() - 1;
+  } else if (ProxyAccessible* proxy = [self getProxyAccessible]) {
+    lineNumber = proxy->CaretLineNumber() - 1;
+  }
+
+  return (lineNumber >= 0) ? [NSNumber numberWithInt:lineNumber] : nil;
+}
+
+- (void)setText:(NSString*)aNewString
+{
+  NS_OBJC_BEGIN_TRY_ABORT_BLOCK;
+
+  AccessibleWrap* accWrap = [self getGeckoAccessible];
+  HyperTextAccessible* textAcc = accWrap? accWrap->AsHyperText() : nullptr;
+
+  nsString text;
+  nsCocoaUtils::GetStringForNSString(aNewString, text);
+  if (textAcc) {
+    textAcc->ReplaceText(text);
+  } else if (ProxyAccessible* proxy = [self getProxyAccessible]) {
+    proxy->ReplaceText(text);
+  }
+
+  NS_OBJC_END_TRY_ABORT_BLOCK;
+}
+
+- (NSString*)text
+{
+  AccessibleWrap* accWrap = [self getGeckoAccessible];
+  ProxyAccessible* proxy = [self getProxyAccessible];
+  HyperTextAccessible* textAcc = accWrap? accWrap->AsHyperText() : nullptr;
+  if (!textAcc && !proxy)
+    return nil;
+
+  // A password text field returns an empty value
+  if (mRole == roles::PASSWORD_TEXT)
+    return @"";
+
+  nsAutoString text;
+  if (textAcc) {
+    textAcc->TextSubstring(0, nsIAccessibleText::TEXT_OFFSET_END_OF_TEXT, text);
+  } else if (proxy) {
+    proxy->TextSubstring(0, nsIAccessibleText::TEXT_OFFSET_END_OF_TEXT, text);
+  }
+
+  return nsCocoaUtils::ToNSString(text);
+}
+
+- (long)textLength
+{
+  NS_OBJC_BEGIN_TRY_ABORT_BLOCK_RETURN;
+
+  AccessibleWrap* accWrap = [self getGeckoAccessible];
+  ProxyAccessible* proxy = [self getProxyAccessible];
+  HyperTextAccessible* textAcc = accWrap? accWrap->AsHyperText() : nullptr;
+  if (!textAcc && !proxy)
+    return 0;
+
+  return textAcc ? textAcc->CharacterCount() : proxy->CharacterCount();
+
+  NS_OBJC_END_TRY_ABORT_BLOCK_RETURN(0);
+}
+
+- (long)selectedTextLength
+{
+  NS_OBJC_BEGIN_TRY_ABORT_BLOCK_RETURN;
+
+  AccessibleWrap* accWrap = [self getGeckoAccessible];
+  ProxyAccessible* proxy = [self getProxyAccessible];
+  HyperTextAccessible* textAcc = accWrap? accWrap->AsHyperText() : nullptr;
+  if (!textAcc && !proxy)
+    return 0;
+
+  int32_t start = 0, end = 0;
+  if (textAcc) {
+    textAcc->SelectionBoundsAt(0, &start, &end);
+  } else if (proxy) {
+    nsString data;
+    proxy->SelectionBoundsAt(0, data, &start, &end);
+  }
+  return (end - start);
+
+  NS_OBJC_END_TRY_ABORT_BLOCK_RETURN(0);
+}
+
+- (NSString*)selectedText
+{
+  NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL;
+
+  AccessibleWrap* accWrap = [self getGeckoAccessible];
+  ProxyAccessible* proxy = [self getProxyAccessible];
+  HyperTextAccessible* textAcc = accWrap? accWrap->AsHyperText() : nullptr;
+  if (!textAcc && !proxy)
+    return nil;
+
+  int32_t start = 0, end = 0;
+  nsAutoString selText;
+  if (textAcc) {
+    textAcc->SelectionBoundsAt(0, &start, &end);
+    if (start != end) {
+      textAcc->TextSubstring(start, end, selText);
+    }
+  } else if (proxy) {
+    proxy->SelectionBoundsAt(0, selText, &start, &end);
+  }
+
+  return nsCocoaUtils::ToNSString(selText);
+
+  NS_OBJC_END_TRY_ABORT_BLOCK_NIL;
+}
+
+- (NSValue*)selectedTextRange
+{
+  NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL;
+
+  AccessibleWrap* accWrap = [self getGeckoAccessible];
+  ProxyAccessible* proxy = [self getProxyAccessible];
+  HyperTextAccessible* textAcc = accWrap? accWrap->AsHyperText() : nullptr;
+
+  int32_t start = 0;
+  int32_t end = 0;
+  int32_t count = 0;
+  if (textAcc) {
+    count = textAcc->SelectionCount();
+    if (count) {
+      textAcc->SelectionBoundsAt(0, &start, &end);
+      return [NSValue valueWithRange:NSMakeRange(start, end - start)];
+    }
+
+    start = textAcc->CaretOffset();
+    return [NSValue valueWithRange:NSMakeRange(start != -1 ? start : 0, 0)];
+  }
+
+  if (proxy) {
+    count = proxy->SelectionCount();
+    if (count) {
+      nsString data;
+      proxy->SelectionBoundsAt(0, data, &start, &end);
+      return [NSValue valueWithRange:NSMakeRange(start, end - start)];
+    }
+
+    start = proxy->CaretOffset();
+    return [NSValue valueWithRange:NSMakeRange(start != -1 ? start : 0, 0)];
+  }
+
+  return [NSValue valueWithRange:NSMakeRange(0, 0)];
+
+  NS_OBJC_END_TRY_ABORT_BLOCK_NIL;
+}
+
+- (NSValue*)visibleCharacterRange
+{
+  // XXX this won't work with Textarea and such as we actually don't give
+  // the visible character range.
+  AccessibleWrap* accWrap = [self getGeckoAccessible];
+  ProxyAccessible* proxy = [self getProxyAccessible];
+  HyperTextAccessible* textAcc = accWrap? accWrap->AsHyperText() : nullptr;
+  if (!textAcc && !proxy)
+    return 0;
+
+  return [NSValue valueWithRange:
+    NSMakeRange(0, textAcc ?
+                textAcc->CharacterCount() : proxy->CharacterCount())];
+}
+
+- (void)valueDidChange
+{
+  NS_OBJC_BEGIN_TRY_ABORT_BLOCK;
+
+  NSAccessibilityPostNotification(GetObjectOrRepresentedView(self),
+                                  NSAccessibilityValueChangedNotification);
+
+  NS_OBJC_END_TRY_ABORT_BLOCK;
+}
+
+- (void)selectedTextDidChange
+{
+  NSAccessibilityPostNotification(GetObjectOrRepresentedView(self),
+                                  NSAccessibilitySelectedTextChangedNotification);
+}
+
+- (NSString*)stringFromRange:(NSRange*)range
+{
+  NS_PRECONDITION(range, "no range");
+
+  AccessibleWrap* accWrap = [self getGeckoAccessible];
+  ProxyAccessible* proxy = [self getProxyAccessible];
+  HyperTextAccessible* textAcc = accWrap? accWrap->AsHyperText() : nullptr;
+  if (!textAcc && !proxy)
+    return nil;
+
+  nsAutoString text;
+  if (textAcc) {
+    textAcc->TextSubstring(range->location,
+                           range->location + range->length, text);
+  } else if (proxy) {
+    proxy->TextSubstring(range->location,
+                           range->location + range->length, text);
+  }
+
+  return nsCocoaUtils::ToNSString(text);
+}
+
+@end
+
+@implementation mozTextLeafAccessible
+
+- (NSArray*)accessibilityAttributeNames
+{
+  static NSMutableArray* supportedAttributes = nil;
+  if (!supportedAttributes) {
+    supportedAttributes = [[super accessibilityAttributeNames] mutableCopy];
+    [supportedAttributes removeObject:NSAccessibilityChildrenAttribute];
+  }
+
+  return supportedAttributes;
+}
+
+- (id)accessibilityAttributeValue:(NSString*)attribute
+{
+  if ([attribute isEqualToString:NSAccessibilityTitleAttribute])
+    return @"";
+
+  if ([attribute isEqualToString:NSAccessibilityValueAttribute])
+    return [self text];
+
+  return [super accessibilityAttributeValue:attribute];
+}
+
+- (NSString*)text
+{
+  if (AccessibleWrap* accWrap = [self getGeckoAccessible]) {
+    return nsCocoaUtils::ToNSString(accWrap->AsTextLeaf()->Text());
+  }
+
+  if (ProxyAccessible* proxy = [self getProxyAccessible]) {
+    nsString text;
+    proxy->Text(&text);
+    return nsCocoaUtils::ToNSString(text);
+  }
+
+  return nil;
+}
+
+- (long)textLength
+{
+  if (AccessibleWrap* accWrap = [self getGeckoAccessible]) {
+    return accWrap->AsTextLeaf()->Text().Length();
+  }
+
+  if (ProxyAccessible* proxy = [self getProxyAccessible]) {
+    nsString text;
+    proxy->Text(&text);
+    return text.Length();
+  }
+
+  return 0;
+}
+
+@end

accessible/moz.build

@@ -9,6 +9,8 @@ if 'gtk' in toolkit:
     DIRS += ['atk']
 elif toolkit == 'windows':
     DIRS += ['windows']
+elif toolkit == 'cocoa':
+    DIRS += ['mac']
 else:
     DIRS += ['other']
 

accessible/tests/mochitest/treeupdate/test_cssoverflow.html

@@ -67,7 +67,7 @@
      * Change scrollbar styles from hidden to auto. That makes us to create an
      * accessible for scroll area.
      */
-    function changeScrollStyles(aContainerID, aScrollAreaID)
+    function changeScrollbarStyles(aContainerID, aScrollAreaID)
     {
       this.container = getAccessible(aContainerID);
       this.scrollAreaNode = getNode(aScrollAreaID);
@@ -77,7 +77,7 @@
         new invokerChecker(EVENT_REORDER, this.container)
       ];
 
-      this.invoke = function changeScrollStyles_invoke()
+      this.invoke = function changeScrollbarStyles_invoke()
       {
         var accTree =
           { SECTION: [] };
@@ -86,7 +86,7 @@
         this.scrollAreaNode.style.overflow = "auto";
       }
 
-      this.finalCheck = function changeScrollStyles_finalCheck()
+      this.finalCheck = function changeScrollbarStyles_finalCheck()
       {
         var accTree =
           { SECTION: [ // container
@@ -95,7 +95,7 @@
         testAccessibleTree(this.container, accTree);
       }
 
-      this.getID = function changeScrollStyles_getID()
+      this.getID = function changeScrollbarStyles_getID()
       {
         return "change scrollbar styles " + prettyName(aScrollAreaID);
       }
@@ -114,7 +114,7 @@
       gQueue = new eventQueue();
 
       gQueue.push(new changeScrollRange("container", "scrollarea"));
-      gQueue.push(new changeScrollStyles("container2", "scrollarea2"));
+      gQueue.push(new changeScrollbarStyles("container2", "scrollarea2"));
 
       gQueue.invoke(); // Will call SimpleTest.finish();
     }

accessible/xpcom/moz.build

@@ -42,6 +42,10 @@ elif CONFIG['MOZ_WIDGET_TOOLKIT'] == 'windows':
     LOCAL_INCLUDES += [
         '/accessible/windows/msaa',
     ]
+elif CONFIG['MOZ_WIDGET_TOOLKIT'] == 'cocoa':
+    LOCAL_INCLUDES += [
+        '/accessible/mac',
+    ]
 else:
     LOCAL_INCLUDES += [
         '/accessible/other',

accessible/xul/moz.build

@@ -37,6 +37,10 @@ elif CONFIG['MOZ_WIDGET_TOOLKIT'] == 'windows':
         '/accessible/windows/ia2',
         '/accessible/windows/msaa',
     ]
+elif CONFIG['MOZ_WIDGET_TOOLKIT'] == 'cocoa':
+    LOCAL_INCLUDES += [
+        '/accessible/mac',
+    ]
 else:
     LOCAL_INCLUDES += [
         '/accessible/other',

aclocal.m4

@@ -21,6 +21,7 @@ builtin(include, build/autoconf/frameptr.m4)dnl
 builtin(include, build/autoconf/compiler-opts.m4)dnl
 builtin(include, build/autoconf/expandlibs.m4)dnl
 builtin(include, build/autoconf/arch.m4)dnl
+builtin(include, build/autoconf/android.m4)dnl
 builtin(include, build/autoconf/zlib.m4)dnl
 builtin(include, build/autoconf/icu.m4)dnl
 builtin(include, build/autoconf/clang-plugin.m4)dnl

build/autoconf/android.m4

@@ -0,0 +1,376 @@
+dnl This Source Code Form is subject to the terms of the Mozilla Public
+dnl License, v. 2.0. If a copy of the MPL was not distributed with this
+dnl file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+AC_DEFUN([MOZ_ANDROID_NDK],
+[
+
+MOZ_ARG_WITH_STRING(android-cxx-stl,
+[  --with-android-cxx-stl=VALUE
+                          use the specified C++ STL (libstdc++, libc++)],
+    android_cxx_stl=$withval,
+    android_cxx_stl=libc++)
+
+case "$target" in
+*-android*|*-linuxandroid*)
+    dnl $android_platform will be set for us by Python configure.
+    CPPFLAGS="-idirafter $android_platform/usr/include $CPPFLAGS"
+    CFLAGS="-fno-short-enums -fno-exceptions $CFLAGS"
+    CXXFLAGS="-fno-short-enums -fno-exceptions $CXXFLAGS"
+    ASFLAGS="-idirafter $android_platform/usr/include -DANDROID $ASFLAGS"
+
+    dnl Add --allow-shlib-undefined, because libGLESv2 links to an
+    dnl undefined symbol (present on the hardware, just not in the
+    dnl NDK.)
+    LDFLAGS="-L$android_platform/usr/lib -Wl,-rpath-link=$android_platform/usr/lib --sysroot=$android_platform -Wl,--allow-shlib-undefined $LDFLAGS"
+    dnl Add -llog by default, since we use it all over the place.
+    LIBS="-llog $LIBS"
+    ANDROID_PLATFORM="${android_platform}"
+
+    AC_DEFINE(ANDROID)
+    AC_SUBST(ANDROID_PLATFORM)
+
+    ;;
+esac
+
+])
+
+AC_DEFUN([MOZ_ANDROID_CPU_ARCH],
+[
+
+if test "$OS_TARGET" = "Android"; then
+    case "${CPU_ARCH}-${MOZ_ARCH}" in
+    arm-armv7*)
+        ANDROID_CPU_ARCH=armeabi-v7a
+        ;;
+    arm-*)
+        ANDROID_CPU_ARCH=armeabi
+        ;;
+    x86-*)
+        ANDROID_CPU_ARCH=x86
+        ;;
+    mips32-*) # When target_cpu is mipsel, CPU_ARCH is mips32
+        ANDROID_CPU_ARCH=mips
+        ;;
+    aarch64-*)
+        ANDROID_CPU_ARCH=arm64-v8a
+        ;;
+    esac
+
+    AC_SUBST(ANDROID_CPU_ARCH)
+fi
+])
+
+AC_DEFUN([MOZ_ANDROID_STLPORT],
+[
+
+if test "$OS_TARGET" = "Android"; then
+    cpu_arch_dir="$ANDROID_CPU_ARCH"
+    # NDK r12 removed the arm/thumb library split and just made everything
+    # thumb by default.  Attempt to compensate.
+    if test "$MOZ_THUMB2" = 1 -a -d "$cpu_arch_dir/thumb"; then
+        cpu_arch_dir="$cpu_arch_dir/thumb"
+    fi
+
+    if test -z "$STLPORT_CPPFLAGS$STLPORT_LIBS"; then
+        case "$android_cxx_stl" in
+        libstdc++)
+            # android-ndk-r8b and later
+            ndk_base="$android_ndk/sources/cxx-stl/gnu-libstdc++/$android_gnu_compiler_version"
+            ndk_libs_include="$ndk_base/libs/$ANDROID_CPU_ARCH"
+            ndk_libs="$ndk_base/libs/$cpu_arch_dir"
+            ndk_include="$ndk_base/include"
+
+            if ! test -e "$ndk_libs/libgnustl_static.a"; then
+                AC_MSG_ERROR([Couldn't find path to gnu-libstdc++ in the android ndk])
+            fi
+
+            STLPORT_LIBS="-L$ndk_libs -lgnustl_static"
+            STLPORT_CPPFLAGS="-I$ndk_include -I$ndk_include/backward -I$ndk_libs_include/include"
+            ;;
+        libc++)
+            # android-ndk-r8b and later
+            ndk_base="$android_ndk/sources/cxx-stl"
+            cxx_base="$ndk_base/llvm-libc++"
+            cxx_libs="$cxx_base/libs/$cpu_arch_dir"
+            cxx_include="$cxx_base/libcxx/include"
+            cxxabi_base="$ndk_base/llvm-libc++abi"
+            cxxabi_include="$cxxabi_base/libcxxabi/include"
+
+            if ! test -e "$cxx_libs/libc++_static.a"; then
+                AC_MSG_ERROR([Couldn't find path to llvm-libc++ in the android ndk])
+            fi
+
+            STLPORT_LIBS="-L$cxx_libs -lc++_static"
+            # NDK r12 split the libc++ runtime libraries into pieces.
+            for lib in c++abi unwind android_support; do
+                if test -e "$cxx_libs/lib${lib}.a"; then
+                     STLPORT_LIBS="$STLPORT_LIBS -l${lib}"
+                fi
+            done
+            # Add android/support/include/ for prototyping long double math
+            # functions, locale-specific C library functions, multibyte support,
+            # etc.
+            STLPORT_CPPFLAGS="-I$android_ndk/sources/android/support/include -I$cxx_include -I$cxxabi_include"
+            ;;
+        *)
+            AC_MSG_ERROR([Bad value for --enable-android-cxx-stl])
+            ;;
+        esac
+    fi
+    CXXFLAGS="$CXXFLAGS $STLPORT_CPPFLAGS"
+fi
+MOZ_ANDROID_CXX_STL=$android_cxx_stl
+AC_SUBST([MOZ_ANDROID_CXX_STL])
+AC_SUBST([STLPORT_LIBS])
+
+])
+
+
+AC_DEFUN([concat],[$1$2$3$4])
+
+dnl Find a component of an AAR.
+dnl Arg 1: variable name to expose, like ANDROID_SUPPORT_V4_LIB.
+dnl Arg 2: path to component.
+dnl Arg 3: if non-empty, expect and require component.
+AC_DEFUN([MOZ_ANDROID_AAR_COMPONENT], [
+  ifelse([$3], ,
+  [
+    if test -e "$$1" ; then
+      AC_MSG_ERROR([Found unexpected exploded $1!])
+    fi
+  ],
+  [
+    AC_MSG_CHECKING([for $1])
+    $1="$2"
+    if ! test -e "$$1" ; then
+      AC_MSG_ERROR([Could not find required exploded $1!])
+    fi
+    AC_MSG_RESULT([$$1])
+    AC_SUBST($1)
+  ])
+])
+
+dnl Find an AAR and expose variables representing its exploded components.
+dnl AC_SUBSTs ANDROID_NAME_{AAR,AAR_RES,AAR_LIB,AAR_INTERNAL_LIB}.
+dnl Arg 1: name, like play-services-base
+dnl Arg 2: version, like 7.8.0
+dnl Arg 3: extras subdirectory, either android or google
+dnl Arg 4: package subdirectory, like com/google/android/gms
+dnl Arg 5: if non-empty, expect and require internal_impl JAR.
+dnl Arg 6: if non-empty, expect and require assets/ directory.
+AC_DEFUN([MOZ_ANDROID_AAR],[
+  define([local_aar_var_base], translit($1, [-a-z], [_A-Z]))
+  define([local_aar_var], concat(ANDROID_, local_aar_var_base, _AAR))
+  local_aar_var="$ANDROID_SDK_ROOT/extras/$3/m2repository/$4/$1/$2/$1-$2.aar"
+  AC_MSG_CHECKING([for $1 AAR])
+  if ! test -e "$local_aar_var" ; then
+    AC_MSG_ERROR([You must download the $1 AAR.  Run the Android SDK tool and install the Android and Google Support Repositories under Extras.  See https://developer.android.com/tools/extras/support-library.html for more info. (Looked for $local_aar_var)])
+  fi
+  AC_SUBST(local_aar_var)
+  AC_MSG_RESULT([$local_aar_var])
+
+  if ! $PYTHON -m mozbuild.action.explode_aar --destdir=$MOZ_BUILD_ROOT/dist/exploded-aar $local_aar_var ; then
+    AC_MSG_ERROR([Could not explode $local_aar_var!])
+  fi
+
+  define([root], $MOZ_BUILD_ROOT/dist/exploded-aar/$1-$2/)
+  MOZ_ANDROID_AAR_COMPONENT(concat(local_aar_var, _LIB), concat(root, $1-$2-classes.jar), REQUIRED)
+  MOZ_ANDROID_AAR_COMPONENT(concat(local_aar_var, _RES), concat(root, res), REQUIRED)
+  MOZ_ANDROID_AAR_COMPONENT(concat(local_aar_var, _INTERNAL_LIB), concat(root, libs/$1-$2-internal_impl-$2.jar), $5)
+  MOZ_ANDROID_AAR_COMPONENT(concat(local_aar_var, _ASSETS), concat(root, assets), $6)
+])
+
+AC_DEFUN([MOZ_ANDROID_GOOGLE_PLAY_SERVICES],
+[
+
+if test -n "$MOZ_NATIVE_DEVICES" ; then
+    AC_SUBST(MOZ_NATIVE_DEVICES)
+
+    MOZ_ANDROID_AAR(play-services-base, $ANDROID_GOOGLE_PLAY_SERVICES_VERSION, google, com/google/android/gms)
+    MOZ_ANDROID_AAR(play-services-basement, $ANDROID_GOOGLE_PLAY_SERVICES_VERSION, google, com/google/android/gms)
+    MOZ_ANDROID_AAR(play-services-cast, $ANDROID_GOOGLE_PLAY_SERVICES_VERSION, google, com/google/android/gms)
+    MOZ_ANDROID_AAR(mediarouter-v7, $ANDROID_SUPPORT_LIBRARY_VERSION, android, com/android/support, REQUIRED_INTERNAL_IMPL)
+fi
+
+])
+
+AC_DEFUN([MOZ_ANDROID_GOOGLE_CLOUD_MESSAGING],
+[
+
+if test -n "$MOZ_ANDROID_GCM" ; then
+    MOZ_ANDROID_AAR(play-services-base, $ANDROID_GOOGLE_PLAY_SERVICES_VERSION, google, com/google/android/gms)
+    MOZ_ANDROID_AAR(play-services-basement, $ANDROID_GOOGLE_PLAY_SERVICES_VERSION, google, com/google/android/gms)
+    MOZ_ANDROID_AAR(play-services-gcm, $ANDROID_GOOGLE_PLAY_SERVICES_VERSION, google, com/google/android/gms)
+    MOZ_ANDROID_AAR(play-services-measurement, $ANDROID_GOOGLE_PLAY_SERVICES_VERSION, google, com/google/android/gms)
+fi
+
+])
+
+AC_DEFUN([MOZ_ANDROID_INSTALL_TRACKING],
+[
+
+if test -n "$MOZ_INSTALL_TRACKING"; then
+    AC_SUBST(MOZ_INSTALL_TRACKING)
+    MOZ_ANDROID_AAR(play-services-ads, $ANDROID_GOOGLE_PLAY_SERVICES_VERSION, google, com/google/android/gms)
+    MOZ_ANDROID_AAR(play-services-basement, $ANDROID_GOOGLE_PLAY_SERVICES_VERSION, google, com/google/android/gms)
+fi
+
+])
+
+dnl Configure an Android SDK.
+dnl Arg 1: target SDK version, like 23.
+dnl Arg 2: list of build-tools versions, like "23.0.3 23.0.1".
+AC_DEFUN([MOZ_ANDROID_SDK],
+[
+
+MOZ_ARG_WITH_STRING(android-sdk,
+[  --with-android-sdk=DIR
+                          location where the Android SDK can be found (like ~/.mozbuild/android-sdk-linux)],
+    android_sdk_root=$withval)
+
+android_sdk_root=${withval%/platforms/android-*}
+
+case "$target" in
+*-android*|*-linuxandroid*)
+    if test -z "$android_sdk_root" ; then
+        AC_MSG_ERROR([You must specify --with-android-sdk=/path/to/sdk when targeting Android.])
+    fi
+
+    # We were given an old-style
+    # --with-android-sdk=/path/to/sdk/platforms/android-*.  We could warn, but
+    # we'll get compliance by forcing the issue.
+    if test -e "$withval"/source.properties ; then
+        AC_MSG_ERROR([Including platforms/android-* in --with-android-sdk arguments is deprecated.  Use --with-android-sdk=$android_sdk_root.])
+    fi
+
+    android_target_sdk=$1
+    AC_MSG_CHECKING([for Android SDK platform version $android_target_sdk])
+    android_sdk=$android_sdk_root/platforms/android-$android_target_sdk
+    if ! test -e "$android_sdk/source.properties" ; then
+        AC_MSG_ERROR([You must download Android SDK platform version $android_target_sdk.  Try |mach bootstrap|.  (Looked for $android_sdk)])
+    fi
+    AC_MSG_RESULT([$android_sdk])
+
+    AC_MSG_CHECKING([for Android build-tools])
+    android_build_tools_base="$android_sdk_root"/build-tools
+    android_build_tools_version=""
+    for version in $2; do
+        android_build_tools="$android_build_tools_base"/$version
+        if test -d "$android_build_tools" -a -f "$android_build_tools/aapt"; then
+            android_build_tools_version=$version
+            AC_MSG_RESULT([$android_build_tools])
+            break
+        fi
+    done
+    if test "$android_build_tools_version" = ""; then
+        version=$(echo $2 | cut -d" " -f1)
+        AC_MSG_ERROR([You must install the Android build-tools version $version.  Try |mach bootstrap|.  (Looked for "$android_build_tools_base"/$version)])
+    fi
+
+    MOZ_PATH_PROG(ZIPALIGN, zipalign, :, [$android_build_tools])
+    MOZ_PATH_PROG(DX, dx, :, [$android_build_tools])
+    MOZ_PATH_PROG(AAPT, aapt, :, [$android_build_tools])
+    MOZ_PATH_PROG(AIDL, aidl, :, [$android_build_tools])
+    if test -z "$ZIPALIGN" -o "$ZIPALIGN" = ":"; then
+      AC_MSG_ERROR([The program zipalign was not found.  Try |mach bootstrap|.])
+    fi
+    if test -z "$DX" -o "$DX" = ":"; then
+      AC_MSG_ERROR([The program dx was not found.  Try |mach bootstrap|.])
+    fi
+    if test -z "$AAPT" -o "$AAPT" = ":"; then
+      AC_MSG_ERROR([The program aapt was not found.  Try |mach bootstrap|.])
+    fi
+    if test -z "$AIDL" -o "$AIDL" = ":"; then
+      AC_MSG_ERROR([The program aidl was not found.  Try |mach bootstrap|.])
+    fi
+
+    android_platform_tools="$android_sdk_root"/platform-tools
+    AC_MSG_CHECKING([for Android platform-tools])
+    if test -d "$android_platform_tools" -a -f "$android_platform_tools/adb"; then
+        AC_MSG_RESULT([$android_platform_tools])
+    else
+        AC_MSG_ERROR([You must install the Android platform-tools.  Try |mach bootstrap|.  (Looked for $android_platform_tools)])
+    fi
+
+    MOZ_PATH_PROG(ADB, adb, :, [$android_platform_tools])
+    if test -z "$ADB" -o "$ADB" = ":"; then
+      AC_MSG_ERROR([The program adb was not found.  Try |mach bootstrap|.])
+    fi
+
+    android_tools="$android_sdk_root"/tools
+    AC_MSG_CHECKING([for Android tools])
+    if test -d "$android_tools" -a -f "$android_tools/emulator"; then
+        AC_MSG_RESULT([$android_tools])
+    else
+        AC_MSG_ERROR([You must install the Android tools.  Try |mach bootstrap|.  (Looked for $android_tools)])
+    fi
+
+    MOZ_PATH_PROG(EMULATOR, emulator, :, [$android_tools])
+    if test -z "$EMULATOR" -o "$EMULATOR" = ":"; then
+      AC_MSG_ERROR([The program emulator was not found.  Try |mach bootstrap|.])
+    fi
+
+    ANDROID_TARGET_SDK="${android_target_sdk}"
+    ANDROID_SDK="${android_sdk}"
+    ANDROID_SDK_ROOT="${android_sdk_root}"
+    ANDROID_TOOLS="${android_tools}"
+    ANDROID_BUILD_TOOLS_VERSION="$android_build_tools_version"
+    AC_DEFINE_UNQUOTED(ANDROID_TARGET_SDK,$ANDROID_TARGET_SDK)
+    AC_SUBST(ANDROID_TARGET_SDK)
+    AC_SUBST(ANDROID_SDK_ROOT)
+    AC_SUBST(ANDROID_SDK)
+    AC_SUBST(ANDROID_TOOLS)
+    AC_SUBST(ANDROID_BUILD_TOOLS_VERSION)
+
+    MOZ_ANDROID_AAR(customtabs, $ANDROID_SUPPORT_LIBRARY_VERSION, android, com/android/support)
+    MOZ_ANDROID_AAR(appcompat-v7, $ANDROID_SUPPORT_LIBRARY_VERSION, android, com/android/support)
+    MOZ_ANDROID_AAR(support-vector-drawable, $ANDROID_SUPPORT_LIBRARY_VERSION, android, com/android/support)
+    MOZ_ANDROID_AAR(animated-vector-drawable, $ANDROID_SUPPORT_LIBRARY_VERSION, android, com/android/support)
+    MOZ_ANDROID_AAR(cardview-v7, $ANDROID_SUPPORT_LIBRARY_VERSION, android, com/android/support)
+    MOZ_ANDROID_AAR(design, $ANDROID_SUPPORT_LIBRARY_VERSION, android, com/android/support)
+    MOZ_ANDROID_AAR(recyclerview-v7, $ANDROID_SUPPORT_LIBRARY_VERSION, android, com/android/support)
+    MOZ_ANDROID_AAR(support-v4, $ANDROID_SUPPORT_LIBRARY_VERSION, android, com/android/support, REQUIRED_INTERNAL_IMPL)
+    MOZ_ANDROID_AAR(palette-v7, $ANDROID_SUPPORT_LIBRARY_VERSION, android, com/android/support)
+
+    ANDROID_SUPPORT_ANNOTATIONS_JAR="$ANDROID_SDK_ROOT/extras/android/m2repository/com/android/support/support-annotations/$ANDROID_SUPPORT_LIBRARY_VERSION/support-annotations-$ANDROID_SUPPORT_LIBRARY_VERSION.jar"
+    AC_MSG_CHECKING([for support-annotations JAR])
+    if ! test -e $ANDROID_SUPPORT_ANNOTATIONS_JAR ; then
+        AC_MSG_ERROR([You must download the support-annotations lib.  Run the Android SDK tool and install the Android Support Repository under Extras.  See https://developer.android.com/tools/extras/support-library.html for more info. (looked for $ANDROID_SUPPORT_ANNOTATIONS_JAR)])
+    fi
+    AC_MSG_RESULT([$ANDROID_SUPPORT_ANNOTATIONS_JAR])
+    AC_SUBST(ANDROID_SUPPORT_ANNOTATIONS_JAR)
+    ANDROID_SUPPORT_ANNOTATIONS_JAR_LIB=$ANDROID_SUPPORT_ANNOTATIONS_JAR
+    AC_SUBST(ANDROID_SUPPORT_ANNOTATIONS_JAR_LIB)
+    ;;
+esac
+
+MOZ_ARG_WITH_STRING(android-min-sdk,
+[  --with-android-min-sdk=[VER]     Impose a minimum Firefox for Android SDK version],
+[ MOZ_ANDROID_MIN_SDK_VERSION=$withval ])
+
+MOZ_ARG_WITH_STRING(android-max-sdk,
+[  --with-android-max-sdk=[VER]     Impose a maximum Firefox for Android SDK version],
+[ MOZ_ANDROID_MAX_SDK_VERSION=$withval ])
+
+if test -n "$MOZ_ANDROID_MIN_SDK_VERSION"; then
+    if test -n "$MOZ_ANDROID_MAX_SDK_VERSION"; then
+        if test $MOZ_ANDROID_MAX_SDK_VERSION -lt $MOZ_ANDROID_MIN_SDK_VERSION ; then
+            AC_MSG_ERROR([--with-android-max-sdk must be at least the value of --with-android-min-sdk.])
+        fi
+    fi
+
+    if test $MOZ_ANDROID_MIN_SDK_VERSION -gt $ANDROID_TARGET_SDK ; then
+        AC_MSG_ERROR([--with-android-min-sdk is expected to be less than $ANDROID_TARGET_SDK])
+    fi
+
+    AC_DEFINE_UNQUOTED(MOZ_ANDROID_MIN_SDK_VERSION, $MOZ_ANDROID_MIN_SDK_VERSION)
+    AC_SUBST(MOZ_ANDROID_MIN_SDK_VERSION)
+fi
+
+if test -n "$MOZ_ANDROID_MAX_SDK_VERSION"; then
+    AC_DEFINE_UNQUOTED(MOZ_ANDROID_MAX_SDK_VERSION, $MOZ_ANDROID_MAX_SDK_VERSION)
+    AC_SUBST(MOZ_ANDROID_MAX_SDK_VERSION)
+fi
+
+])

build/gecko_templates.mozbuild

@@ -63,11 +63,6 @@ def GeckoBinary(linkage='dependent', msvcrt='dynamic', mozglue=None):
                     LDFLAGS += ['-rdynamic']
                 if CONFIG['MOZ_MEMORY']:
                     USE_LIBS += ['memory']
-                    if CONFIG['OS_ARCH'] == 'FreeBSD':
-                        # Make sure this function is linked in, so that it is
-                        # executed at executable load (it has the 'constructor'
-                        # flag).
-                        LDFLAGS += ['-u', 'jemalloc_FreeBSD_init']
         elif mozglue == 'library':
             LIBRARY_DEFINES['MOZ_HAS_MOZGLUE'] = True
             if not CONFIG['MOZ_GLUE_IN_PROGRAM']:

build/gyp.mozbuild

@@ -87,6 +87,7 @@ flavors = {
     'WINNT': 'win',
     'Android': 'android',
     'Linux': 'linux',
+    'Darwin': 'mac' if CONFIG['MOZ_WIDGET_TOOLKIT'] == 'cocoa' else 'ios',
     'SunOS': 'solaris',
     'GNU/kFreeBSD': 'freebsd',
     'DragonFly': 'dragonfly',

build/mach_bootstrap.py

@@ -90,6 +90,9 @@ SEARCH_PATHS = [
     'testing/mozbase/manifestparser',
     'testing/taskcluster',
     'testing/tools/autotry',
+    'testing/web-platform',
+    'testing/web-platform/harness',
+    'testing/web-platform/tests/tools/wptserve',
     'testing/xpcshell',
     'xpcom/idl-parser',
 ]
@@ -118,6 +121,7 @@ MACH_MODULES = [
     'testing/mochitest/mach_commands.py',
     'testing/mozharness/mach_commands.py',
     'testing/talos/mach_commands.py',
+    'testing/web-platform/mach_commands.py',
     'testing/xpcshell/mach_commands.py',
     'tools/docs/mach_commands.py',
     'tools/lint/mach_commands.py',

build/macosx/build-cctools.sh

@@ -0,0 +1,26 @@
+#!/bin/bash
+
+set -e
+
+if ! git remote -v | grep origin | grep -q cctools-port; then
+    echo "must be in a cctools-port checkout"
+    exit 1
+fi
+
+mkdir build-cctools
+cd build-cctools
+
+CFLAGS='-mcpu=generic -mtune=generic' MACOSX_DEPLOYMENT_TARGET=10.7 ../cctools/configure --target=x86_64-apple-darwin11
+env MACOSX_DEPLOYMENT_TARGET=10.7 make -s -j4
+
+if test ! -e ld64/src/ld/ld; then
+    echo "ld did not get built"
+    exit 1
+fi
+
+gtar jcf cctools.tar.bz2 ld64/src/ld/ld --transform 's#ld64/src/ld#cctools/bin#'
+
+cd ../
+
+echo "build from $(git show --pretty=format:%H -s HEAD) complete!"
+echo "upload the build-cctools/cctools.tar.bz2 file to tooltool"

build/macosx/cross-mozconfig.common

@@ -0,0 +1,47 @@
+# 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/.
+
+MOZ_AUTOMATION_L10N_CHECK=0
+
+if [ "x$IS_NIGHTLY" = "xyes" ]; then
+  # Some nightlies (eg: Mulet) don't want these set.
+  MOZ_AUTOMATION_UPDATE_PACKAGING=${MOZ_AUTOMATION_UPDATE_PACKAGING-1}
+  MOZ_AUTOMATION_SDK=${MOZ_AUTOMATION_SDK-1}
+fi
+. "$topsrcdir/build/mozconfig.common"
+
+# ld needs libLTO.so from llvm
+mk_add_options "export LD_LIBRARY_PATH=$topsrcdir/clang/lib"
+
+CROSS_CCTOOLS_PATH=$topsrcdir/cctools
+CROSS_SYSROOT=$topsrcdir/MacOSX10.7.sdk
+CROSS_PRIVATE_FRAMEWORKS=$CROSS_SYSROOT/System/Library/PrivateFrameworks
+FLAGS="-target x86_64-apple-darwin10 -mlinker-version=136 -B $CROSS_CCTOOLS_PATH/bin -isysroot $CROSS_SYSROOT"
+
+export CC="$topsrcdir/clang/bin/clang $FLAGS"
+export CXX="$topsrcdir/clang/bin/clang++ $FLAGS"
+export CPP="$topsrcdir/clang/bin/clang $FLAGS -E"
+export LLVMCONFIG=$topsrcdir/clang/bin/llvm-config
+export LDFLAGS="-Wl,-syslibroot,$CROSS_SYSROOT -Wl,-dead_strip"
+export TOOLCHAIN_PREFIX=$CROSS_CCTOOLS_PATH/bin/x86_64-apple-darwin10-
+export DSYMUTIL=$topsrcdir/clang/bin/llvm-dsymutil
+export GENISOIMAGE=$topsrcdir/genisoimage/genisoimage
+export DMG_TOOL=$topsrcdir/dmg/dmg
+
+export HOST_CC="$topsrcdir/clang/bin/clang"
+export HOST_CXX="$topsrcdir/clang/bin/clang++"
+export HOST_CPP="$topsrcdir/clang/bin/clang -E"
+export HOST_CFLAGS="-g"
+export HOST_CXXFLAGS="-g"
+export HOST_LDFLAGS="-g"
+
+ac_add_options --target=x86_64-apple-darwin
+ac_add_options --with-macos-private-frameworks=$CROSS_PRIVATE_FRAMEWORKS
+
+# Enable static analysis checks by default on OSX cross builds.
+ac_add_options --enable-clang-plugin
+
+. "$topsrcdir/build/mozconfig.cache"
+
+export SOCORRO_SYMBOL_UPLOAD_TOKEN_FILE=/builds/crash-stats-api.token

build/macosx/local-mozconfig.common

@@ -0,0 +1,46 @@
+# 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/.
+
+if [ "x$IS_NIGHTLY" = "xyes" ]; then
+  # Some nightlies (eg: Mulet) don't want these set.
+  MOZ_AUTOMATION_UPLOAD_SYMBOLS=${MOZ_AUTOMATION_UPLOAD_SYMBOLS-1}
+  MOZ_AUTOMATION_UPDATE_PACKAGING=${MOZ_AUTOMATION_UPDATE_PACKAGING-1}
+  MOZ_AUTOMATION_SDK=${MOZ_AUTOMATION_SDK-1}
+fi
+. "$topsrcdir/build/mozconfig.common"
+
+if [ -d "$topsrcdir/clang" ]; then
+    # mozilla-central based build
+    export CC=$topsrcdir/clang/bin/clang
+    export CXX=$topsrcdir/clang/bin/clang++
+    export LLVMCONFIG=$topsrcdir/clang/bin/llvm-config
+    export DSYMUTIL=$topsrcdir/clang/bin/llvm-dsymutil
+    # Use an updated linker.
+    ldflags="-B$topsrcdir/cctools/bin"
+elif [ -d "$topsrcdir/../clang" ]; then
+    # comm-central based build
+    export CC=$topsrcdir/../clang/bin/clang
+    export CXX=$topsrcdir/../clang/bin/clang++
+    export LLVMCONFIG=$topsrcdir/../clang/bin/llvm-config
+    export DSYMUTIL=$topsrcdir/../clang/bin/llvm-dsymutil
+    # Use an updated linker.
+    ldflags="-B$topsrcdir/../cctools/bin"
+fi
+
+# Ensure the updated linker doesn't generate things our older build tools
+# don't understand.
+ldflags="$ldflags -Wl,-no_data_in_code_info"
+export LDFLAGS="$ldflags"
+
+# If not set use the system default clang
+if [ -z "$CC" ]; then
+    export CC=clang
+fi
+
+# If not set use the system default clang++
+if [ -z "$CXX" ]; then
+    export CXX=clang++
+fi
+
+export SOCORRO_SYMBOL_UPLOAD_TOKEN_FILE=/builds/crash-stats-api.token

build/macosx/mozconfig.common

@@ -0,0 +1,5 @@
+if test `uname -s` = Linux; then
+  . $topsrcdir/build/macosx/cross-mozconfig.common
+else
+  . $topsrcdir/build/macosx/local-mozconfig.common
+fi

build/macosx/permissions/chown_revert.c

@@ -0,0 +1,20 @@
+/* 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)
+{
+  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);
+}

build/macosx/permissions/chown_root.c

@@ -0,0 +1,14 @@
+/* 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)
+{
+  if (argc != 2)
+    return 1;
+
+  return execl("/usr/sbin/chown",
+               "/usr/sbin/chown", "-R", "-h", "root:admin", argv[1], (char*) 0);
+}

build/macosx/universal/mozconfig

@@ -0,0 +1,11 @@
+# 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/.
+
+# i386/x86-64 Universal Build mozconfig
+
+# As used here, arguments in $MOZ_BUILD_PROJECTS are suitable as arguments
+# to gcc's -arch parameter.
+mk_add_options MOZ_BUILD_PROJECTS="x86_64 i386"
+
+. $topsrcdir/build/macosx/universal/mozconfig.common

build/macosx/universal/mozconfig.common

@@ -0,0 +1,55 @@
+# 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/.
+
+mk_add_options MOZ_UNIFY_BDATE=1
+
+DARWIN_VERSION=10
+ac_add_app_options i386 --target=i386-apple-darwin$DARWIN_VERSION
+ac_add_app_options x86_64 --target=x86_64-apple-darwin$DARWIN_VERSION
+ac_add_app_options i386 --with-unify-dist=../x86_64/dist
+ac_add_app_options x86_64 --with-unify-dist=../i386/dist
+
+if ! test `uname -s` = Linux; then
+  # Cross-universal builds already do the equivalent of this by setting -isysroot directly
+  ac_add_options --with-macos-sdk=/Developer/SDKs/MacOSX10.7.sdk
+fi
+
+. $topsrcdir/build/macosx/mozconfig.common
+
+# $MOZ_BUILD_APP is only defined when sourced by configure.  That's not a
+# problem, because the variables it affects only need to be set for
+# configure.
+if test -n "$MOZ_BUILD_APP" ; then
+if test "$MOZ_BUILD_APP" = "i386" -o "$MOZ_BUILD_APP" = "x86_64"; then
+  TARGET_CPU=$MOZ_BUILD_APP
+
+  # $HOST_CXX is presently unused.  $HOST_CC will only be used during a cross
+  # compile.
+  HOST_CC=$CC
+  HOST_CXX=$CXX
+
+  NATIVE_CPU=`$topsrcdir/build/autoconf/config.guess | cut -f1 -d-`
+
+  # It's not strictly necessary to specify -arch during native builds, but it
+  # makes the merged about:buildconfig easier to follow, and it reduces
+  # conditionalized differences between builds.
+  CC="$CC -arch $TARGET_CPU"
+  CXX="$CXX -arch $TARGET_CPU"
+
+  # These must be set for cross builds, and don't hurt straight builds.
+  RANLIB="${TOOLCHAIN_PREFIX}ranlib"
+  AR="${TOOLCHAIN_PREFIX}ar"
+  AS=$CC
+  LD=ld
+  STRIP="${TOOLCHAIN_PREFIX}strip"
+  OTOOL="${TOOLCHAIN_PREFIX}otool"
+
+  # Each per-CPU build should be entirely oblivious to the fact that a
+  # universal binary will be produced.  The exception is packager.mk, which
+  # needs to know to look for universal bits when building the .dmg.
+  UNIVERSAL_BINARY=1
+
+  export CC CXX HOST_CC HOST_CXX RANLIB AR AS LD STRIP OTOOL
+fi
+fi

build/moz.configure/init.configure

@@ -542,6 +542,27 @@ def target_is_unix(target):
 
 set_define('XP_UNIX', target_is_unix)
 
+@depends(target)
+def target_is_darwin(target):
+    if target.kernel == 'Darwin':
+        return True
+
+set_define('XP_DARWIN', target_is_darwin)
+
+@depends(target)
+def target_is_ios(target):
+    if target.kernel == 'Darwin' and target.os == 'iOS':
+        return True
+
+set_define('XP_IOS', target_is_ios)
+
+@depends(target)
+def target_is_osx(target):
+    if target.kernel == 'Darwin' and target.os == 'OSX':
+        return True
+
+set_define('XP_MACOSX', target_is_osx)
+
 @depends(target)
 def target_is_linux(target):
     if target.kernel == 'Linux':

build/moz.configure/keyfiles.configure

@@ -36,6 +36,10 @@ def keyfile(desc, help=None, callback=lambda x: x):
 def simple_keyfile(desc):
     value = keyfile(desc)
     set_config('MOZ_%s_KEY' % desc.upper().replace(' ', '_'), value)
+    # Only really required for MOZ_ADJUST_SDK_KEY currently still used in
+    # old-configure.
+    add_old_configure_assignment('MOZ_%s_KEY' % desc.upper().replace(' ', '_'),
+                                 value)
 
 
 @template

build/moz.configure/old.configure

@@ -200,6 +200,7 @@ def old_configure_options(*options):
     '--enable-logrefcnt',
     '--enable-maintenance-service',
     '--enable-memory-sanitizer',
+    '--enable-mobile-optimize',
     '--enable-mozril-geoloc',
     '--enable-necko-wifi',
     '--enable-negotiateauth',
@@ -225,7 +226,6 @@ def old_configure_options(*options):
     '--enable-safe-browsing',
     '--enable-sandbox',
     '--enable-security-sqlstore',
-    '--enable-shared-media',
     '--enable-signmar',
     '--enable-simulator',
     '--enable-small-chunk-size',
@@ -312,6 +312,7 @@ def old_configure_options(*options):
     '--disable-browser-statusbar',
     '--disable-sync',
     '--disable-personas',
+    '--enable-phoenix-extensions',
     
     # Below are configure flags used by Basilisk
     '--disable-webextensions',

chrome/nsChromeRegistry.cpp

@@ -298,6 +298,8 @@ nsChromeRegistry::ConvertChromeURL(nsIURI* aChromeURI, nsIURI* *aResult)
   if (flags & PLATFORM_PACKAGE) {
 #if defined(XP_WIN)
     path.Insert("win/", 0);
+#elif defined(XP_MACOSX)
+    path.Insert("mac/", 0);
 #else
     path.Insert("unix/", 0);
 #endif

chrome/nsChromeRegistryChrome.cpp

@@ -11,6 +11,8 @@
 
 #if defined(XP_WIN)
 #include <windows.h>
+#elif defined(XP_MACOSX)
+#include <CoreServices/CoreServices.h>
 #endif
 
 #include "nsArrayEnumerator.h"

config/check_spidermonkey_style.py

@@ -79,7 +79,6 @@ included_inclnames_to_ignore = set([
     'prtypes.h',                # NSPR
     'selfhosted.out.h',         # generated in $OBJDIR
     'shellmoduleloader.out.h',  # generated in $OBJDIR
-    'unicode/plurrule.h',       # ICU
     'unicode/timezone.h',       # ICU
     'unicode/ucal.h',           # ICU
     'unicode/uclean.h',         # ICU
@@ -91,7 +90,6 @@ included_inclnames_to_ignore = set([
     'unicode/unorm.h',          # ICU
     'unicode/unum.h',           # ICU
     'unicode/unumsys.h',        # ICU
-    'unicode/upluralrules.h',   # ICU
     'unicode/ustring.h',        # ICU
     'unicode/utypes.h',         # ICU
     'vtune/VTuneWrapper.h'      # VTune

config/external/nspr/prcpucfg.h

@@ -10,7 +10,9 @@
  * Need to support conditionals that are defined in both the top-level build
  * system as well as NSS' build system for now.
  */
-#if defined(XP_WIN) || defined(_WINDOWS)
+#if defined(XP_DARWIN) || defined(DARWIN)
+#include "md/_darwin.cfg"
+#elif defined(XP_WIN) || defined(_WINDOWS)
 #include "md/_win95.cfg"
 #elif defined(__FreeBSD__)
 #include "md/_freebsd.cfg"

config/gcc-stl-wrapper.template.h

@@ -8,7 +8,9 @@
 #ifndef mozilla_${HEADER}_h
 #define mozilla_${HEADER}_h
 
-#if defined(__EXCEPTIONS) && __EXCEPTIONS
+// For some reason, Apple's GCC refuses to honor -fno-exceptions when
+// compiling ObjC.
+#if defined(__EXCEPTIONS) && __EXCEPTIONS && !(__OBJC__ && __GNUC__ && XP_IOS)
 #  error "STL code can only be used with -fno-exceptions"
 #endif
 
@@ -30,14 +32,6 @@
 #  define moz_dont_include_mozalloc_for_cstdlib
 #endif
 
-#ifndef moz_dont_include_mozalloc_for_type_traits
-#  define moz_dont_include_mozalloc_for_type_traits
-#endif
-
-#ifndef moz_dont_include_mozalloc_for_limits
-#  define moz_dont_include_mozalloc_for_limits
-#endif
-
 // Include mozalloc after the STL header and all other headers it includes
 // have been preprocessed.
 #if !defined(MOZ_INCLUDE_MOZALLOC_H) && \

config/milestone.txt

@@ -10,4 +10,4 @@
 # hardcoded milestones in the tree from these two files.
 #--------------------------------------------------------
 
-4.8.3
+4.7.0

config/moz.build

@@ -28,9 +28,6 @@ if CONFIG['HOST_OS_ARCH'] != 'WINNT':
     # while the program here is in C.
     HostProgram('nsinstall_real', c_only=True)
 
-if CONFIG['GKMEDIAS_SHARED_LIBRARY']:
-    DEFINES['GKMEDIAS_SHARED_LIBRARY'] = True
-
 PYTHON_UNIT_TESTS += [
     'tests/test_mozbuild_reading.py',
     'tests/unit-expandlibs.py',

config/rules.mk

@@ -1,4 +1,5 @@
 # -*- makefile -*-
+# vim:set ts=8 sw=8 sts=8 noet:
 #
 # 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,
@@ -750,6 +751,7 @@ $(HOST_LIBRARY): $(HOST_OBJS) Makefile
 	$(EXPAND_LIBS_EXEC) --extract -- $(HOST_AR) $(HOST_AR_FLAGS) $(HOST_OBJS)
 
 ifdef HAVE_DTRACE
+ifndef XP_MACOSX
 ifdef DTRACE_PROBE_OBJ
 ifndef DTRACE_LIB_DEPENDENT
 NON_DTRACE_OBJS := $(filter-out $(DTRACE_PROBE_OBJ),$(OBJS))
@@ -758,6 +760,7 @@ $(DTRACE_PROBE_OBJ): $(NON_DTRACE_OBJS)
 endif
 endif
 endif
+endif
 
 # On Darwin (Mac OS X), dwarf2 debugging uses debug info left in .o files,
 # so instead of deleting .o files after repacking them into a dylib, we make
@@ -770,7 +773,9 @@ ifndef INCREMENTAL_LINKER
 	$(RM) $@
 endif
 ifdef DTRACE_LIB_DEPENDENT
+ifndef XP_MACOSX
 	dtrace -x nolibs -G -C -s $(MOZILLA_DTRACE_SRC) -o  $(DTRACE_PROBE_OBJ) $(shell $(EXPAND_LIBS) $(MOZILLA_PROBE_LIBS))
+endif
 	$(EXPAND_MKSHLIB) $(SHLIB_LDSTARTFILE) $(OBJS) $(SUB_SHLOBJS) $(DTRACE_PROBE_OBJ) $(MOZILLA_PROBE_LIBS) $(RESFILE) $(LDFLAGS) $(WRAP_LDFLAGS) $(STATIC_LIBS) $(RUST_STATIC_LIB_FOR_SHARED_LIB) $(SHARED_LIBS) $(EXTRA_DSO_LDOPTS) $(MOZ_GLUE_LDFLAGS) $(EXTRA_LIBS) $(OS_LIBS) $(SHLIB_LDENDFILE)
 	@$(RM) $(DTRACE_PROBE_OBJ)
 else # ! DTRACE_LIB_DEPENDENT

config/system-headers

@@ -164,6 +164,13 @@ all.h
 alloca.h
 alloc.h
 alsa/asoundlib.h
+#ifdef ANDROID
+android/ashmem.h
+android/log.h
+android/looper.h
+android/native_window.h
+android_audio/AudioSystem.h
+#endif
 ansi_parms.h
 a.out.h
 app/Cursor.h
@@ -193,6 +200,14 @@ atlimpl.cpp
 atlwin.cpp
 ATSTypes.h
 ATSUnicode.h
+#ifdef ANDROID
+audio_effects/effect_aec.h
+audio_effects/effect_ns.h
+AudioParameter.h
+AudioSystem.h
+AudioTrack.h
+avc_utils.h
+#endif
 Balloons.h
 base/pblock.h
 base/PCR_Base.h
@@ -203,6 +218,18 @@ Beep.h
 be/kernel/image.h
 be/kernel/OS.h
 bfd.h
+#ifdef ANDROID
+binder/Binder.h
+binder/BinderService.h
+binder/IBinder.h
+binder/IInterface.h
+binder/IMemory.h
+binder/IPCThreadState.h
+binder/IPermissionController.h
+binder/IServiceManager.h
+binder/Parcel.h
+binder/ProcessState.h
+#endif
 Bitmap.h
 bitset
 blapi.h
@@ -281,6 +308,10 @@ dfb_types.h
 directfb_strings.h
 directfb_keyboard.h
 callconv.h
+#ifdef ANDROID
+camera/Camera.h
+camera/CameraParameters.h
+#endif
 Carbon/Carbon.h
 CarbonEvents.h
 Carbon.h
@@ -304,6 +335,9 @@ Clipboard.h
 cmplrs/stsupport.h
 Cocoa/Cocoa.h
 CodeFragments.h
+#ifdef ANDROID
+ColorConverter.h
+#endif
 comdef.h
 commctrl.h
 COMMCTRL.H
@@ -332,6 +366,15 @@ ctype.h
 curl/curl.h
 curl/easy.h
 curses.h
+#ifdef ANDROID
+cutils/android_reboot.h
+cutils/atomic.h
+cutils/compiler.h
+cutils/log.h
+cutils/native_handle.h
+cutils/properties.h
+cutils/sockets.h
+#endif
 cxxabi.h
 DateTimeUtils.h
 dbus/dbus.h
@@ -386,6 +429,19 @@ fontconfig/fontconfig.h
 fontconfig/fcfreetype.h
 Font.h
 Fonts.h
+#ifdef ANDROID
+foundation/ABase.h
+foundation/ABitReader.h
+foundation/ABuffer.h
+foundation/ADebug.h
+foundation/AHandler.h
+foundation/AHandlerReflector.h
+foundation/ALooper.h
+foundation/AMessage.h
+foundation/AString.h
+foundation/base64.h
+foundation/hexdump.h
+#endif
 fp.h
 fpieee.h
 frame/log.h
@@ -449,8 +505,33 @@ gssapi.h
 gtk/gtk.h
 gtk/gtkx.h
 gtk/gtkunixprint.h
+#ifdef ANDROID
+gui/BufferQueue.h
+gui/ConsumerBase.h
+gui/GraphicBufferAlloc.h
+gui/IConsumerListener.h
+gui/IGraphicBufferAlloc.h
+gui/IGraphicBufferProducer.h
+gui/ISurfaceComposer.h
+gui/ISurfaceComposerClient.h
+gui/ISurfaceTexture.h
+gui/Surface.h
+gui/SurfaceComposerClient.h
+gui/SurfaceTextureClient.h
+hardware/audio.h
+hardware/gralloc.h
+hardware/hardware.h
+hardware/hwcomposer.h
+hardware/lights.h
+hardware/power.h
+hardware_legacy/power.h
+hardware_legacy/uevent.h
+#endif
 HIToolbox/HIToolbox.h
 hlink.h
+#ifdef ANDROID
+HTTPBase.h
+#endif
 ia64/sys/inline.h
 Icons.h
 iconv.h
@@ -542,6 +623,10 @@ libgnomeui/gnome-icon-theme.h
 libgnomeui/gnome-ui-init.h
 limits.h
 link.h
+#ifdef ANDROID
+linux/android_alarm.h
+linux/ashmem.h
+#endif
 linux/ioprio.h
 linux/kernel.h
 linux/limits.h
@@ -627,6 +712,53 @@ mapix.h
 Math64.h
 math.h
 mbstring.h
+#ifdef ANDROID
+android/native_window.h
+android/native_window_jni.h
+media/AudioEffect.h
+media/AudioSystem.h
+media/ICrypto.h
+media/IOMX.h
+media/MediaProfiles.h
+media/MediaRecorderBase.h
+media/openmax/OMX_Audio.h
+media/stagefright/AACWriter.h
+media/stagefright/AMRWriter.h
+media/stagefright/AudioSource.h
+media/stagefright/DataSource.h
+media/stagefright/foundation/ABase.h
+media/stagefright/foundation/ABitReader.h
+media/stagefright/foundation/ABuffer.h
+media/stagefright/foundation/ADebug.h
+media/stagefright/foundation/AHandler.h
+media/stagefright/foundation/AHandlerReflector.h
+media/stagefright/foundation/ALooper.h
+media/stagefright/foundation/AMessage.h
+media/stagefright/foundation/AString.h
+media/stagefright/foundation/base64.h
+media/stagefright/foundation/hexdump.h
+media/stagefright/MediaBuffer.h
+media/stagefright/MediaBufferGroup.h
+media/stagefright/MediaCodec.h
+media/stagefright/MediaCodecList.h
+media/stagefright/MediaCodecSource.h
+media/stagefright/MediaDefs.h
+media/stagefright/MediaErrors.h
+media/stagefright/MediaExtractor.h
+media/stagefright/MediaSource.h
+media/stagefright/MediaWriter.h
+media/stagefright/MetaData.h
+media/stagefright/MPEG2TSWriter.h
+media/stagefright/MPEG4Writer.h
+media/stagefright/OMXClient.h
+media/stagefright/OMXCodec.h
+media/stagefright/openmax/OMX_Core.h
+media/stagefright/openmax/OMX_Index.h
+media/stagefright/openmax/OMX_IVCommon.h
+media/stagefright/openmax/OMX_Types.h
+media/stagefright/openmax/OMX_Video.h
+media/stagefright/Utils.h
+#endif
 mem.h
 memory.h
 Memory.h
@@ -666,6 +798,10 @@ Objsafe.h
 ojiapitests.h
 ole2.h
 oleidl.h
+#ifdef ANDROID
+OMX.h
+OMX_Component.h
+#endif
 OpenGL/OpenGL.h
 OpenTptInternet.h
 OpenTransport.h
@@ -711,6 +847,10 @@ PP_Resources.h
 PP_Types.h
 Printing.h
 Print/PMPrintingDialogExtensions.h
+#ifdef ANDROID
+private/android_filesystem_config.h
+private/qucomextra_p.h
+#endif
 Processes.h
 process.h
 Process.h
@@ -777,6 +917,43 @@ Sound.h
 soundcard.h
 sqlite3.h
 sstream
+#ifdef ANDROID
+stagefright/AACWriter.h
+stagefright/AMRWriter.h
+stagefright/AudioSource.h
+stagefright/DataSource.h
+stagefright/foundation/ABase.h
+stagefright/foundation/ABitReader.h
+stagefright/foundation/ABuffer.h
+stagefright/foundation/ADebug.h
+stagefright/foundation/AHandler.h
+stagefright/foundation/AHandlerReflector.h
+stagefright/foundation/ALooper.h
+stagefright/foundation/AMessage.h
+stagefright/foundation/AString.h
+stagefright/foundation/base64.h
+stagefright/foundation/hexdump.h
+stagefright/MediaBuffer.h
+stagefright/MediaBufferGroup.h
+stagefright/MediaCodec.h
+stagefright/MediaDefs.h
+stagefright/MediaErrors.h
+stagefright/MediaExtractor.h
+stagefright/MediaSource.h
+stagefright/MediaWriter.h
+stagefright/MetaData.h
+stagefright/MPEG2TSWriter.h
+stagefright/MPEG4Writer.h
+stagefright/OMXCodec.h
+stagefright/OMXClient.h
+stagefright/openmax/OMX_Component.h
+stagefright/openmax/OMX_Core.h
+stagefright/openmax/OMX_Index.h
+stagefright/openmax/OMX_IVCommon.h
+stagefright/openmax/OMX_Types.h
+stagefright/openmax/OMX_Video.h
+stagefright/Utils.h
+#endif
 StandardFile.h
 starlet.h
 stat.h
@@ -804,6 +981,9 @@ SupportDefs.h
 support/String.h
 support/SupportDefs.h
 support/TLS.h
+#ifdef ANDROID
+suspend/autosuspend.h
+#endif
 svrcore.h
 symconst.h
 sym.h
@@ -891,6 +1071,12 @@ sys/unistd.h
 sys/utsname.h
 sys/vfs.h
 sys/wait.h
+#ifdef ANDROID
+sysutils/NetlinkEvent.h
+system/audio.h
+system/graphics.h
+system/window.h
+#endif
 tables.h
 TArray.h
 TArrayIterator.h
@@ -933,6 +1119,15 @@ UEventMgr.h
 UException.h
 UExtractFromAEDesc.h
 UGWorld.h
+#ifdef ANDROID
+ui/ANativeObjectBase.h
+ui/egl/android_natives.h
+ui/Fence.h
+ui/FramebufferNativeWindow.h
+ui/GraphicBuffer.h
+ui/Rect.h
+ui/Region.h
+#endif
 UKeyFilters.h
 ulocks.h
 ulserrno.h
@@ -954,6 +1149,28 @@ UReanimator.h
 URegions.h
 URegistrar.h
 UResourceMgr.h
+#ifdef ANDROID
+utils/BitSet.h
+utils/CallStack.h
+utils/Errors.h
+utils/FileMap.h
+utils/KeyedVector.h
+utils/List.h
+utils/Log.h
+utils/Looper.h
+utils/PropertyMap.h
+utils/RefBase.h
+utils/String16.h
+utils/String8.h
+utils/threads.h
+utils/TextOutput.h
+utils/Timers.h
+utils/Trace.h
+utils/TypeHelpers.h
+utils/Unicode.h
+utils/Vector.h
+utils/VectorImpl.h
+#endif
 urlhist.h
 urlmon.h
 UScrap.h
@@ -1070,22 +1287,6 @@ QtSparql/qsparqlresult.h
 #if MOZ_TREE_PIXMAN!=1
 pixman.h
 #endif
-#ifdef GKMEDIAS_SHARED_LIBRARY
-vpx/vpx_codec.h
-vpx/vpx_decoder.h
-vpx/vpx_encoder.h
-vpx/vp8cx.h
-vpx/vp8dx.h
-vpx_mem/vpx_mem.h
-vorbis/codec.h
-theora/theoradec.h
-tremor/ivorbiscodec.h
-speex/speex_resampler.h
-ogg/ogg.h
-ogg/os_types.h
-nestegg/nestegg.h
-cubeb/cubeb.h
-#endif
 gst/gst.h
 gst/app/gstappsink.h
 gst/app/gstappsrc.h

db/mork/src/morkConfig.h

@@ -18,6 +18,10 @@
 
 // { %%%%% begin platform defs peculiar to Mork %%%%%
 
+#ifdef XP_MACOSX
+#define MORK_MAC 1
+#endif
+
 #ifdef XP_WIN
 #define MORK_WIN 1
 #endif
@@ -28,7 +32,7 @@
 
 // } %%%%% end platform defs peculiar to Mork %%%%%
 
-#if defined(MORK_WIN) || defined(MORK_UNIX)
+#if defined(MORK_WIN) || defined(MORK_UNIX) || defined(MORK_MAC)
 #include <stdio.h> 
 #include <ctype.h> 
 #include <errno.h> 
@@ -84,15 +88,20 @@ void mork_fileflush(FILE * file);
 #define mork_kTAB '\011'
 #define mork_kCRLF "\015\012"     /* A CR LF equivalent string */
 
-#if defined(MORK_WIN)
-#  define mork_kNewline           "\015\012"
-#  define mork_kNewlineSize       2
+#if defined(MORK_MAC)
+#  define mork_kNewline             "\015"
+#  define mork_kNewlineSize 1
 #else
-#  if defined(MORK_UNIX)
-#    define mork_kNewline         "\012"
-#    define mork_kNewlineSize     1
-#  endif /* MORK_UNIX */
-#endif /* MORK_WIN */
+#  if defined(MORK_WIN)
+#    define mork_kNewline           "\015\012"
+#    define mork_kNewlineSize       2
+#  else
+#    if defined(MORK_UNIX)
+#      define mork_kNewline         "\012"
+#      define mork_kNewlineSize     1
+#    endif /* MORK_UNIX */
+#  endif /* MORK_WIN */
+#endif /* MORK_MAC */
 
 // { %%%%% begin assertion macro %%%%%
 extern void mork_assertion_signal(const char* inMessage);
@@ -105,7 +114,7 @@ extern void mork_assertion_signal(const char* inMessage);
 
 // { %%%%% begin standard c utility methods %%%%%
 
-#if defined(MORK_WIN) || defined(MORK_UNIX)
+#if defined(MORK_WIN) || defined(MORK_UNIX) || defined(MORK_MAC)
 #define MORK_USE_C_STDLIB 1
 #endif /*MORK_WIN*/
 

db/sqlite3/src/moz.build

@@ -45,6 +45,10 @@ if CONFIG['MOZ_WIDGET_TOOLKIT'] == 'windows':
     DEFINES['SQLITE_WIN32_GETVERSIONEX'] = 0
     DEFINES['SQLITE_ALLOW_URI_AUTHORITY'] = 1
 
+# -DSQLITE_ENABLE_LOCKING_STYLE=1 to help with AFP folders
+if CONFIG['MOZ_WIDGET_TOOLKIT'] == 'cocoa':
+    DEFINES['SQLITE_ENABLE_LOCKING_STYLE'] = 1
+
 # sqlite defaults this to on on __APPLE_ but it breaks on newer iOS SDKs
 if CONFIG['MOZ_WIDGET_TOOLKIT'] == 'uikit':
     DEFINES['SQLITE_ENABLE_LOCKING_STYLE'] = 0

db/sqlite3/src/sqlite3.h

@@ -123,9 +123,9 @@ extern "C" {
 ** [sqlite3_libversion_number()], [sqlite3_sourceid()],
 ** [sqlite_version()] and [sqlite_source_id()].
 */
-#define SQLITE_VERSION        "3.36.0"
-#define SQLITE_VERSION_NUMBER 3036000
-#define SQLITE_SOURCE_ID      "2021-06-18 18:36:39 5c9a6c06871cb9fe42814af9c039eb6da5427a6ec28f187af7ebfb62eafa66e5"
+#define SQLITE_VERSION        "3.33.0"
+#define SQLITE_VERSION_NUMBER 3033000
+#define SQLITE_SOURCE_ID      "2020-08-14 13:23:32 fca8dc8b578f215a969cd899336378966156154710873e68b3d9ac5881b0ff3f"
 
 /*
 ** CAPI3REF: Run-Time Library Version Numbers
@@ -504,7 +504,6 @@ SQLITE_API int sqlite3_exec(
 #define SQLITE_IOERR_COMMIT_ATOMIC     (SQLITE_IOERR | (30<<8))
 #define SQLITE_IOERR_ROLLBACK_ATOMIC   (SQLITE_IOERR | (31<<8))
 #define SQLITE_IOERR_DATA              (SQLITE_IOERR | (32<<8))
-#define SQLITE_IOERR_CORRUPTFS         (SQLITE_IOERR | (33<<8))
 #define SQLITE_LOCKED_SHAREDCACHE      (SQLITE_LOCKED |  (1<<8))
 #define SQLITE_LOCKED_VTAB             (SQLITE_LOCKED |  (2<<8))
 #define SQLITE_BUSY_RECOVERY           (SQLITE_BUSY   |  (1<<8))
@@ -1128,23 +1127,6 @@ struct sqlite3_io_methods {
 ** file to the database file, but before the *-shm file is updated to
 ** record the fact that the pages have been checkpointed.
 ** </ul>
-**
-** <li>[[SQLITE_FCNTL_EXTERNAL_READER]]
-** The EXPERIMENTAL [SQLITE_FCNTL_EXTERNAL_READER] opcode is used to detect
-** whether or not there is a database client in another process with a wal-mode
-** transaction open on the database or not. It is only available on unix.The
-** (void*) argument passed with this file-control should be a pointer to a
-** value of type (int). The integer value is set to 1 if the database is a wal
-** mode database and there exists at least one client in another process that
-** currently has an SQL transaction open on the database. It is set to 0 if
-** the database is not a wal-mode db, or if there is no such connection in any
-** other process. This opcode cannot be used to detect transactions opened
-** by clients within the current process, only within other processes.
-** </ul>
-**
-** <li>[[SQLITE_FCNTL_CKSM_FILE]]
-** Used by the cksmvfs VFS module only.
-** </ul>
 */
 #define SQLITE_FCNTL_LOCKSTATE               1
 #define SQLITE_FCNTL_GET_LOCKPROXYFILE       2
@@ -1184,8 +1166,6 @@ struct sqlite3_io_methods {
 #define SQLITE_FCNTL_CKPT_DONE              37
 #define SQLITE_FCNTL_RESERVE_BYTES          38
 #define SQLITE_FCNTL_CKPT_START             39
-#define SQLITE_FCNTL_EXTERNAL_READER        40
-#define SQLITE_FCNTL_CKSM_FILE              41
 
 /* deprecated names */
 #define SQLITE_GET_LOCKPROXYFILE      SQLITE_FCNTL_GET_LOCKPROXYFILE
@@ -2134,13 +2114,7 @@ struct sqlite3_mem_methods {
 ** The second parameter is a pointer to an integer into which
 ** is written 0 or 1 to indicate whether triggers are disabled or enabled
 ** following this call.  The second parameter may be a NULL pointer, in
-** which case the trigger setting is not reported back.
-**
-** <p>Originally this option disabled all triggers.  ^(However, since
-** SQLite version 3.35.0, TEMP triggers are still allowed even if
-** this option is off.  So, in other words, this option now only disables
-** triggers in the main database schema or in the schemas of ATTACH-ed
-** databases.)^ </dd>
+** which case the trigger setting is not reported back. </dd>
 **
 ** [[SQLITE_DBCONFIG_ENABLE_VIEW]]
 ** <dt>SQLITE_DBCONFIG_ENABLE_VIEW</dt>
@@ -2151,13 +2125,7 @@ struct sqlite3_mem_methods {
 ** The second parameter is a pointer to an integer into which
 ** is written 0 or 1 to indicate whether views are disabled or enabled
 ** following this call.  The second parameter may be a NULL pointer, in
-** which case the view setting is not reported back.
-**
-** <p>Originally this option disabled all views.  ^(However, since
-** SQLite version 3.35.0, TEMP views are still allowed even if
-** this option is off.  So, in other words, this option now only disables
-** views in the main database schema or in the schemas of ATTACH-ed
-** databases.)^ </dd>
+** which case the view setting is not reported back. </dd>
 **
 ** [[SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER]]
 ** <dt>SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER</dt>
@@ -3530,7 +3498,6 @@ SQLITE_API void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*);
 **          that uses dot-files in place of posix advisory locking.
 ** <tr><td> file:data.db?mode=readonly <td>
 **          An error. "readonly" is not a valid option for the "mode" parameter.
-**          Use "ro" instead:  "file:data.db?mode=ro".
 ** </table>
 **
 ** ^URI hexadecimal escape sequences (%HH) are supported within the path and
@@ -3729,7 +3696,7 @@ SQLITE_API sqlite3_file *sqlite3_database_file_object(const char*);
 ** If the Y parameter to sqlite3_free_filename(Y) is anything other
 ** than a NULL pointer or a pointer previously acquired from
 ** sqlite3_create_filename(), then bad things such as heap
-** corruption or segfaults may occur. The value Y should not be
+** corruption or segfaults may occur. The value Y should be
 ** used again after sqlite3_free_filename(Y) has been called.  This means
 ** that if the [sqlite3_vfs.xOpen()] method of a VFS has been called using Y,
 ** then the corresponding [sqlite3_module.xClose() method should also be
@@ -4198,15 +4165,6 @@ SQLITE_API const char *sqlite3_normalized_sql(sqlite3_stmt *pStmt);
 ** [BEGIN] merely sets internal flags, but the [BEGIN|BEGIN IMMEDIATE] and
 ** [BEGIN|BEGIN EXCLUSIVE] commands do touch the database and so
 ** sqlite3_stmt_readonly() returns false for those commands.
-**
-** ^This routine returns false if there is any possibility that the
-** statement might change the database file.  ^A false return does
-** not guarantee that the statement will change the database file.
-** ^For example, an UPDATE statement might have a WHERE clause that
-** makes it a no-op, but the sqlite3_stmt_readonly() result would still
-** be false.  ^Similarly, a CREATE TABLE IF NOT EXISTS statement is a
-** read-only no-op if the table already exists, but
-** sqlite3_stmt_readonly() still returns false for such a statement.
 */
 SQLITE_API int sqlite3_stmt_readonly(sqlite3_stmt *pStmt);
 
@@ -4376,22 +4334,18 @@ typedef struct sqlite3_context sqlite3_context;
 ** contain embedded NULs.  The result of expressions involving strings
 ** with embedded NULs is undefined.
 **
-** ^The fifth argument to the BLOB and string binding interfaces controls
-** or indicates the lifetime of the object referenced by the third parameter.
-** These three options exist:
-** ^ (1) A destructor to dispose of the BLOB or string after SQLite has finished
-** with it may be passed. ^It is called to dispose of the BLOB or string even
-** if the call to the bind API fails, except the destructor is not called if
-** the third parameter is a NULL pointer or the fourth parameter is negative.
-** ^ (2) The special constant, [SQLITE_STATIC], may be passsed to indicate that
-** the application remains responsible for disposing of the object. ^In this
-** case, the object and the provided pointer to it must remain valid until
-** either the prepared statement is finalized or the same SQL parameter is
-** bound to something else, whichever occurs sooner.
-** ^ (3) The constant, [SQLITE_TRANSIENT], may be passed to indicate that the
-** object is to be copied prior to the return from sqlite3_bind_*(). ^The
-** object and pointer to it must remain valid until then. ^SQLite will then
-** manage the lifetime of its private copy.
+** ^The fifth argument to the BLOB and string binding interfaces
+** is a destructor used to dispose of the BLOB or
+** string after SQLite has finished with it.  ^The destructor is called
+** to dispose of the BLOB or string even if the call to the bind API fails,
+** except the destructor is not called if the third parameter is a NULL
+** pointer or the fourth parameter is negative.
+** ^If the fifth argument is
+** the special value [SQLITE_STATIC], then SQLite assumes that the
+** information is in static, unmanaged space and does not need to be freed.
+** ^If the fifth argument has the value [SQLITE_TRANSIENT], then
+** SQLite makes its own private copy of the data immediately, before
+** the sqlite3_bind_*() routine returns.
 **
 ** ^The sixth argument to sqlite3_bind_text64() must be one of
 ** [SQLITE_UTF8], [SQLITE_UTF16], [SQLITE_UTF16BE], or [SQLITE_UTF16LE]
@@ -5133,6 +5087,7 @@ SQLITE_API int sqlite3_reset(sqlite3_stmt *pStmt);
 ** within VIEWs, TRIGGERs, CHECK constraints, generated column expressions,
 ** index expressions, or the WHERE clause of partial indexes.
 **
+** <span style="background-color:#ffff90;">
 ** For best security, the [SQLITE_DIRECTONLY] flag is recommended for
 ** all application-defined SQL functions that do not need to be
 ** used inside of triggers, view, CHECK constraints, or other elements of
@@ -5142,6 +5097,7 @@ SQLITE_API int sqlite3_reset(sqlite3_stmt *pStmt);
 ** a database file to include invocations of the function with parameters
 ** chosen by the attacker, which the application will then execute when
 ** the database file is opened and read.
+** </span>
 **
 ** ^(The fifth parameter is an arbitrary pointer.  The implementation of the
 ** function can gain access to this pointer using [sqlite3_user_data()].)^
@@ -6230,57 +6186,6 @@ SQLITE_API const char *sqlite3_db_filename(sqlite3 *db, const char *zDbName);
 */
 SQLITE_API int sqlite3_db_readonly(sqlite3 *db, const char *zDbName);
 
-/*
-** CAPI3REF: Determine the transaction state of a database
-** METHOD: sqlite3
-**
-** ^The sqlite3_txn_state(D,S) interface returns the current
-** [transaction state] of schema S in database connection D.  ^If S is NULL,
-** then the highest transaction state of any schema on database connection D
-** is returned.  Transaction states are (in order of lowest to highest):
-** <ol>
-** <li value="0"> SQLITE_TXN_NONE
-** <li value="1"> SQLITE_TXN_READ
-** <li value="2"> SQLITE_TXN_WRITE
-** </ol>
-** ^If the S argument to sqlite3_txn_state(D,S) is not the name of
-** a valid schema, then -1 is returned.
-*/
-SQLITE_API int sqlite3_txn_state(sqlite3*,const char *zSchema);
-
-/*
-** CAPI3REF: Allowed return values from [sqlite3_txn_state()]
-** KEYWORDS: {transaction state}
-**
-** These constants define the current transaction state of a database file.
-** ^The [sqlite3_txn_state(D,S)] interface returns one of these
-** constants in order to describe the transaction state of schema S
-** in [database connection] D.
-**
-** <dl>
-** [[SQLITE_TXN_NONE]] <dt>SQLITE_TXN_NONE</dt>
-** <dd>The SQLITE_TXN_NONE state means that no transaction is currently
-** pending.</dd>
-**
-** [[SQLITE_TXN_READ]] <dt>SQLITE_TXN_READ</dt>
-** <dd>The SQLITE_TXN_READ state means that the database is currently
-** in a read transaction.  Content has been read from the database file
-** but nothing in the database file has changed.  The transaction state
-** will advanced to SQLITE_TXN_WRITE if any changes occur and there are
-** no other conflicting concurrent write transactions.  The transaction
-** state will revert to SQLITE_TXN_NONE following a [ROLLBACK] or
-** [COMMIT].</dd>
-**
-** [[SQLITE_TXN_WRITE]] <dt>SQLITE_TXN_WRITE</dt>
-** <dd>The SQLITE_TXN_WRITE state means that the database is currently
-** in a write transaction.  Content has been written to the database file
-** but has not yet committed.  The transaction state will change to
-** to SQLITE_TXN_NONE at the next [ROLLBACK] or [COMMIT].</dd>
-*/
-#define SQLITE_TXN_NONE  0
-#define SQLITE_TXN_READ  1
-#define SQLITE_TXN_WRITE 2
-
 /*
 ** CAPI3REF: Find the next prepared statement
 ** METHOD: sqlite3
@@ -7807,10 +7712,7 @@ SQLITE_API int sqlite3_test_control(int op, ...);
 #define SQLITE_TESTCTRL_RESULT_INTREAL          27
 #define SQLITE_TESTCTRL_PRNG_SEED               28
 #define SQLITE_TESTCTRL_EXTRA_SCHEMA_CHECKS     29
-#define SQLITE_TESTCTRL_SEEK_COUNT              30
-#define SQLITE_TESTCTRL_TRACEFLAGS              31
-#define SQLITE_TESTCTRL_TUNE                    32
-#define SQLITE_TESTCTRL_LAST                    32  /* Largest TESTCTRL */
+#define SQLITE_TESTCTRL_LAST                    29  /* Largest TESTCTRL */
 
 /*
 ** CAPI3REF: SQL Keyword Checking
@@ -9290,11 +9192,10 @@ SQLITE_API int sqlite3_vtab_on_conflict(sqlite3 *);
 ** CAPI3REF: Determine If Virtual Table Column Access Is For UPDATE
 **
 ** If the sqlite3_vtab_nochange(X) routine is called within the [xColumn]
-** method of a [virtual table], then it might return true if the
+** method of a [virtual table], then it returns true if and only if the
 ** column is being fetched as part of an UPDATE operation during which the
-** column value will not change.  The virtual table implementation can use
-** this hint as permission to substitute a return value that is less
-** expensive to compute and that the corresponding
+** column value will not change.  Applications might use this to substitute
+** a return value that is less expensive to compute and that the corresponding
 ** [xUpdate] method understands as a "no-change" value.
 **
 ** If the [xColumn] method calls sqlite3_vtab_nochange() and finds that
@@ -9303,12 +9204,6 @@ SQLITE_API int sqlite3_vtab_on_conflict(sqlite3 *);
 ** any of the [sqlite3_result_int|sqlite3_result_xxxxx() interfaces].
 ** In that case, [sqlite3_value_nochange(X)] will return true for the
 ** same column in the [xUpdate] method.
-**
-** The sqlite3_vtab_nochange() routine is an optimization.  Virtual table
-** implementations should continue to give a correct answer even if the
-** sqlite3_vtab_nochange() interface were to always return false.  In the
-** current implementation, the sqlite3_vtab_nochange() interface does always
-** returns false for the enhanced [UPDATE FROM] statement.
 */
 SQLITE_API int sqlite3_vtab_nochange(sqlite3_context*);
 
@@ -9450,7 +9345,6 @@ SQLITE_API void sqlite3_stmt_scanstatus_reset(sqlite3_stmt*);
 
 /*
 ** CAPI3REF: Flush caches to disk mid-transaction
-** METHOD: sqlite3
 **
 ** ^If a write-transaction is open on [database connection] D when the
 ** [sqlite3_db_cacheflush(D)] interface invoked, any dirty
@@ -9483,7 +9377,6 @@ SQLITE_API int sqlite3_db_cacheflush(sqlite3*);
 
 /*
 ** CAPI3REF: The pre-update hook.
-** METHOD: sqlite3
 **
 ** ^These interfaces are only available if SQLite is compiled using the
 ** [SQLITE_ENABLE_PREUPDATE_HOOK] compile-time option.
@@ -9524,7 +9417,7 @@ SQLITE_API int sqlite3_db_cacheflush(sqlite3*);
 ** seventh parameter is the final rowid value of the row being inserted
 ** or updated. The value of the seventh parameter passed to the callback
 ** function is not defined for operations on WITHOUT ROWID tables, or for
-** DELETE operations on rowid tables.
+** INSERT operations on rowid tables.
 **
 ** The [sqlite3_preupdate_old()], [sqlite3_preupdate_new()],
 ** [sqlite3_preupdate_count()], and [sqlite3_preupdate_depth()] interfaces
@@ -9562,15 +9455,6 @@ SQLITE_API int sqlite3_db_cacheflush(sqlite3*);
 ** triggers; or 2 for changes resulting from triggers called by top-level
 ** triggers; and so forth.
 **
-** When the [sqlite3_blob_write()] API is used to update a blob column,
-** the pre-update hook is invoked with SQLITE_DELETE. This is because the
-** in this case the new values are not available. In this case, when a
-** callback made with op==SQLITE_DELETE is actuall a write using the
-** sqlite3_blob_write() API, the [sqlite3_preupdate_blobwrite()] returns
-** the index of the column being written. In other cases, where the
-** pre-update hook is being invoked for some other reason, including a
-** regular DELETE, sqlite3_preupdate_blobwrite() returns -1.
-**
 ** See also:  [sqlite3_update_hook()]
 */
 #if defined(SQLITE_ENABLE_PREUPDATE_HOOK)
@@ -9591,12 +9475,10 @@ SQLITE_API int sqlite3_preupdate_old(sqlite3 *, int, sqlite3_value **);
 SQLITE_API int sqlite3_preupdate_count(sqlite3 *);
 SQLITE_API int sqlite3_preupdate_depth(sqlite3 *);
 SQLITE_API int sqlite3_preupdate_new(sqlite3 *, int, sqlite3_value **);
-SQLITE_API int sqlite3_preupdate_blobwrite(sqlite3 *);
 #endif
 
 /*
 ** CAPI3REF: Low-level system error code
-** METHOD: sqlite3
 **
 ** ^Attempt to return the underlying operating system error code or error
 ** number that caused the most recent I/O error or failure to open a file.
@@ -9830,8 +9712,8 @@ SQLITE_API SQLITE_EXPERIMENTAL int sqlite3_snapshot_recover(sqlite3 *db, const c
 ** SQLITE_SERIALIZE_NOCOPY bit is omitted from argument F if a memory
 ** allocation error occurs.
 **
-** This interface is omitted if SQLite is compiled with the
-** [SQLITE_OMIT_DESERIALIZE] option.
+** This interface is only available if SQLite is compiled with the
+** [SQLITE_ENABLE_DESERIALIZE] option.
 */
 SQLITE_API unsigned char *sqlite3_serialize(
   sqlite3 *db,           /* The database connection */
@@ -9882,8 +9764,8 @@ SQLITE_API unsigned char *sqlite3_serialize(
 ** SQLITE_DESERIALIZE_FREEONCLOSE bit is set in argument F, then
 ** [sqlite3_free()] is invoked on argument P prior to returning.
 **
-** This interface is omitted if SQLite is compiled with the
-** [SQLITE_OMIT_DESERIALIZE] option.
+** This interface is only available if SQLite is compiled with the
+** [SQLITE_ENABLE_DESERIALIZE] option.
 */
 SQLITE_API int sqlite3_deserialize(
   sqlite3 *db,            /* The database connection */
@@ -10132,38 +10014,6 @@ SQLITE_API int sqlite3session_create(
 */
 SQLITE_API void sqlite3session_delete(sqlite3_session *pSession);
 
-/*
-** CAPIREF: Conigure a Session Object
-** METHOD: sqlite3_session
-**
-** This method is used to configure a session object after it has been
-** created. At present the only valid value for the second parameter is
-** [SQLITE_SESSION_OBJCONFIG_SIZE].
-**
-** Arguments for sqlite3session_object_config()
-**
-** The following values may passed as the the 4th parameter to
-** sqlite3session_object_config().
-**
-** <dt>SQLITE_SESSION_OBJCONFIG_SIZE <dd>
-**   This option is used to set, clear or query the flag that enables
-**   the [sqlite3session_changeset_size()] API. Because it imposes some
-**   computational overhead, this API is disabled by default. Argument
-**   pArg must point to a value of type (int). If the value is initially
-**   0, then the sqlite3session_changeset_size() API is disabled. If it
-**   is greater than 0, then the same API is enabled. Or, if the initial
-**   value is less than zero, no change is made. In all cases the (int)
-**   variable is set to 1 if the sqlite3session_changeset_size() API is
-**   enabled following the current call, or 0 otherwise.
-**
-**   It is an error (SQLITE_MISUSE) to attempt to modify this setting after
-**   the first table has been attached to the session object.
-*/
-SQLITE_API int sqlite3session_object_config(sqlite3_session*, int op, void *pArg);
-
-/*
-*/
-#define SQLITE_SESSION_OBJCONFIG_SIZE 1
 
 /*
 ** CAPI3REF: Enable Or Disable A Session Object
@@ -10408,22 +10258,6 @@ SQLITE_API int sqlite3session_changeset(
   void **ppChangeset              /* OUT: Buffer containing changeset */
 );
 
-/*
-** CAPI3REF: Return An Upper-limit For The Size Of The Changeset
-** METHOD: sqlite3_session
-**
-** By default, this function always returns 0. For it to return
-** a useful result, the sqlite3_session object must have been configured
-** to enable this API using sqlite3session_object_config() with the
-** SQLITE_SESSION_OBJCONFIG_SIZE verb.
-**
-** When enabled, this function returns an upper limit, in bytes, for the size
-** of the changeset that might be produced if sqlite3session_changeset() were
-** called. The final changeset size might be equal to or smaller than the
-** size in bytes returned by this function.
-*/
-SQLITE_API sqlite3_int64 sqlite3session_changeset_size(sqlite3_session *pSession);
-
 /*
 ** CAPI3REF: Load The Difference Between Tables Into A Session
 ** METHOD: sqlite3_session
@@ -10541,14 +10375,6 @@ SQLITE_API int sqlite3session_patchset(
 */
 SQLITE_API int sqlite3session_isempty(sqlite3_session *pSession);
 
-/*
-** CAPI3REF: Query for the amount of heap memory used by a session object.
-**
-** This API returns the total amount of heap memory in bytes currently
-** used by the session object passed as the only argument.
-*/
-SQLITE_API sqlite3_int64 sqlite3session_memory_used(sqlite3_session *pSession);
-
 /*
 ** CAPI3REF: Create An Iterator To Traverse A Changeset
 ** CONSTRUCTOR: sqlite3_changeset_iter
@@ -10651,23 +10477,18 @@ SQLITE_API int sqlite3changeset_next(sqlite3_changeset_iter *pIter);
 ** call to [sqlite3changeset_next()] must have returned [SQLITE_ROW]. If this
 ** is not the case, this function returns [SQLITE_MISUSE].
 **
-** Arguments pOp, pnCol and pzTab may not be NULL. Upon return, three
-** outputs are set through these pointers:
-**
-** *pOp is set to one of [SQLITE_INSERT], [SQLITE_DELETE] or [SQLITE_UPDATE],
-** depending on the type of change that the iterator currently points to;
-**
-** *pnCol is set to the number of columns in the table affected by the change; and
-**
-** *pzTab is set to point to a nul-terminated utf-8 encoded string containing
-** the name of the table affected by the current change. The buffer remains
-** valid until either sqlite3changeset_next() is called on the iterator
-** or until the conflict-handler function returns.
-**
-** If pbIndirect is not NULL, then *pbIndirect is set to true (1) if the change
+** If argument pzTab is not NULL, then *pzTab is set to point to a
+** nul-terminated utf-8 encoded string containing the name of the table
+** affected by the current change. The buffer remains valid until either
+** sqlite3changeset_next() is called on the iterator or until the
+** conflict-handler function returns. If pnCol is not NULL, then *pnCol is
+** set to the number of columns in the table affected by the change. If
+** pbIndirect is not NULL, then *pbIndirect is set to true (1) if the change
 ** is an indirect change, or false (0) otherwise. See the documentation for
 ** [sqlite3session_indirect()] for a description of direct and indirect
-** changes.
+** changes. Finally, if pOp is not NULL, then *pOp is set to one of
+** [SQLITE_INSERT], [SQLITE_DELETE] or [SQLITE_UPDATE], depending on the
+** type of change that the iterator currently points to.
 **
 ** If no error occurs, SQLITE_OK is returned. If an error does occur, an
 ** SQLite error code is returned. The values of the output variables may not

devtools/client/framework/dev-edition-promo/dev-edition-promo.css

@@ -21,7 +21,11 @@ window {
  * depend on. Must style font-size to target linux.
  */
 %ifdef XP_UNIX
+%ifndef XP_MACOSX
   font-size: 13px;
+%else
+  font-size: 15px;
+%endif
 %else
   font-size: 15px;
 %endif

devtools/client/framework/toolbox-process-window.js

@@ -142,6 +142,16 @@ function evaluateTestScript(script, toolbox) {
 function bindToolboxHandlers() {
   gToolbox.once("destroyed", quitApp);
   window.addEventListener("unload", onUnload);
+
+#ifdef XP_MACOSX
+  // Badge the dock icon to differentiate this process from the main application process.
+  updateBadgeText(false);
+
+  // Once the debugger panel opens listen for thread pause / resume.
+  gToolbox.getPanelWhenReady("jsdebugger").then(panel => {
+    setupThreadListeners(panel);
+  });
+#endif
 }
 
 function setupThreadListeners(panel) {

devtools/client/jar.mn

@@ -110,7 +110,7 @@ devtools.jar:
     content/framework/toolbox-init.js (framework/toolbox-init.js)
     content/framework/options-panel.css (framework/options-panel.css)
     content/framework/toolbox-process-window.xul (framework/toolbox-process-window.xul)
-    content/framework/toolbox-process-window.js (framework/toolbox-process-window.js)
+*   content/framework/toolbox-process-window.js (framework/toolbox-process-window.js)
     content/framework/dev-edition-promo/dev-edition-promo.xul (framework/dev-edition-promo/dev-edition-promo.xul)
 *   content/framework/dev-edition-promo/dev-edition-promo.css (framework/dev-edition-promo/dev-edition-promo.css)
     content/framework/dev-edition-promo/dev-edition-logo.png (framework/dev-edition-promo/dev-edition-logo.png)

devtools/client/menus.js

@@ -94,7 +94,7 @@ exports.menuitems = [
     },
     key: {
       id: "browserToolbox",
-      modifiers: "accel,alt,shift",
+      modifiers: isMac ? "accel,alt" : "accel,shift",
       keytext: true
     }
   },

devtools/shared/css/generated/properties-db.js

@@ -3038,7 +3038,6 @@ exports.CSS_PROPERTIES = {
       "scroll-snap-points-y",
       "scroll-snap-type-x",
       "scroll-snap-type-y",
-      "scrollbar-width",
       "shape-outside",
       "shape-rendering",
       "-moz-stack-sizing",

docshell/base/nsDocShell.cpp

@@ -820,8 +820,6 @@ nsDocShell::nsDocShell()
   , mParentCharsetSource(0)
   , mJSRunToCompletionDepth(0)
   , mTouchEventsOverride(nsIDocShell::TOUCHEVENTS_OVERRIDE_NONE)
-  , mStateFloodGuardCount(0)
-  , mStateFloodGuardReported(false)
 {
   AssertOriginAttributesMatchPrivateBrowsing();
   mHistoryID = ++gDocshellIDCounter;
@@ -5449,19 +5447,11 @@ nsDocShell::Stop(uint32_t aStopFlags)
   }
 
   if (nsIWebNavigation::STOP_CONTENT & aStopFlags) {
-    // Stop the document loading and animations
+    // Stop the document loading
     if (mContentViewer) {
       nsCOMPtr<nsIContentViewer> cv = mContentViewer;
       cv->Stop();
     }
-  } else if (nsIWebNavigation::STOP_NETWORK & aStopFlags) {
-    // Stop the document loading only
-    if (mContentViewer) {
-      RefPtr<nsIDocument> doc = mContentViewer->GetDocument();
-      if (doc) {
-        doc->StopDocumentLoad();
-      }
-    }
   }
 
   if (nsIWebNavigation::STOP_NETWORK & aStopFlags) {
@@ -11843,27 +11833,6 @@ nsDocShell::SetReferrerPolicy(uint32_t aReferrerPolicy)
 // nsDocShell: Session History
 //*****************************************************************************
 
-bool
-nsDocShell::IsStateChangeFlooding()
-{
-  // Issue #1688: Let's copy Firefox's strategy for state flooding here, so
-  // that our implementations are interoperable.
-  if (mStateFloodGuardCount > kStateUpdateLimit) {
-    TimeStamp now = TimeStamp::Now();
-
-    if (now - mStateFloodGuardUpdated > TimeDuration::FromSeconds(kRefreshTimeSecs)) {
-      mStateFloodGuardCount = 0;
-      mStateFloodGuardUpdated = now;
-      mStateFloodGuardReported = false;
-      return false;
-    }
-    return true;
-  }
-
-  mStateFloodGuardCount++;
-  return false;
-}
-
 NS_IMETHODIMP
 nsDocShell::AddState(JS::Handle<JS::Value> aData, const nsAString& aTitle,
                      const nsAString& aURL, bool aReplace, JSContext* aCx)
@@ -11928,24 +11897,6 @@ nsDocShell::AddState(JS::Handle<JS::Value> aData, const nsAString& aTitle,
   nsCOMPtr<nsIDocument> document = GetDocument();
   NS_ENSURE_TRUE(document, NS_ERROR_FAILURE);
 
-  // If we're being flooded with state change requests, we should abort early
-  // from the state change logic.
-  if (IsStateChangeFlooding()) {
-    // Report a warning to the console to tell developers why their navigations
-    // failed.
-    // Do this only if not yet marked reported so we only report it once per
-    // flood interval.
-    if (!mStateFloodGuardReported) {
-      nsContentUtils::ReportToConsole(nsIScriptError::warningFlag,
-                                      NS_LITERAL_CSTRING("PushState"),
-                                      document,
-                                      nsContentUtils::eDOM_PROPERTIES,
-                                      "PushStateFloodingPrevented");
-      mStateFloodGuardReported = true;
-    }
-    return NS_OK;
-  }
-
   // Step A: Serialize aData using structured clone.
   // https://html.spec.whatwg.org/multipage/history.html#dom-history-pushstate
   // step 5.

docshell/base/nsDocShell.h

@@ -1049,15 +1049,6 @@ private:
   // as constants in the nsIDocShell.idl file.
   uint32_t mTouchEventsOverride;
 
-  // Keep track how how many history state changes we're getting, to catch &
-  // prevent flooding.
-  int32_t mStateFloodGuardCount;
-  mozilla::TimeStamp mStateFloodGuardUpdated;
-  bool mStateFloodGuardReported;
-  // We have a limit of pushing 50 states to history every 10 seconds.
-  const int32_t kStateUpdateLimit = 50;
-  const double kRefreshTimeSecs = 10.0;
-
   // Separate function to do the actual name (i.e. not _top, _self etc.)
   // searching for FindItemWithName.
   nsresult DoFindItemWithName(const nsAString& aName,
@@ -1073,10 +1064,6 @@ private:
   void MaybeNotifyKeywordSearchLoading(const nsString& aProvider,
                                        const nsString& aKeyword);
 
-  // Helper method for AddState which checks for excessive calls to PushState or
-  // ReplaceState.
-  bool IsStateChangeFlooding();
-
 #ifdef DEBUG
   // We're counting the number of |nsDocShells| to help find leaks
   static unsigned long gNumberOfDocShells;

dom/animation/KeyframeEffect.cpp

@@ -10,7 +10,6 @@
 #include "mozilla/dom/AnimationEffectTiming.h"
 #include "mozilla/dom/KeyframeEffectBinding.h"
 #include "mozilla/KeyframeUtils.h"
-#include "mozilla/Preferences.h"
 #include "nsContentUtils.h"
 #include "nsDOMMutationObserver.h" // For nsAutoAnimationMutationBatch
 #include "nsIScriptError.h"
@@ -136,9 +135,9 @@ void
 KeyframeEffect::SetIterationComposite(
   const IterationCompositeOperation& aIterationComposite)
 {
-  // Ignore iterationComposite if the API is not enabled,
+  // Ignore iterationComposite if the Web Animations API is not enabled,
   // then the default value 'Replace' will be used.
-  if (!Preferences::GetBool("dom.animations-api.compositing.enabled")) {
+  if (!AnimationUtils::IsCoreAPIEnabledForCaller()) {
     return;
   }
 

dom/animation/KeyframeEffectReadOnly.cpp

@@ -1089,7 +1089,7 @@ KeyframeEffectReadOnly::CanThrottleTransformChanges(nsIFrame& aFrame) const
     return true;
   }
 
-  ScrollStyles ss = scrollable->GetScrollStyles();
+  ScrollbarStyles ss = scrollable->GetScrollbarStyles();
   if (ss.mVertical == NS_STYLE_OVERFLOW_HIDDEN &&
       ss.mHorizontal == NS_STYLE_OVERFLOW_HIDDEN &&
       scrollable->GetLogicalScrollPosition() == nsPoint(0, 0)) {

dom/animation/KeyframeUtils.cpp

@@ -7,7 +7,6 @@
 #include "mozilla/AnimationUtils.h"
 #include "mozilla/ErrorResult.h"
 #include "mozilla/Move.h"
-#include "mozilla/Preferences.h"
 #include "mozilla/RangedArray.h"
 #include "mozilla/ServoBindings.h"
 #include "mozilla/StyleAnimationValue.h"
@@ -22,7 +21,6 @@
 #include "nsCSSPropertyIDSet.h"
 #include "nsCSSProps.h"
 #include "nsCSSPseudoElements.h" // For CSSPseudoElementType
-#include "nsDocument.h"
 #include "nsTArray.h"
 #include <algorithm> // For std::stable_sort
 
@@ -402,7 +400,7 @@ GetKeyframeListFromPropertyIndexedKeyframe(JSContext* aCx,
                                            ErrorResult& aRv);
 
 static bool
-HasImplicitKeyframeValues(const nsTArray<Keyframe>& aKeyframes,
+RequiresAdditiveAnimation(const nsTArray<Keyframe>& aKeyframes,
                           nsIDocument* aDocument);
 
 static void
@@ -469,13 +467,11 @@ KeyframeUtils::GetKeyframesFromObject(JSContext* aCx,
   // says that if you don't have a keyframe at offset 0 or 1, then you should
   // synthesize one using an additive zero value when you go to compose style.
   // Until we implement additive animations we just throw if we encounter any
-  // set of keyframes that would put us in that situation and keyframes aren't
-  // explicitly force-enabled.
+  // set of keyframes that would put us in that situation.
 
-  if (!nsDocument::AreWebAnimationsImplicitKeyframesEnabled(aCx, nullptr) &&
-      HasImplicitKeyframeValues(keyframes, aDocument)) {
-    keyframes.Clear();
+  if (RequiresAdditiveAnimation(keyframes, aDocument)) {
     aRv.Throw(NS_ERROR_DOM_ANIM_MISSING_PROPS_ERR);
+    keyframes.Clear();
   }
 
   return keyframes;
@@ -1334,16 +1330,10 @@ GetKeyframeListFromPropertyIndexedKeyframe(JSContext* aCx,
       // No animation values for this property.
       continue;
     }
-    if (!Preferences::GetBool("dom.animations-api.implicit-keyframes.enabled") &&
-        count == 1) {
-      // We don't support implicit keyframes by preference.
-      aRv.Throw(NS_ERROR_DOM_ANIM_MISSING_PROPS_ERR);
-      return;
-    } else if (count == 1) {
-      // Implicit keyframes isn't implemented yet and so we can't
-      // support an animation that goes from the underlying value
-      // to this specified value.
-      // Throw an exception until we do support this.
+    if (count == 1) {
+      // We don't support additive values and so can't support an
+      // animation that goes from the underlying value to this
+      // specified value.  Throw an exception until we do support this.
       aRv.Throw(NS_ERROR_DOM_ANIM_MISSING_PROPS_ERR);
       return;
     }
@@ -1384,7 +1374,7 @@ GetKeyframeListFromPropertyIndexedKeyframe(JSContext* aCx,
  *   try to detect where we have an invalid value at 0%/100%.
  */
 static bool
-HasImplicitKeyframeValues(const nsTArray<Keyframe>& aKeyframes,
+RequiresAdditiveAnimation(const nsTArray<Keyframe>& aKeyframes,
                           nsIDocument* aDocument)
 {
   // We are looking to see if that every property referenced in |aKeyframes|
@@ -1395,7 +1385,7 @@ HasImplicitKeyframeValues(const nsTArray<Keyframe>& aKeyframes,
   // a document which we might not always have at the point where we want to
   // perform this check.
   //
-  // This is only a temporary measure until we implement implicit keyframes.
+  // This is only a temporary measure until we implement additive animation.
   // So as long as this check catches most cases, and we don't do anything
   // horrible in one of the cases we can't detect, it should be sufficient.
 

dom/animation/test/crashtests/crashtests.list

@@ -1,13 +1,13 @@
 pref(dom.animations-api.core.enabled,true) load 1239889-1.html
 pref(dom.animations-api.core.enabled,true) load 1244595-1.html
-pref(dom.animations-api.core.enabled,true) pref(dom.animations-api.timelines.enabled,true) load 1216842-1.html
-pref(dom.animations-api.core.enabled,true) pref(dom.animations-api.timelines.enabled,true) load 1216842-2.html
-pref(dom.animations-api.core.enabled,true) pref(dom.animations-api.timelines.enabled,true) load 1216842-3.html
-pref(dom.animations-api.core.enabled,true) pref(dom.animations-api.timelines.enabled,true) load 1216842-4.html
-pref(dom.animations-api.core.enabled,true) pref(dom.animations-api.timelines.enabled,true) load 1216842-5.html
-pref(dom.animations-api.core.enabled,true) pref(dom.animations-api.timelines.enabled,true) load 1216842-6.html
+pref(dom.animations-api.core.enabled,true) load 1216842-1.html
+pref(dom.animations-api.core.enabled,true) load 1216842-2.html
+pref(dom.animations-api.core.enabled,true) load 1216842-3.html
+pref(dom.animations-api.core.enabled,true) load 1216842-4.html
+pref(dom.animations-api.core.enabled,true) load 1216842-5.html
+pref(dom.animations-api.core.enabled,true) load 1216842-6.html
 pref(dom.animations-api.core.enabled,true) load 1272475-1.html
 pref(dom.animations-api.core.enabled,true) load 1272475-2.html
 pref(dom.animations-api.core.enabled,true) load 1278485-1.html
-pref(dom.animations-api.core.enabled,true) pref(dom.animations-api.timelines.enabled,true) load 1277272-1.html
+pref(dom.animations-api.core.enabled,true) load 1277272-1.html
 pref(dom.animations-api.core.enabled,true) load 1290535-1.html

dom/animation/test/mochitest.ini

@@ -1,10 +1,4 @@
 [DEFAULT]
-prefs =
-  dom.animations-api.compositing.enabled=true
-  dom.animations-api.core.enabled=true
-  dom.animations-api.getAnimations.enabled=true
-  dom.animations-api.implicit-keyframes.enabled=true
-  dom.animations-api.timelines.enabled=true
 # Support files for chrome tests that we want to load over HTTP need
 # to go in here, not chrome.ini.
 support-files =

dom/apps/AppsUtils.jsm

@@ -84,6 +84,9 @@ function _setAppProperties(aObj, aApp) {
   aObj.csp = aApp.csp;
   aObj.installOrigin = aApp.installOrigin;
   aObj.origin = aApp.origin;
+#ifdef MOZ_WIDGET_ANDROID
+  aObj.apkPackageName = aApp.apkPackageName;
+#endif
   aObj.receipts = aApp.receipts ? JSON.parse(JSON.stringify(aApp.receipts)) : null;
   aObj.installTime = aApp.installTime;
   aObj.manifestURL = aApp.manifestURL;

dom/apps/moz.build

@@ -12,7 +12,10 @@ EXTRA_COMPONENTS += [
 
 EXTRA_JS_MODULES += [
     'AppsServiceChild.jsm',
-    'AppsUtils.jsm',
     'PermissionsInstaller.jsm',
     'PermissionsTable.jsm',
 ]
+
+EXTRA_PP_JS_MODULES += [
+    'AppsUtils.jsm',
+]

dom/audiochannel/AudioChannelService.cpp

@@ -159,8 +159,16 @@ bool
 IsEnableAudioCompetingForAllAgents()
 {
   // In general, the audio competing should only be for audible media and it
-  // helps user can focus on one media at the same time.
+  // helps user can focus on one media at the same time. However, we hope to
+  // treat all media as the same in the mobile device. First reason is we have
+  // media control on fennec and we just want to control one media at once time.
+  // Second reason is to reduce the bandwidth, avoiding to play any non-audible
+  // media in background which user doesn't notice about.
+#ifdef MOZ_WIDGET_ANDROID
+  return true;
+#else
   return sAudioChannelCompetingAllAgents;
+#endif
 }
 
 } // anonymous namespace

dom/base/Element.cpp

@@ -745,7 +745,7 @@ Element::Scroll(const CSSIntPoint& aScroll, const ScrollOptions& aOptions)
     if (aOptions.mBehavior == ScrollBehavior::Smooth) {
       scrollMode = nsIScrollableFrame::SMOOTH_MSD;
     } else if (aOptions.mBehavior == ScrollBehavior::Auto) {
-      ScrollStyles styles = sf->GetScrollStyles();
+      ScrollbarStyles styles = sf->GetScrollbarStyles();
       if (styles.mScrollBehavior == NS_STYLE_SCROLL_BEHAVIOR_SMOOTH) {
         scrollMode = nsIScrollableFrame::SMOOTH_MSD;
       }
@@ -834,7 +834,7 @@ Element::SetScrollTop(int32_t aScrollTop)
   nsIScrollableFrame* sf = GetScrollFrame();
   if (sf) {
     nsIScrollableFrame::ScrollMode scrollMode = nsIScrollableFrame::INSTANT;
-    if (sf->GetScrollStyles().mScrollBehavior == NS_STYLE_SCROLL_BEHAVIOR_SMOOTH) {
+    if (sf->GetScrollbarStyles().mScrollBehavior == NS_STYLE_SCROLL_BEHAVIOR_SMOOTH) {
       scrollMode = nsIScrollableFrame::SMOOTH_MSD;
     }
     sf->ScrollToCSSPixels(CSSIntPoint(sf->GetScrollPositionCSSPixels().x,
@@ -856,7 +856,7 @@ Element::SetScrollLeft(int32_t aScrollLeft)
   nsIScrollableFrame* sf = GetScrollFrame();
   if (sf) {
     nsIScrollableFrame::ScrollMode scrollMode = nsIScrollableFrame::INSTANT;
-    if (sf->GetScrollStyles().mScrollBehavior == NS_STYLE_SCROLL_BEHAVIOR_SMOOTH) {
+    if (sf->GetScrollbarStyles().mScrollBehavior == NS_STYLE_SCROLL_BEHAVIOR_SMOOTH) {
       scrollMode = nsIScrollableFrame::SMOOTH_MSD;
     }
 
@@ -1069,7 +1069,7 @@ ShadowRoot*
 Element::GetShadowRootByMode() const
 {
   /**
-   * 1. Let shadow be context object???s shadow root.
+   * 1. Let shadow be context object’s shadow root.
    * 2. If shadow is null or its mode is "closed", then return null.
    */
   ShadowRoot* shadowRoot = GetShadowRoot();
@@ -1088,7 +1088,7 @@ already_AddRefed<ShadowRoot>
 Element::AttachShadow(const ShadowRootInit& aInit, ErrorResult& aError)
 {
   /**
-   * 1. If context object???s namespace is not the HTML namespace,
+   * 1. If context object’s namespace is not the HTML namespace,
    *    then throw a "NotSupportedError" DOMException.
    */
   if (!IsHTMLElement()) {
@@ -1097,7 +1097,7 @@ Element::AttachShadow(const ShadowRootInit& aInit, ErrorResult& aError)
   }
 
   /**
-   * 2. If context object???s local name is not
+   * 2. If context object’s local name is not
    *      a valid custom element name, "article", "aside", "blockquote",
    *      "body", "div", "footer", "h1", "h2", "h3", "h4", "h5", "h6",
    *      "header", "main" "nav", "p", "section", or "span",
@@ -1181,8 +1181,8 @@ Element::AttachShadowInternal(bool aClosed, ErrorResult& aError)
 
   /**
    * 4. Let shadow be a new shadow root whose node document is
-   *    context object???s node document, host is context object,
-   *    and mode is init???s mode.
+   *    context object’s node document, host is context object,
+   *    and mode is init’s mode.
    */
   RefPtr<ShadowRoot> shadowRoot =
     new ShadowRoot(this, aClosed, nodeInfo.forget(), protoBinding);
@@ -1190,7 +1190,7 @@ Element::AttachShadowInternal(bool aClosed, ErrorResult& aError)
   shadowRoot->SetIsComposedDocParticipant(IsInComposedDoc());
 
   /**
-   * 5. Set context object???s shadow root to shadow.
+   * 5. Set context object’s shadow root to shadow.
    */
   SetShadowRoot(shadowRoot);
 
@@ -1890,7 +1890,7 @@ Element::UnbindFromTree(bool aDeep, bool aNullParent)
       nsPresContext* presContext = presShell->GetPresContext();
       if (presContext) {
         MOZ_ASSERT(this !=
-                   presContext->GetViewportScrollStylesOverrideNode(),
+                   presContext->GetViewportScrollbarStylesOverrideNode(),
                    "Leaving behind a raw pointer to this node (as having "
                    "propagated scrollbar styles) - that's dangerous...");
       }

dom/base/Navigator.cpp

@@ -1407,6 +1407,12 @@ Navigator::GetPlatform(nsAString& aPlatform, bool aUsePrefOverriddenValue)
   aPlatform.AssignLiteral("Win64");
 #elif defined(WIN32)
   aPlatform.AssignLiteral("Win32");
+#elif defined(XP_MACOSX) && defined(__ppc__)
+  aPlatform.AssignLiteral("MacPPC");
+#elif defined(XP_MACOSX) && defined(__i386__)
+  aPlatform.AssignLiteral("MacIntel");
+#elif defined(XP_MACOSX) && defined(__x86_64__)
+  aPlatform.AssignLiteral("MacIntel");
 #else
   // XXX Communicator uses compiled-in build-time string defines
   // to indicate the platform it was compiled *for*, not what it is

dom/base/ResizeObserver.cpp

@@ -1,376 +1,304 @@
-/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* 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 "mozilla/dom/ResizeObserver.h"
-
-#include "mozilla/dom/DOMRect.h"
-#include "nsIContentInlines.h"
-#include "nsIFrame.h"
-#include "nsSVGUtils.h"
-
-namespace mozilla {
-namespace dom {
-
-/**
- * Returns the length of the parent-traversal path (in terms of the number of
- * nodes) to an unparented/root node from aNode. An unparented/root node is
- * considered to have a depth of 1, its children have a depth of 2, etc.
- * aNode is expected to be non-null.
- * Note: The shadow root is not part of the calculation because the caller,
- * ResizeObserver, doesn't observe the shadow root, and only needs relative
- * depths among all the observed targets. In other words, we calculate the
- * depth of the flattened tree.
- *
- * Note: these is a spec issue about how to handle shadow DOM case. We
- * may need to update this function later.
- *
- *
- * https://drafts.csswg.org/resize-observer/#calculate-depth-for-node-h
- */
-static uint32_t
-GetNodeDepth(nsINode* aNode) {
-  uint32_t depth = 1;
-
-  MOZ_ASSERT(aNode, "Node shouldn't be null");
-
-  // Use GetFlattenedTreeParentNode to bypass the shadow root and cross the
-  // shadow boundary to calculate the node depth without the shadow root.
-  while ((aNode = aNode->GetFlattenedTreeParentNode())) {
-    ++depth;
-  }
-
-  return depth;
-}
-
-/**
- * Returns |aTarget|'s size in the form of an nsSize.
- * If the target is an SVG, width and height are determined from the bounding box.
- */
-static nsSize
-GetTargetSize(Element* aTarget, ResizeObserverBoxOptions aBox) {
-  nsSize size;
-  nsIFrame* frame = aTarget->GetPrimaryFrame();
-
-  if (!frame) {
-    return size;
-  }
-
-  if (aTarget->IsSVGElement()) {
-    // Per the spec, an SVG size is always its bounding box size, no matter what
-    // box option you choose, because SVG elements do not use the standard CSS box
-    // model.
-    gfxRect bbox = nsSVGUtils::GetBBox(frame);
-    size.width = NSFloatPixelsToAppUnits(bbox.width, AppUnitsPerCSSPixel());
-    size.height = NSFloatPixelsToAppUnits(bbox.height, AppUnitsPerCSSPixel());
-  } else {
-    // Per the spec, non-replaced inline Elements will always have an empty
-    // content rect. We therefore always use the same empty size for
-    // non-replaced inline elements here, and their IsActive() will
-    // always return false. (So its observation won't be fired.)
-    if (!frame->IsFrameOfType(nsIFrame::eReplaced) &&
-        frame->IsFrameOfType(nsIFrame::eLineParticipant)) {
-      return size;
-    }
-
-    switch (aBox) {
-      case ResizeObserverBoxOptions::Border_box:
-        // GetSize() includes the content area, borders, and padding.
-        size = frame->GetSize();
-        break;
-      case ResizeObserverBoxOptions::Content_box:
-      default:
-        size = frame->GetContentRectRelativeToSelf().Size();
-    }
-  }
-
-  return size;
-}
-
-NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(ResizeObserver)
-  NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
-  NS_INTERFACE_MAP_ENTRY(nsISupports)
-NS_INTERFACE_MAP_END
-
-NS_IMPL_CYCLE_COLLECTING_ADDREF(ResizeObserver)
-NS_IMPL_CYCLE_COLLECTING_RELEASE(ResizeObserver)
-
-NS_IMPL_CYCLE_COLLECTION_CLASS(ResizeObserver)
-
-NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(ResizeObserver)
-  NS_IMPL_CYCLE_COLLECTION_TRACE_PRESERVED_WRAPPER
-NS_IMPL_CYCLE_COLLECTION_TRACE_END
-
-NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(ResizeObserver)
-  NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER
-  NS_IMPL_CYCLE_COLLECTION_UNLINK(mOwner)
-  NS_IMPL_CYCLE_COLLECTION_UNLINK(mCallback)
-  NS_IMPL_CYCLE_COLLECTION_UNLINK(mObservationMap)
-NS_IMPL_CYCLE_COLLECTION_UNLINK_END
-
-NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(ResizeObserver)
-  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mOwner)
-  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mCallback)
-  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mObservationMap)
-NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
-
-already_AddRefed<ResizeObserver>
-ResizeObserver::Constructor(const GlobalObject& aGlobal,
-                            ResizeObserverCallback& aCb,
-                            ErrorResult& aRv)
-{
-  nsCOMPtr<nsPIDOMWindowInner> window =
-    do_QueryInterface(aGlobal.GetAsSupports());
-
-  if (!window) {
-    aRv.Throw(NS_ERROR_FAILURE);
-    return nullptr;
-  }
-
-  nsCOMPtr<nsIDocument> document = window->GetExtantDoc();
-
-  if (!document) {
-    aRv.Throw(NS_ERROR_FAILURE);
-    return nullptr;
-  }
-
-  RefPtr<ResizeObserver> observer = new ResizeObserver(window.forget(), aCb);
-  document->AddResizeObserver(observer);
-
-  return observer.forget();
-}
-
-void
-ResizeObserver::Observe(Element* aTarget,
-                        const ResizeObserverOptions& aOptions,
-                        ErrorResult& aRv)
-{
-  if (!aTarget) {
-    aRv.Throw(NS_ERROR_DOM_NOT_FOUND_ERR);
-    return;
-  }
-
-  RefPtr<ResizeObservation> observation;
-
-  if (!mObservationMap.Get(aTarget, getter_AddRefs(observation))) {
-    nsIFrame* frame = aTarget->GetPrimaryFrame();
-    WritingMode wm = frame ? frame->GetWritingMode() : WritingMode();
-    observation = new ResizeObservation(aTarget->OwnerDoc(), aTarget, aOptions.mBox, wm);
-
-    mObservationMap.Put(aTarget, observation);
-    mObservationList.insertBack(observation);
-
-    // Per the spec, we need to trigger notification in event loop that
-    // contains ResizeObserver observe call even when resize/reflow does
-    // not happen.
-    aTarget->OwnerDoc()->ScheduleResizeObserversNotification();
-  }
-}
-
-void
-ResizeObserver::Unobserve(Element* aTarget,
-                          ErrorResult& aRv)
-{
-  if (!aTarget) {
-    aRv.Throw(NS_ERROR_DOM_NOT_FOUND_ERR);
-    return;
-  }
-
-  RefPtr<ResizeObservation> observation;
-
-  if (mObservationMap.Get(aTarget, getter_AddRefs(observation))) {
-    mObservationMap.Remove(aTarget);
-
-    MOZ_ASSERT(!mObservationList.isEmpty(),
-               "If ResizeObservation found for an element, observation list "
-               "must be not empty.");
-
-    observation->remove();
-  }
-}
-
-void
-ResizeObserver::Disconnect()
-{
-  mObservationMap.Clear();
-  mObservationList.clear();
-  mActiveTargets.Clear();
-}
-
-void
-ResizeObserver::GatherActiveObservations(uint32_t aDepth)
-{
-  mActiveTargets.Clear();
-  mHasSkippedTargets = false;
-
-  for (auto observation : mObservationList) {
-    if (observation->IsActive()) {
-      uint32_t targetDepth = GetNodeDepth(observation->Target());
-
-      if (targetDepth > aDepth) {
-        mActiveTargets.AppendElement(observation);
-      } else {
-        mHasSkippedTargets = true;
-      }
-    }
-  }
-}
-
-bool
-ResizeObserver::HasActiveObservations() const
-{
-  return !mActiveTargets.IsEmpty();
-}
-
-bool
-ResizeObserver::HasSkippedObservations() const
-{
-  return mHasSkippedTargets;
-}
-
-uint32_t
-ResizeObserver::BroadcastActiveObservations()
-{
-  uint32_t shallowestTargetDepth = UINT32_MAX;
-
-  if (HasActiveObservations()) {
-    Sequence<OwningNonNull<ResizeObserverEntry>> entries;
-
-    for (auto observation : mActiveTargets) {
-      Element* target = observation->Target();
-      RefPtr<ResizeObserverEntry> entry = new ResizeObserverEntry(this, target);
-
-      nsSize borderBoxSize = GetTargetSize(target, ResizeObserverBoxOptions::Border_box);
-      entry->SetBorderBoxSize(borderBoxSize);
-
-      nsSize contentBoxSize = GetTargetSize(target, ResizeObserverBoxOptions::Content_box);
-      entry->SetContentRectAndSize(contentBoxSize);
-
-      if (!entries.AppendElement(entry.forget(), fallible)) {
-        // Out of memory.
-        break;
-      }
-
-      // Sync the broadcast size of observation so the next size inspection
-      // will be based on the updated size from last delivered observations.
-      switch (observation->BoxOptions()) {
-        case ResizeObserverBoxOptions::Border_box:
-          observation->UpdateLastReportedSize(borderBoxSize);
-          break;
-        case ResizeObserverBoxOptions::Content_box:
-        default:
-          observation->UpdateLastReportedSize(contentBoxSize);
-      }
-
-      uint32_t targetDepth = GetNodeDepth(observation->Target());
-
-      if (targetDepth < shallowestTargetDepth) {
-        shallowestTargetDepth = targetDepth;
-      }
-    }
-
-    mCallback->Call(this, entries, *this);
-    mActiveTargets.Clear();
-    mHasSkippedTargets = false;
-  }
-
-  return shallowestTargetDepth;
-}
-
-NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(ResizeObserverEntry)
-  NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
-  NS_INTERFACE_MAP_ENTRY(nsISupports)
-NS_INTERFACE_MAP_END
-
-NS_IMPL_CYCLE_COLLECTING_ADDREF(ResizeObserverEntry)
-NS_IMPL_CYCLE_COLLECTING_RELEASE(ResizeObserverEntry)
-
-NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(ResizeObserverEntry,
-                                      mOwner,
-                                      mTarget,
-                                      mContentRect,
-                                      mBorderBoxSize,
-                                      mContentBoxSize)
-
-already_AddRefed<ResizeObserverEntry>
-ResizeObserverEntry::Constructor(const GlobalObject& aGlobal,
-                                 Element* aTarget,
-                                 ErrorResult& aRv)
-{
-  RefPtr<ResizeObserverEntry> observerEntry =
-    new ResizeObserverEntry(aGlobal.GetAsSupports(), aTarget);
-  return observerEntry.forget();
-}
-
-void
-ResizeObserverEntry::SetBorderBoxSize(const nsSize& aSize) {
-  nsIFrame* frame = mTarget->GetPrimaryFrame();
-  WritingMode wm = frame ? frame->GetWritingMode() : WritingMode();
-  mBorderBoxSize = new ResizeObserverSize(this, aSize, wm);
-}
-
-void
-ResizeObserverEntry::SetContentRectAndSize(const nsSize& aSize) {
-  nsIFrame* frame = mTarget->GetPrimaryFrame();
-
-  // Update mContentRect.
-  nsMargin padding = frame ? frame->GetUsedPadding(): nsMargin();
-  // Per the spec, we need to use the top-left padding offset as the origin of
-  // our contentRect.
-  nsRect rect(nsPoint(padding.left, padding.top), aSize);
-  RefPtr<DOMRect> contentRect = new DOMRect(mTarget);
-  contentRect->SetLayoutRect(rect);
-  mContentRect = contentRect.forget();
-
-  // Update mContentBoxSize.
-  WritingMode wm = frame ? frame->GetWritingMode() : WritingMode();
-  mContentBoxSize = new ResizeObserverSize(this, aSize, wm);
-}
-
-ResizeObserverEntry::~ResizeObserverEntry()
-{
-}
-
-NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(ResizeObserverSize, mOwner)
-NS_IMPL_CYCLE_COLLECTING_ADDREF(ResizeObserverSize)
-NS_IMPL_CYCLE_COLLECTING_RELEASE(ResizeObserverSize)
-NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(ResizeObserverSize)
-  NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
-  NS_INTERFACE_MAP_ENTRY(nsISupports)
-NS_INTERFACE_MAP_END
-
-NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(ResizeObservation)
-  NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
-  NS_INTERFACE_MAP_ENTRY(nsISupports)
-NS_INTERFACE_MAP_END
-
-NS_IMPL_CYCLE_COLLECTING_ADDREF(ResizeObservation)
-NS_IMPL_CYCLE_COLLECTING_RELEASE(ResizeObservation)
-
-NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(ResizeObservation,
-                                      mTarget, mOwner)
-
-bool
-ResizeObservation::IsActive() const
-{
-  nsIFrame* frame = mTarget->GetPrimaryFrame();
-  WritingMode wm = frame ? frame->GetWritingMode() : WritingMode();
-  LogicalSize size(wm, GetTargetSize(mTarget, mObservedBox));
-  return mLastReportedSize.ISize(mLastReportedWM) != size.ISize(wm) ||
-         mLastReportedSize.BSize(mLastReportedWM) != size.BSize(wm);
-}
-
-void
-ResizeObservation::UpdateLastReportedSize(const nsSize& aSize) {
-  nsIFrame* frame = mTarget->GetPrimaryFrame();
-  mLastReportedWM = frame ? frame->GetWritingMode() : WritingMode();
-  mLastReportedSize = LogicalSize(mLastReportedWM, aSize);
-}
-
-ResizeObservation::~ResizeObservation()
-{
-}
-
-} // namespace dom
-} // namespace mozilla
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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 "mozilla/dom/ResizeObserver.h"
+
+#include "mozilla/dom/DOMRect.h"
+#include "nsContentUtils.h"
+#include "nsIFrame.h"
+#include "nsSVGUtils.h"
+
+namespace mozilla {
+namespace dom {
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(ResizeObserver)
+  NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
+  NS_INTERFACE_MAP_ENTRY(nsISupports)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(ResizeObserver)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(ResizeObserver)
+
+NS_IMPL_CYCLE_COLLECTION_CLASS(ResizeObserver)
+
+NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(ResizeObserver)
+  NS_IMPL_CYCLE_COLLECTION_TRACE_PRESERVED_WRAPPER
+NS_IMPL_CYCLE_COLLECTION_TRACE_END
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(ResizeObserver)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mOwner)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mCallback)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mObservationMap)
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(ResizeObserver)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mOwner)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mCallback)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mObservationMap)
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+already_AddRefed<ResizeObserver>
+ResizeObserver::Constructor(const GlobalObject& aGlobal,
+                            ResizeObserverCallback& aCb,
+                            ErrorResult& aRv)
+{
+  nsCOMPtr<nsPIDOMWindowInner> window =
+    do_QueryInterface(aGlobal.GetAsSupports());
+
+  if (!window) {
+    aRv.Throw(NS_ERROR_FAILURE);
+    return nullptr;
+  }
+
+  nsCOMPtr<nsIDocument> document = window->GetExtantDoc();
+
+  if (!document) {
+    aRv.Throw(NS_ERROR_FAILURE);
+    return nullptr;
+  }
+
+  RefPtr<ResizeObserver> observer = new ResizeObserver(window.forget(), aCb);
+  document->AddResizeObserver(observer);
+
+  return observer.forget();
+}
+
+void
+ResizeObserver::Observe(Element* aTarget,
+                        ErrorResult& aRv)
+{
+  if (!aTarget) {
+    aRv.Throw(NS_ERROR_DOM_NOT_FOUND_ERR);
+    return;
+  }
+
+  RefPtr<ResizeObservation> observation;
+
+  if (!mObservationMap.Get(aTarget, getter_AddRefs(observation))) {
+    observation = new ResizeObservation(this, aTarget);
+
+    mObservationMap.Put(aTarget, observation);
+    mObservationList.insertBack(observation);
+
+    // Per the spec, we need to trigger notification in event loop that
+    // contains ResizeObserver observe call even when resize/reflow does
+    // not happen.
+    aTarget->OwnerDoc()->ScheduleResizeObserversNotification();
+  }
+}
+
+void
+ResizeObserver::Unobserve(Element* aTarget,
+                          ErrorResult& aRv)
+{
+  if (!aTarget) {
+    aRv.Throw(NS_ERROR_DOM_NOT_FOUND_ERR);
+    return;
+  }
+
+  RefPtr<ResizeObservation> observation;
+
+  if (mObservationMap.Get(aTarget, getter_AddRefs(observation))) {
+    mObservationMap.Remove(aTarget);
+
+    MOZ_ASSERT(!mObservationList.isEmpty(),
+               "If ResizeObservation found for an element, observation list "
+               "must be not empty.");
+
+    observation->remove();
+  }
+}
+
+void
+ResizeObserver::Disconnect()
+{
+  mObservationMap.Clear();
+  mObservationList.clear();
+  mActiveTargets.Clear();
+}
+
+void
+ResizeObserver::GatherActiveObservations(uint32_t aDepth)
+{
+  mActiveTargets.Clear();
+  mHasSkippedTargets = false;
+
+  for (auto observation : mObservationList) {
+    if (observation->IsActive()) {
+      uint32_t targetDepth =
+        nsContentUtils::GetNodeDepth(observation->Target());
+
+      if (targetDepth > aDepth) {
+        mActiveTargets.AppendElement(observation);
+      } else {
+        mHasSkippedTargets = true;
+      }
+    }
+  }
+}
+
+bool
+ResizeObserver::HasActiveObservations() const
+{
+  return !mActiveTargets.IsEmpty();
+}
+
+bool
+ResizeObserver::HasSkippedObservations() const
+{
+  return mHasSkippedTargets;
+}
+
+uint32_t
+ResizeObserver::BroadcastActiveObservations()
+{
+  uint32_t shallowestTargetDepth = UINT32_MAX;
+
+  if (HasActiveObservations()) {
+    Sequence<OwningNonNull<ResizeObserverEntry>> entries;
+
+    for (auto observation : mActiveTargets) {
+      RefPtr<ResizeObserverEntry> entry =
+        new ResizeObserverEntry(this, observation->Target());
+
+      nsRect rect = observation->GetTargetRect();
+      entry->SetContentRect(rect);
+
+      if (!entries.AppendElement(entry.forget(), fallible)) {
+        // Out of memory.
+        break;
+      }
+
+      // Sync the broadcast size of observation so the next size inspection
+      // will be based on the updated size from last delivered observations.
+      observation->UpdateBroadcastSize(rect);
+
+      uint32_t targetDepth =
+        nsContentUtils::GetNodeDepth(observation->Target());
+
+      if (targetDepth < shallowestTargetDepth) {
+        shallowestTargetDepth = targetDepth;
+      }
+    }
+
+    mCallback->Call(this, entries, *this);
+    mActiveTargets.Clear();
+    mHasSkippedTargets = false;
+  }
+
+  return shallowestTargetDepth;
+}
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(ResizeObserverEntry)
+  NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
+  NS_INTERFACE_MAP_ENTRY(nsISupports)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(ResizeObserverEntry)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(ResizeObserverEntry)
+
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(ResizeObserverEntry,
+                                      mTarget, mContentRect,
+                                      mOwner)
+
+already_AddRefed<ResizeObserverEntry>
+ResizeObserverEntry::Constructor(const GlobalObject& aGlobal,
+                                 Element* aTarget,
+                                 ErrorResult& aRv)
+{
+  RefPtr<ResizeObserverEntry> observerEntry =
+    new ResizeObserverEntry(aGlobal.GetAsSupports(), aTarget);
+  return observerEntry.forget();
+}
+
+void
+ResizeObserverEntry::SetContentRect(nsRect aRect)
+{
+  RefPtr<DOMRect> contentRect = new DOMRect(mTarget);
+  nsIFrame* frame = mTarget->GetPrimaryFrame();
+
+  if (frame) {
+    nsMargin padding = frame->GetUsedPadding();
+
+    // Per the spec, we need to include padding in contentRect of
+    // ResizeObserverEntry.
+    aRect.x = padding.left;
+    aRect.y = padding.top;
+  }
+
+  contentRect->SetLayoutRect(aRect);
+  mContentRect = contentRect.forget();
+}
+
+ResizeObserverEntry::~ResizeObserverEntry()
+{
+}
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(ResizeObservation)
+  NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
+  NS_INTERFACE_MAP_ENTRY(nsISupports)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(ResizeObservation)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(ResizeObservation)
+
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(ResizeObservation,
+                                      mTarget, mOwner)
+
+already_AddRefed<ResizeObservation>
+ResizeObservation::Constructor(const GlobalObject& aGlobal,
+                               Element* aTarget,
+                               ErrorResult& aRv)
+{
+  RefPtr<ResizeObservation> observation =
+    new ResizeObservation(aGlobal.GetAsSupports(), aTarget);
+  return observation.forget();
+}
+
+bool
+ResizeObservation::IsActive() const
+{
+  nsRect rect = GetTargetRect();
+  return (rect.width != mBroadcastWidth || rect.height != mBroadcastHeight);
+}
+
+void
+ResizeObservation::UpdateBroadcastSize(nsRect aRect)
+{
+  mBroadcastWidth = aRect.width;
+  mBroadcastHeight = aRect.height;
+}
+
+nsRect
+ResizeObservation::GetTargetRect() const
+{
+  nsRect rect;
+  nsIFrame* frame = mTarget->GetPrimaryFrame();
+
+  if (frame) {
+    if (mTarget->IsSVGElement()) {
+      gfxRect bbox = nsSVGUtils::GetBBox(frame);
+      rect.width = NSFloatPixelsToAppUnits(bbox.width, AppUnitsPerCSSPixel());
+      rect.height = NSFloatPixelsToAppUnits(bbox.height, AppUnitsPerCSSPixel());
+    } else {
+      // Per the spec, non-replaced inline Elements will always have an empty
+      // content rect.
+      if (frame->IsFrameOfType(nsIFrame::eReplaced) ||
+          !frame->IsFrameOfType(nsIFrame::eLineParticipant)) {
+        rect = frame->GetContentRectRelativeToSelf();
+      }
+    }
+  }
+
+  return rect;
+}
+
+ResizeObservation::~ResizeObservation()
+{
+}
+
+} // namespace dom
+} // namespace mozilla

dom/base/ResizeObserver.h

@@ -1,312 +1,254 @@
-/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
-/* 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/. */
-
-#ifndef mozilla_dom_ResizeObserver_h
-#define mozilla_dom_ResizeObserver_h
-
-#include "mozilla/AppUnits.h"
-#include "mozilla/WritingModes.h"
-#include "mozilla/dom/ResizeObserverBinding.h"
-#include "nsCoord.h"
-
-namespace mozilla {
-namespace dom {
-
-/**
- * ResizeObserver interfaces and algorithms are based on
- * https://wicg.github.io/ResizeObserver/#api
- */
-class ResizeObserver final
-  : public nsISupports
-  , public nsWrapperCache
-{
-public:
-  NS_DECL_CYCLE_COLLECTING_ISUPPORTS
-  NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(ResizeObserver)
-
-  ResizeObserver(already_AddRefed<nsPIDOMWindowInner>&& aOwner,
-                 ResizeObserverCallback& aCb)
-    : mOwner(aOwner)
-    , mCallback(&aCb)
-  {
-    MOZ_ASSERT(mOwner, "Need a non-null owner window");
-  }
-
-  static already_AddRefed<ResizeObserver>
-  Constructor(const GlobalObject& aGlobal,
-              ResizeObserverCallback& aCb,
-              ErrorResult& aRv);
-
-  JSObject* WrapObject(JSContext* aCx,
-                       JS::Handle<JSObject*> aGivenProto) override
-  {
-    return ResizeObserverBinding::Wrap(aCx, this, aGivenProto);
-  }
-
-  nsISupports* GetParentObject() const
-  {
-    return mOwner;
-  }
-
-  void Observe(Element* aTarget, const ResizeObserverOptions& aOptions, ErrorResult& aRv);
-
-  void Unobserve(Element* aTarget, ErrorResult& aRv);
-
-  void Disconnect();
-
-  /*
-   * Gather all observations which have an observed target with size changed
-   * since last BroadcastActiveObservations() in this ResizeObserver.
-   * An observation will be skipped if the depth of its observed target is less
-   * or equal than aDepth. All gathered observations will be added to
-   * mActiveTargets.
-  */
-  void GatherActiveObservations(uint32_t aDepth);
-
-  /*
-   * Returns whether this ResizeObserver has any active observations
-   * since last GatherActiveObservations().
-  */
-  bool HasActiveObservations() const;
-
-  /*
-   * Returns whether this ResizeObserver has any skipped observations
-   * since last GatherActiveObservations().
-  */
-  bool HasSkippedObservations() const;
-
-  /*
-   * Deliver the callback function in JavaScript for all active observations
-   * and pass the sequence of ResizeObserverEntry so JavaScript can access them.
-   * The active observations' mLastReportedSize fields will be updated, and
-   * mActiveTargets will be cleared. It also returns the shallowest depth of
-   * elements from active observations or numeric_limits<uint32_t>::max() if
-   * there are not any active observations.
-  */
-  uint32_t BroadcastActiveObservations();
-
-protected:
-  ~ResizeObserver()
-  {
-    mObservationList.clear();
-  }
-
-  nsCOMPtr<nsPIDOMWindowInner> mOwner;
-  RefPtr<ResizeObserverCallback> mCallback;
-  nsTArray<RefPtr<ResizeObservation>> mActiveTargets;
-  // The spec uses a list to store the skipped targets. However, it seems what
-  // we want is to check if there are any skipped targets (i.e. existence).
-  // Therefore, we use a boolean value to represent the existence of skipped
-  // targets.
-  bool mHasSkippedTargets;
-
-  // Combination of HashTable and LinkedList so we can iterate through
-  // the elements of HashTable in order of insertion time.
-  // Will be nice if we have our own data structure for this in the future.
-  nsRefPtrHashtable<nsPtrHashKey<Element>, ResizeObservation> mObservationMap;
-  LinkedList<ResizeObservation> mObservationList;
-};
-
-/**
- * ResizeObserverEntry is the entry that contains the information for observed
- * elements. This object is the one that visible to JavaScript in callback
- * function that is fired by ResizeObserver.
- */
-class ResizeObserverEntry final
-  : public nsISupports
-  , public nsWrapperCache
-{
-public:
-  NS_DECL_CYCLE_COLLECTING_ISUPPORTS
-  NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(ResizeObserverEntry)
-
-  ResizeObserverEntry(nsISupports* aOwner, Element* aTarget)
-    : mOwner(aOwner)
-    , mTarget(aTarget)
-  {
-    MOZ_ASSERT(mOwner, "Need a non-null owner");
-    MOZ_ASSERT(mTarget, "Need a non-null target element");
-  }
-
-  static already_AddRefed<ResizeObserverEntry>
-  Constructor(const GlobalObject& aGlobal,
-              Element* aTarget,
-              ErrorResult& aRv);
-
-  JSObject* WrapObject(JSContext* aCx,
-                       JS::Handle<JSObject*> aGivenProto) override
-  {
-    return ResizeObserverEntryBinding::Wrap(aCx, this,
-                                            aGivenProto);
-  }
-
-  nsISupports* GetParentObject() const
-  {
-    return mOwner;
-  }
-
-  Element* Target() const
-  {
-    return mTarget;
-  }
-
-  /*
-   * Returns the DOMRectReadOnly of target's content rect so it can be
-   * accessed from JavaScript in callback function of ResizeObserver.
-  */
-  DOMRectReadOnly* GetContentRect() const
-  {
-    return mContentRect;
-  }
-
-  /**
-   * Returns target's logical border-box size and content-box size as
-   * ResizeObserverSize.
-   */
-  ResizeObserverSize* BorderBoxSize() const { 
-    return mBorderBoxSize;
-  }
-  ResizeObserverSize* ContentBoxSize() const { 
-    return mContentBoxSize;
-  }
-
-  // Set borderBoxSize.
-  void SetBorderBoxSize(const nsSize& aSize);
-  // Set contentRect and contentBoxSize.
-  void SetContentRectAndSize(const nsSize& aSize);
-
-protected:
-  ~ResizeObserverEntry();
-
-  nsCOMPtr<nsISupports> mOwner;
-  nsCOMPtr<Element> mTarget;
-
-  RefPtr<DOMRectReadOnly> mContentRect;
-  RefPtr<ResizeObserverSize> mBorderBoxSize;
-  RefPtr<ResizeObserverSize> mContentBoxSize;
-};
-
-class ResizeObserverSize final : public nsISupports, public nsWrapperCache {
-public:
-  NS_DECL_CYCLE_COLLECTING_ISUPPORTS
-  NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(ResizeObserverSize)
-
-  // Note: the unit of |aSize| is app unit, and we convert it into css pixel in
-  // the public JS APIs.
-  ResizeObserverSize(nsISupports* aOwner, const nsSize& aSize,
-                     const WritingMode aWM)
-      : mOwner(aOwner), mSize(aWM, aSize), mWM(aWM) {
-    MOZ_ASSERT(mOwner, "Need a non-null owner");
-  }
-
-  nsISupports* GetParentObject() const { return mOwner; }
-
-  JSObject* WrapObject(JSContext* aCx,
-                       JS::Handle<JSObject*> aGivenProto) override {
-    return ResizeObserverSizeBinding::Wrap(aCx, this, aGivenProto);
-  }
-
-  double InlineSize() const {
-    return NSAppUnitsToDoublePixels(mSize.ISize(mWM), AppUnitsPerCSSPixel());
-  }
-
-  double BlockSize() const {
-    return NSAppUnitsToDoublePixels(mSize.BSize(mWM), AppUnitsPerCSSPixel());
-  }
-
-protected:
-  ~ResizeObserverSize() = default;
-
-  nsCOMPtr<nsISupports> mOwner;
-  const LogicalSize mSize;
-  const WritingMode mWM;
-};
-
-/**
- * We use ResizeObservation to store and sync the size information of one
- * observed element so we can decide whether an observation should be fired
- * or not.
- */
-class ResizeObservation final
-  : public nsISupports
-  , public nsWrapperCache
-  , public LinkedListElement<ResizeObservation>
-{
-public:
-  NS_DECL_CYCLE_COLLECTING_ISUPPORTS
-  NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(ResizeObservation)
-
-  ResizeObservation(nsISupports* aOwner,
-                    Element* aTarget,
-                    ResizeObserverBoxOptions aBox,
-                    const WritingMode aWM)
-    : mOwner(aOwner)
-    , mTarget(aTarget)
-    , mObservedBox(aBox)
-    , mLastReportedSize(aWM)
-    , mLastReportedWM(aWM)
-  {
-    MOZ_ASSERT(mOwner, "Need a non-null owner");
-    MOZ_ASSERT(mTarget, "Need a non-null target element");
-  }
-
-  static already_AddRefed<ResizeObservation>
-  Constructor(const GlobalObject& aGlobal,
-              Element* aTarget,
-              ErrorResult& aRv);
-
-  JSObject* WrapObject(JSContext* aCx,
-                       JS::Handle<JSObject*> aGivenProto) override
-  {
-    return ResizeObservationBinding::Wrap(aCx, this, aGivenProto);
-  }
-
-  nsISupports* GetParentObject() const
-  {
-    return mOwner;
-  }
-
-  Element* Target() const
-  {
-    return mTarget;
-  }
-
-  ResizeObserverBoxOptions BoxOptions() const
-  { 
-    return mObservedBox;
-  }
-
-  /*
-   * Returns whether the observed target element size differs from the saved
-   * mLastReportedSize.
-  */
-  bool IsActive() const;
-
-  /*
-   * Update current mLastReportedSize with size from aSize.
-  */
-  void UpdateLastReportedSize(const nsSize& aSize);
-
-protected:
-  ~ResizeObservation();
-
-  nsCOMPtr<nsISupports> mOwner;
-  nsCOMPtr<Element> mTarget;
-
-  const ResizeObserverBoxOptions mObservedBox;
-
-  // The latest recorded size of observed target.
-  // Per the spec, observation.lastReportedSize should be entry.borderBoxSize
-  // or entry.contentBoxSize (i.e. logical size), instead of entry.contentRect
-  // (i.e. physical rect), so we store this as LogicalSize.
-  LogicalSize mLastReportedSize;
-  WritingMode mLastReportedWM;
-};
-
-} // namespace dom
-} // namespace mozilla
-
-#endif // mozilla_dom_ResizeObserver_h
-
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+#ifndef mozilla_dom_ResizeObserver_h
+#define mozilla_dom_ResizeObserver_h
+
+#include "mozilla/dom/ResizeObserverBinding.h"
+
+namespace mozilla {
+namespace dom {
+
+/**
+ * ResizeObserver interfaces and algorithms are based on
+ * https://wicg.github.io/ResizeObserver/#api
+ */
+class ResizeObserver final
+  : public nsISupports
+  , public nsWrapperCache
+{
+public:
+  NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+  NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(ResizeObserver)
+
+  ResizeObserver(already_AddRefed<nsPIDOMWindowInner>&& aOwner,
+                 ResizeObserverCallback& aCb)
+    : mOwner(aOwner)
+    , mCallback(&aCb)
+  {
+    MOZ_ASSERT(mOwner, "Need a non-null owner window");
+  }
+
+  static already_AddRefed<ResizeObserver>
+  Constructor(const GlobalObject& aGlobal,
+              ResizeObserverCallback& aCb,
+              ErrorResult& aRv);
+
+  JSObject* WrapObject(JSContext* aCx,
+                       JS::Handle<JSObject*> aGivenProto) override
+  {
+    return ResizeObserverBinding::Wrap(aCx, this, aGivenProto);
+  }
+
+  nsISupports* GetParentObject() const
+  {
+    return mOwner;
+  }
+
+  void Observe(Element* aTarget, ErrorResult& aRv);
+
+  void Unobserve(Element* aTarget, ErrorResult& aRv);
+
+  void Disconnect();
+
+  /*
+   * Gather all observations which have an observed target with size changed
+   * since last BroadcastActiveObservations() in this ResizeObserver.
+   * An observation will be skipped if the depth of its observed target is less
+   * or equal than aDepth. All gathered observations will be added to
+   * mActiveTargets.
+  */
+  void GatherActiveObservations(uint32_t aDepth);
+
+  /*
+   * Returns whether this ResizeObserver has any active observations
+   * since last GatherActiveObservations().
+  */
+  bool HasActiveObservations() const;
+
+  /*
+   * Returns whether this ResizeObserver has any skipped observations
+   * since last GatherActiveObservations().
+  */
+  bool HasSkippedObservations() const;
+
+  /*
+   * Deliver the callback function in JavaScript for all active observations
+   * and pass the sequence of ResizeObserverEntry so JavaScript can access them.
+   * The broadcast size of observations will be updated and mActiveTargets will
+   * be cleared. It also returns the shallowest depth of elements from active
+   * observations or UINT32_MAX if there is no any active observations.
+  */
+  uint32_t BroadcastActiveObservations();
+
+protected:
+  ~ResizeObserver()
+  {
+    mObservationList.clear();
+  }
+
+  nsCOMPtr<nsPIDOMWindowInner> mOwner;
+  RefPtr<ResizeObserverCallback> mCallback;
+  nsTArray<RefPtr<ResizeObservation>> mActiveTargets;
+  bool mHasSkippedTargets;
+
+  // Combination of HashTable and LinkedList so we can iterate through
+  // the elements of HashTable in order of insertion time.
+  // Will be nice if we have our own data structure for this in the future.
+  nsRefPtrHashtable<nsPtrHashKey<Element>, ResizeObservation> mObservationMap;
+  LinkedList<ResizeObservation> mObservationList;
+};
+
+/**
+ * ResizeObserverEntry is the entry that contains the information for observed
+ * elements. This object is the one that visible to JavaScript in callback
+ * function that is fired by ResizeObserver.
+ */
+class ResizeObserverEntry final
+  : public nsISupports
+  , public nsWrapperCache
+{
+public:
+  NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+  NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(ResizeObserverEntry)
+
+  ResizeObserverEntry(nsISupports* aOwner, Element* aTarget)
+    : mOwner(aOwner)
+    , mTarget(aTarget)
+  {
+    MOZ_ASSERT(mOwner, "Need a non-null owner");
+    MOZ_ASSERT(mTarget, "Need a non-null target element");
+  }
+
+  static already_AddRefed<ResizeObserverEntry>
+  Constructor(const GlobalObject& aGlobal,
+              Element* aTarget,
+              ErrorResult& aRv);
+
+  JSObject* WrapObject(JSContext* aCx,
+                       JS::Handle<JSObject*> aGivenProto) override
+  {
+    return ResizeObserverEntryBinding::Wrap(aCx, this,
+                                            aGivenProto);
+  }
+
+  nsISupports* GetParentObject() const
+  {
+    return mOwner;
+  }
+
+  Element* Target() const
+  {
+    return mTarget;
+  }
+
+  /*
+   * Returns the DOMRectReadOnly of target's content rect so it can be
+   * accessed from JavaScript in callback function of ResizeObserver.
+  */
+  DOMRectReadOnly* GetContentRect() const
+  {
+    return mContentRect;
+  }
+
+  void SetContentRect(nsRect aRect);
+
+protected:
+  ~ResizeObserverEntry();
+
+  nsCOMPtr<nsISupports> mOwner;
+  nsCOMPtr<Element> mTarget;
+  RefPtr<DOMRectReadOnly> mContentRect;
+};
+
+/**
+ * We use ResizeObservation to store and sync the size information of one
+ * observed element so we can decide whether an observation should be fired
+ * or not.
+ */
+class ResizeObservation final
+  : public nsISupports
+  , public nsWrapperCache
+  , public LinkedListElement<ResizeObservation>
+{
+public:
+  NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+  NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(ResizeObservation)
+
+  ResizeObservation(nsISupports* aOwner, Element* aTarget)
+    : mOwner(aOwner)
+    , mTarget(aTarget)
+    , mBroadcastWidth(0)
+    , mBroadcastHeight(0)
+  {
+    MOZ_ASSERT(mOwner, "Need a non-null owner");
+    MOZ_ASSERT(mTarget, "Need a non-null target element");
+  }
+
+  static already_AddRefed<ResizeObservation>
+  Constructor(const GlobalObject& aGlobal,
+              Element* aTarget,
+              ErrorResult& aRv);
+
+  JSObject* WrapObject(JSContext* aCx,
+                       JS::Handle<JSObject*> aGivenProto) override
+  {
+    return ResizeObservationBinding::Wrap(aCx, this, aGivenProto);
+  }
+
+  nsISupports* GetParentObject() const
+  {
+    return mOwner;
+  }
+
+  Element* Target() const
+  {
+    return mTarget;
+  }
+
+  nscoord BroadcastWidth() const
+  {
+    return mBroadcastWidth;
+  }
+
+  nscoord BroadcastHeight() const
+  {
+    return mBroadcastHeight;
+  }
+
+  /*
+   * Returns whether the observed target element size differs from current
+   * BroadcastWidth and BroadcastHeight
+  */
+  bool IsActive() const;
+
+  /*
+   * Update current BroadcastWidth and BroadcastHeight with size from aRect.
+  */
+  void UpdateBroadcastSize(nsRect aRect);
+
+  /*
+   * Returns the target's rect in the form of nsRect.
+   * If the target is SVG, width and height are determined from bounding box.
+  */
+  nsRect GetTargetRect() const;
+
+protected:
+  ~ResizeObservation();
+
+  nsCOMPtr<nsISupports> mOwner;
+  nsCOMPtr<Element> mTarget;
+
+  // Broadcast width and broadcast height are the latest recorded size
+  // of observed target.
+  nscoord mBroadcastWidth;
+  nscoord mBroadcastHeight;
+};
+
+} // namespace dom
+} // namespace mozilla
+
+#endif // mozilla_dom_ResizeObserver_h
+

dom/base/ResizeObserverController.h

@@ -41,9 +41,9 @@ public:
 
   void Disconnect();
 
-  bool IsRegistered() const { return mRegistered; }
-
-  void DetachFromOwner() { mOwner = nullptr; }
+  bool IsRegistered() const { return mRegistered; }
+
+  void DetachFromOwner() { mOwner = nullptr; }
 
 protected:
   virtual ~ResizeObserverNotificationHelper();