Issue #1829 - Revert "Issue #1751"

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/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/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',

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,20 @@ 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_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':

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/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/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

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

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)

dom/base/Navigator.cpp

@@ -1406,6 +1406,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/nsContentUtils.cpp

@@ -6842,6 +6842,10 @@ nsContentUtils::HaveEqualPrincipals(nsIDocument* aDoc1, nsIDocument* aDoc2)
 bool
 nsContentUtils::HasPluginWithUncontrolledEventDispatch(nsIContent* aContent)
 {
+#ifdef XP_MACOSX
+  // We control dispatch to all mac plugins.
+  return false;
+#else
   if (!aContent || !aContent->IsInUncomposedDoc()) {
     return false;
   }
@@ -6864,6 +6868,7 @@ nsContentUtils::HasPluginWithUncontrolledEventDispatch(nsIContent* aContent)
   }
 
   return !isWindowless;
+#endif
 }
 
 /* static */

dom/base/nsFocusManager.cpp

@@ -66,7 +66,9 @@
 #include "nsAccessibilityService.h"
 #endif
 
+#ifndef XP_MACOSX
 #include "nsIScriptError.h"
+#endif
 
 using namespace mozilla;
 using namespace mozilla::dom;
@@ -1268,10 +1270,12 @@ nsFocusManager::SetFocusInner(nsIContent* aNewContent, int32_t aFlags,
     }
   }
 
-  // Exit fullscreen if we're focusing a windowed plugin. We don't control
-  // event dispatch to windowed plugins, so we can't display the <Press ESC
-  // to leave fullscreen mode> warning on key input if a windowed plugin is
-  // focused, so just exit fullscreen to guard against phishing.
+  // Exit fullscreen if we're focusing a windowed plugin on a non-MacOSX
+  // system. We don't control event dispatch to windowed plugins on non-MacOSX,
+  // so we can't display the "Press ESC to leave fullscreen mode" warning on
+  // key input if a windowed plugin is focused, so just exit fullscreen
+  // to guard against phishing.
+#ifndef XP_MACOSX
   if (contentToFocus &&
       nsContentUtils::
         GetRootDocument(contentToFocus->OwnerDoc())->GetFullscreenElement() &&
@@ -1283,6 +1287,7 @@ nsFocusManager::SetFocusInner(nsIContent* aNewContent, int32_t aFlags,
                                     "FocusedWindowedPluginWhileFullscreen");
     nsIDocument::AsyncExitFullscreen(contentToFocus->OwnerDoc());
   }
+#endif
 
   // if the FLAG_NOSWITCHFRAME flag is used, only allow the focus to be
   // shifted away from the current element if the new shell to focus is

dom/base/nsGlobalWindow.cpp

@@ -6228,7 +6228,18 @@ nsGlobalWindow::CheckSecurityLeftAndTop(int32_t* aLeft, int32_t* aTop, bool aCal
       screen->GetAvailLeft(&screenLeft);
       screen->GetAvailWidth(&screenWidth);
       screen->GetAvailHeight(&screenHeight);
+#if defined(XP_MACOSX)
+      /* The mac's coordinate system is different from the assumed Windows'
+         system. It offsets by the height of the menubar so that a window
+         placed at (0,0) will be entirely visible. Unfortunately that
+         correction is made elsewhere (in Widget) and the meaning of
+         the Avail... coordinates is overloaded. Here we allow a window
+         to be placed at (0,0) because it does make sense to do so.
+      */
+      screen->GetTop(&screenTop);
+#else
       screen->GetAvailTop(&screenTop);
+#endif
 
       if (aLeft) {
         if (screenLeft+screenWidth < *aLeft+winWidth)
@@ -7066,6 +7077,16 @@ nsGlobalWindow::Dump(const nsAString& aStr)
 
   char *cstr = ToNewUTF8String(aStr);
 
+#if defined(XP_MACOSX)
+  // have to convert \r to \n so that printing to the console works
+  char *c = cstr, *cEnd = cstr + strlen(cstr);
+  while (c < cEnd) {
+    if (*c == '\r')
+      *c = '\n';
+    c++;
+  }
+#endif
+
   if (cstr) {
     MOZ_LOG(nsContentUtils::DOMDumpLog(), LogLevel::Debug, ("[Window.Dump] %s", cstr));
 #ifdef XP_WIN

dom/base/nsJSEnvironment.cpp

@@ -59,6 +59,10 @@
 
 #include "nsJSPrincipals.h"
 
+#ifdef XP_MACOSX
+// AssertMacros.h defines 'check' and conflicts with AccessCheck.h
+#undef check
+#endif
 #include "AccessCheck.h"
 
 #include "mozilla/Logging.h"

dom/base/nsObjectLoadingContent.cpp

@@ -95,6 +95,13 @@
 #endif
 #endif // XP_WIN
 
+#ifdef XP_MACOSX
+// HandlePluginCrashed() and HandlePluginInstantiated() needed from here to
+// fix bug 1147521.  Should later be replaced by proper interface methods,
+// maybe on nsIObjectLoadingContext.
+#include "mozilla/dom/HTMLObjectElement.h"
+#endif
+
 static NS_DEFINE_CID(kAppShellCID, NS_APPSHELL_CID);
 
 static const char *kPrefJavaMIME = "plugin.java.mime";
@@ -909,6 +916,10 @@ nsObjectLoadingContent::InstantiatePluginInstance(bool aIsLoading)
                             NS_LITERAL_STRING("PluginInstantiated"));
   NS_DispatchToCurrentThread(ev);
 
+#ifdef XP_MACOSX
+  HTMLObjectElement::HandlePluginInstantiated(thisContent->AsElement());
+#endif
+
   return NS_OK;
 }
 
@@ -2937,6 +2948,10 @@ nsObjectLoadingContent::PluginCrashed(nsIPluginTag* aPluginTag,
   nsCOMPtr<nsIContent> thisContent =
     do_QueryInterface(static_cast<nsIImageLoadingContent*>(this));
 
+#ifdef XP_MACOSX
+  HTMLObjectElement::HandlePluginCrashed(thisContent->AsElement());
+#endif
+
   PluginDestroyed();
 
   // Switch to fallback/crashed state, notify
@@ -3175,6 +3190,10 @@ nsObjectLoadingContent::DoStopPlugin(nsPluginInstanceOwner* aInstanceOwner,
       return;
     }
 
+#if defined(XP_MACOSX)
+    aInstanceOwner->HidePluginWindow();
+#endif
+
     RefPtr<nsPluginHost> pluginHost = nsPluginHost::GetInst();
     NS_ASSERTION(pluginHost, "No plugin host?");
     pluginHost->StopPluginInstance(inst);

dom/base/nsWindowRoot.cpp

@@ -37,8 +37,14 @@ nsWindowRoot::nsWindowRoot(nsPIDOMWindowOuter* aWindow)
   mWindow = aWindow;
   MOZ_ASSERT(mWindow->IsOuterWindow());
 
+  // Keyboard indicators are not shown on Mac by default.
+#if defined(XP_MACOSX)
+  mShowAccelerators = false;
+  mShowFocusRings = false;
+#else
   mShowAccelerators = true;
   mShowFocusRings = true;
+#endif
 }
 
 nsWindowRoot::~nsWindowRoot()

dom/canvas/WebGL2Context.cpp

@@ -125,6 +125,13 @@ WebGLContext::InitWebGL2(FailureReason* const out_failReason)
     fnGatherMissing2(gl::GLFeature::occlusion_query_boolean,
                      gl::GLFeature::occlusion_query);
 
+#ifdef XP_MACOSX
+    // On OSX, GL core profile is used. This requires texture swizzle
+    // support to emulate legacy texture formats: ALPHA, LUMINANCE,
+    // and LUMINANCE_ALPHA.
+    fnGatherMissing(gl::GLFeature::texture_swizzle);
+#endif
+
     fnGatherMissing2(gl::GLFeature::prim_restart_fixed,
                      gl::GLFeature::prim_restart);
 

dom/canvas/WebGLBuffer.cpp

@@ -115,7 +115,7 @@ WebGLBuffer::BufferData(GLenum target, size_t size, const void* data, GLenum usa
     const ScopedLazyBind lazyBind(gl, target, this);
     mContext->InvalidateBufferFetching();
 
-#if defined(MOZ_WIDGET_GTK)
+#if defined(XP_MACOSX) || defined(MOZ_WIDGET_GTK)
     // bug 790879
     if (gl->WorkAroundDriverBugs() &&
         size > INT32_MAX)

dom/canvas/WebGLContext.h

@@ -30,6 +30,10 @@
 #include "ScopedGLHelpers.h"
 #include "TexUnpackBlob.h"
 
+#ifdef XP_MACOSX
+#include "ForceDiscreteGPUHelperCGL.h"
+#endif
+
 // Local
 #include "WebGLContextLossHandler.h"
 #include "WebGLContextUnchecked.h"
@@ -2011,6 +2015,15 @@ protected:
     JSObject* WebGLObjectAsJSObject(JSContext* cx, const WebGLObjectType*,
                                     ErrorResult& rv) const;
 
+#ifdef XP_MACOSX
+    // see bug 713305. This RAII helper guarantees that we're on the discrete GPU, during its lifetime
+    // Debouncing note: we don't want to switch GPUs too frequently, so try to not create and destroy
+    // these objects at high frequency. Having WebGLContext's hold one such object seems fine,
+    // because WebGLContext objects only go away during GC, which shouldn't happen too frequently.
+    // If in the future GC becomes much more frequent, we may have to revisit then (maybe use a timer).
+    ForceDiscreteGPUHelperCGL mForceDiscreteGPUHelper;
+#endif
+
 public:
     // console logging helpers
     void GenerateWarning(const char* fmt, ...);

dom/canvas/WebGLContextBuffers.cpp

@@ -295,6 +295,16 @@ WebGLContext::BindBufferRange(GLenum target, GLuint index, WebGLBuffer* buffer,
 
     ////
 
+#ifdef XP_MACOSX
+    if (buffer && buffer->Content() == WebGLBuffer::Kind::Undefined &&
+        gl->WorkAroundDriverBugs())
+    {
+        // BindBufferRange will fail if the buffer's contents is undefined.
+        // Bind so driver initializes the buffer.
+        gl->fBindBuffer(target, buffer->mGLName);
+    }
+#endif
+
     gl->fBindBufferRange(target, index, buffer ? buffer->mGLName : 0, offset, size);
 
     ////
@@ -342,6 +352,12 @@ WebGLContext::BufferData(GLenum target, WebGLsizeiptr size, GLenum usage)
     if (!checkedSize.isValid())
       return ErrorOutOfMemory("%s: Size too large for platform.", funcName);
      
+#if defined(XP_MACOSX)
+    if (gl->WorkAroundDriverBugs() && size > 1200000000) {
+      return ErrorOutOfMemory("Allocations larger than 1200000000 fail on MacOS.");
+    }
+#endif
+
     const UniqueBuffer zeroBuffer(calloc(size, 1));
     if (!zeroBuffer)
         return ErrorOutOfMemory("%s: Failed to allocate zeros.", funcName);

dom/canvas/WebGLContextDraw.cpp

@@ -1045,6 +1045,13 @@ WebGLContext::WhatDoesVertexAttrib0Need() const
     const auto& isAttribArray0Enabled = mBoundVertexArray->mAttribs[0].mEnabled;
 
     bool legacyAttrib0 = gl->IsCompatibilityProfile();
+#ifdef XP_MACOSX
+    if (gl->WorkAroundDriverBugs()) {
+        // Failures in conformance/attribs/gl-disabled-vertex-attrib.
+        // Even in Core profiles on NV. Sigh.
+        legacyAttrib0 |= (gl->Vendor() == gl::GLVendor::NVIDIA);
+    }
+#endif
 
     if (!legacyAttrib0)
         return WebGLVertexAttrib0Status::Default;

dom/canvas/WebGLContextValidate.cpp

@@ -695,6 +695,18 @@ WebGLContext::InitAndValidateGL(FailureReason* const out_failReason)
         gl->fEnable(LOCAL_GL_PROGRAM_POINT_SIZE);
     }
 
+#ifdef XP_MACOSX
+    if (gl->WorkAroundDriverBugs() &&
+        gl->Vendor() == gl::GLVendor::ATI &&
+        !nsCocoaFeatures::IsAtLeastVersion(10,9))
+    {
+        // The Mac ATI driver, in all known OSX version up to and including
+        // 10.8, renders points sprites upside-down. (Apple bug 11778921)
+        gl->fPointParameterf(LOCAL_GL_POINT_SPRITE_COORD_ORIGIN,
+                             LOCAL_GL_LOWER_LEFT);
+    }
+#endif
+
     if (gl->IsSupported(gl::GLFeature::seamless_cube_map_opt_in)) {
         gl->fEnable(LOCAL_GL_TEXTURE_CUBE_MAP_SEAMLESS);
     }

dom/canvas/WebGLProgram.cpp

@@ -689,6 +689,24 @@ WebGLProgram::GetFragDataLocation(const nsAString& userName_wide) const
     gl->MakeCurrent();
 
     const NS_LossyConvertUTF16toASCII userName(userName_wide);
+#ifdef XP_MACOSX
+    if (gl->WorkAroundDriverBugs()) {
+        // OSX doesn't return locs for indexed names, just the base names.
+        // Indicated by failure in: conformance2/programs/gl-get-frag-data-location.html
+        bool isArray;
+        size_t arrayIndex;
+        nsCString baseUserName;
+        if (!ParseName(userName, &baseUserName, &isArray, &arrayIndex))
+            return -1;
+
+        if (arrayIndex >= mContext->mImplMaxDrawBuffers)
+            return -1;
+
+        const auto baseLoc = GetFragDataByUserName(this, baseUserName);
+        const auto loc = baseLoc + GLint(arrayIndex);
+        return loc;
+    }
+#endif
     return GetFragDataByUserName(this, userName);
 }
 
@@ -752,6 +770,11 @@ WebGLProgram::GetProgramParameter(GLenum pname) const
         return JS::BooleanValue(IsLinked());
 
     case LOCAL_GL_VALIDATE_STATUS:
+#ifdef XP_MACOSX
+        // See comment in ValidateProgram.
+        if (gl->WorkAroundDriverBugs())
+            return JS::BooleanValue(true);
+#endif
         // Todo: Implement this in our code.
         return JS::BooleanValue(bool(GetProgramiv(gl, mGLName, pname)));
 
@@ -1354,6 +1377,17 @@ WebGLProgram::ValidateProgram() const
 {
     mContext->MakeContextCurrent();
     gl::GLContext* gl = mContext->gl;
+
+#ifdef XP_MACOSX
+    // See bug 593867 for NVIDIA and bug 657201 for ATI. The latter is confirmed
+    // with Mac OS 10.6.7.
+    if (gl->WorkAroundDriverBugs()) {
+        mContext->GenerateWarning("validateProgram: Implemented as a no-op on"
+                                  " Mac to work around crashes.");
+        return;
+    }
+#endif
+
     gl->fValidateProgram(mGLName);
 }
 

dom/canvas/WebGLShaderValidator.cpp

@@ -63,8 +63,34 @@ ChooseValidatorCompileOptions(const ShBuiltInResources& resources,
                SH_REGENERATE_STRUCT_NAMES;
     }
 
-    // We want to do this everywhere.
+#ifndef XP_MACOSX
+    // We want to do this everywhere, but to do this on Mac, we need
+    // to do it only on Mac OSX > 10.6 as this causes the shader
+    // compiler in 10.6 to crash
     options |= SH_CLAMP_INDIRECT_ARRAY_BOUNDS;
+#endif
+
+#ifdef XP_MACOSX
+    if (gl->WorkAroundDriverBugs()) {
+        // Work around https://bugs.webkit.org/show_bug.cgi?id=124684,
+        // https://chromium.googlesource.com/angle/angle/+/5e70cf9d0b1bb
+        options |= SH_UNFOLD_SHORT_CIRCUIT;
+        
+        // OS X 10.7/10.8 specific:
+        
+        // Work around bug 665578 and bug 769810
+        if (gl->Vendor() == gl::GLVendor::ATI) {
+            options |= SH_EMULATE_BUILT_IN_FUNCTIONS;
+        }
+        // Work around bug 735560
+        if (gl->Vendor() == gl::GLVendor::Intel) {
+            options |= SH_EMULATE_BUILT_IN_FUNCTIONS;
+        }
+
+        // Work around that Mac drivers handle struct scopes incorrectly.
+        options |= SH_REGENERATE_STRUCT_NAMES;
+    }
+#endif
 
     if (resources.MaxExpressionComplexity > 0) {
         options |= SH_LIMIT_EXPRESSION_COMPLEXITY;
@@ -161,6 +187,15 @@ WebGLContext::CreateShaderValidator(GLenum shaderType) const
     // If underlying GLES doesn't have highp in frag shaders, it should complain anyways.
     resources.FragmentPrecisionHigh = mDisableFragHighP ? 0 : 1;
 
+    if (gl->WorkAroundDriverBugs()) {
+#ifdef XP_MACOSX
+        if (gl->Vendor() == gl::GLVendor::NVIDIA) {
+            // Work around bug 890432
+            resources.MaxExpressionComplexity = 1000;
+        }
+#endif
+    }
+
     int compileOptions = webgl::ChooseValidatorCompileOptions(resources, gl);
     return webgl::ShaderValidator::Create(shaderType, spec, outputLanguage, resources,
                                           compileOptions);

dom/events/EventStateManager.cpp

@@ -95,6 +95,10 @@
 #include "Units.h"
 #include "mozilla/layers/APZCTreeManager.h"
 
+#ifdef XP_MACOSX
+#import <ApplicationServices/ApplicationServices.h>
+#endif
+
 namespace mozilla {
 
 using namespace dom;
@@ -1513,6 +1517,14 @@ EventStateManager::FireContextClick()
     return;
   }
 
+#ifdef XP_MACOSX
+  // Hack to ensure that we don't show a context menu when the user
+  // let go of the mouse after a long cpu-hogging operation prevented
+  // us from handling any OS events. See bug 117589.
+  if (!CGEventSourceButtonState(kCGEventSourceStateCombinedSessionState, kCGMouseButtonLeft))
+    return;
+#endif
+
   nsEventStatus status = nsEventStatus_eIgnore;
 
   // Dispatch to the DOM. We have to fake out the ESM and tell it that the
@@ -2829,6 +2841,29 @@ EventStateManager::DecideGestureEvent(WidgetGestureNotifyEvent* aEvent,
   aEvent->mPanDirection = panDirection;
 }
 
+#ifdef XP_MACOSX
+static bool
+NodeAllowsClickThrough(nsINode* aNode)
+{
+  while (aNode) {
+    if (aNode->IsXULElement()) {
+      mozilla::dom::Element* element = aNode->AsElement();
+      static nsIContent::AttrValuesArray strings[] =
+        {&nsGkAtoms::always, &nsGkAtoms::never, nullptr};
+      switch (element->FindAttrValueIn(kNameSpaceID_None, nsGkAtoms::clickthrough,
+                                       strings, eCaseMatters)) {
+        case 0:
+          return true;
+        case 1:
+          return false;
+      }
+    }
+    aNode = nsContentUtils::GetCrossDocParentNode(aNode);
+  }
+  return true;
+}
+#endif
+
 void
 EventStateManager::PostHandleKeyboardEvent(WidgetKeyboardEvent* aKeyboardEvent,
                                            nsEventStatus& aStatus,
@@ -3061,7 +3096,10 @@ EventStateManager::PostHandleEvent(nsPresContext* aPresContext,
             // focused frame
             EnsureDocument(mPresContext);
             if (mDocument) {
-              fm->ClearFocus(mDocument->GetWindow());
+#ifdef XP_MACOSX
+              if (!activeContent || !activeContent->IsXULElement())
+#endif
+                fm->ClearFocus(mDocument->GetWindow());
               fm->SetFocusedWindow(mDocument->GetWindow());
             }
           }
@@ -3473,6 +3511,18 @@ EventStateManager::PostHandleEvent(nsPresContext* aPresContext,
     }
     break;
 
+#ifdef XP_MACOSX
+  case eMouseActivate:
+    if (mCurrentTarget) {
+      nsCOMPtr<nsIContent> targetContent;
+      mCurrentTarget->GetContentForEvent(aEvent, getter_AddRefs(targetContent));
+      if (!NodeAllowsClickThrough(targetContent)) {
+        *aStatus = nsEventStatus_eConsumeNoDefault;
+      }
+    }
+    break;
+#endif
+
   default:
     break;
   }

dom/events/TextComposition.cpp

@@ -21,8 +21,21 @@
 #include "mozilla/Unused.h"
 #include "mozilla/dom/TabParent.h"
 
+#ifdef XP_MACOSX
+// Some defiens will be conflict with OSX SDK
+#define TextRange _TextRange
+#define TextRangeArray _TextRangeArray
+#define Comment _Comment
+#endif
+
 #include "nsPluginInstanceOwner.h"
 
+#ifdef XP_MACOSX
+#undef TextRange
+#undef TextRangeArray
+#undef Comment
+#endif
+
 using namespace mozilla::widget;
 
 namespace mozilla {

dom/gamepad/cocoa/CocoaGamepad.cpp

@@ -0,0 +1,590 @@
+/* -*- 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/. */
+
+// mostly derived from the Allegro source code at:
+// http://alleg.svn.sourceforge.net/viewvc/alleg/allegro/branches/4.9/src/macosx/hidjoy.m?revision=13760&view=markup
+
+#include "mozilla/dom/Gamepad.h"
+#include "mozilla/dom/GamepadPlatformService.h"
+#include "mozilla/ArrayUtils.h"
+#include "mozilla/Unused.h"
+#include "nsThreadUtils.h"
+#include <CoreFoundation/CoreFoundation.h>
+#include <IOKit/hid/IOHIDBase.h>
+#include <IOKit/hid/IOHIDKeys.h>
+#include <IOKit/hid/IOHIDManager.h>
+
+#include <stdio.h>
+#include <vector>
+
+namespace {
+
+using namespace mozilla;
+using namespace mozilla::dom;
+using std::vector;
+
+struct Button {
+  int id;
+  bool analog;
+  IOHIDElementRef element;
+  CFIndex min;
+  CFIndex max;
+
+  Button(int aId, IOHIDElementRef aElement, CFIndex aMin, CFIndex aMax) :
+    id(aId),
+    analog((aMax - aMin) > 1),
+    element(aElement),
+    min(aMin),
+    max(aMax) {}
+};
+
+struct Axis {
+  int id;
+  IOHIDElementRef element;
+  uint32_t usagePage;
+  uint32_t usage;
+  CFIndex min;
+  CFIndex max;
+};
+
+typedef bool dpad_buttons[4];
+
+// These values can be found in the USB HID Usage Tables:
+// http://www.usb.org/developers/hidpage
+const unsigned kDesktopUsagePage = 0x01;
+const unsigned kSimUsagePage = 0x02;
+const unsigned kAcceleratorUsage = 0xC4;
+const unsigned kBrakeUsage = 0xC5;
+const unsigned kJoystickUsage = 0x04;
+const unsigned kGamepadUsage = 0x05;
+const unsigned kAxisUsageMin = 0x30;
+const unsigned kAxisUsageMax = 0x35;
+const unsigned kDpadUsage = 0x39;
+const unsigned kButtonUsagePage = 0x09;
+const unsigned kConsumerPage = 0x0C;
+const unsigned kHomeUsage = 0x223;
+const unsigned kBackUsage = 0x224;
+
+
+class Gamepad {
+ private:
+  IOHIDDeviceRef mDevice;
+  nsTArray<Button> buttons;
+  nsTArray<Axis> axes;
+  IOHIDElementRef mDpad;
+  dpad_buttons mDpadState;
+
+ public:
+  Gamepad() : mDevice(nullptr), mDpad(nullptr), mSuperIndex(-1) {}
+  bool operator==(IOHIDDeviceRef device) const { return mDevice == device; }
+  bool empty() const { return mDevice == nullptr; }
+  void clear()
+  {
+    mDevice = nullptr;
+    buttons.Clear();
+    axes.Clear();
+    mDpad = nullptr;
+    mSuperIndex = -1;
+  }
+  void init(IOHIDDeviceRef device);
+  size_t numButtons() { return buttons.Length() + (mDpad ? 4 : 0); }
+  size_t numAxes() { return axes.Length(); }
+
+  // Index given by our superclass.
+  uint32_t mSuperIndex;
+
+  bool isDpad(IOHIDElementRef element) const
+  {
+    return element == mDpad;
+  }
+
+  const dpad_buttons& getDpadState() const
+  {
+    return mDpadState;
+  }
+
+  void setDpadState(const dpad_buttons& dpadState)
+  {
+    for (unsigned i = 0; i < ArrayLength(mDpadState); i++) {
+      mDpadState[i] = dpadState[i];
+    }
+  }
+
+  const Button* lookupButton(IOHIDElementRef element) const
+  {
+    for (unsigned i = 0; i < buttons.Length(); i++) {
+      if (buttons[i].element == element)
+        return &buttons[i];
+    }
+    return nullptr;
+  }
+
+  const Axis* lookupAxis(IOHIDElementRef element) const
+  {
+    for (unsigned i = 0; i < axes.Length(); i++) {
+      if (axes[i].element == element)
+        return &axes[i];
+    }
+    return nullptr;
+  }
+};
+
+class AxisComparator {
+public:
+  bool Equals(const Axis& a1, const Axis& a2) const
+  {
+    return a1.usagePage == a2.usagePage && a1.usage == a2.usage;
+  }
+  bool LessThan(const Axis& a1, const Axis& a2) const
+  {
+    if (a1.usagePage == a2.usagePage) {
+      return a1.usage < a2.usage;
+    }
+    return a1.usagePage < a2.usagePage;
+  }
+};
+
+void Gamepad::init(IOHIDDeviceRef device)
+{
+  clear();
+  mDevice = device;
+
+  CFArrayRef elements = IOHIDDeviceCopyMatchingElements(device,
+                                                        nullptr,
+                                                        kIOHIDOptionsTypeNone);
+  CFIndex n = CFArrayGetCount(elements);
+  for (CFIndex i = 0; i < n; i++) {
+    IOHIDElementRef element = (IOHIDElementRef)CFArrayGetValueAtIndex(elements,
+                                                                      i);
+    uint32_t usagePage = IOHIDElementGetUsagePage(element);
+    uint32_t usage = IOHIDElementGetUsage(element);
+
+    if (usagePage == kDesktopUsagePage &&
+        usage >= kAxisUsageMin &&
+        usage <= kAxisUsageMax)
+    {
+      Axis axis = { int(axes.Length()),
+                    element,
+                    usagePage,
+                    usage,
+                    IOHIDElementGetLogicalMin(element),
+                    IOHIDElementGetLogicalMax(element) };
+      axes.AppendElement(axis);
+    } else if (usagePage == kDesktopUsagePage && usage == kDpadUsage &&
+               // Don't know how to handle d-pads that return weird values.
+               IOHIDElementGetLogicalMax(element) - IOHIDElementGetLogicalMin(element) == 7) {
+      mDpad = element;
+    } else if ((usagePage == kSimUsagePage &&
+                 (usage == kAcceleratorUsage ||
+                  usage == kBrakeUsage)) ||
+               (usagePage == kButtonUsagePage) ||
+               (usagePage == kConsumerPage &&
+                 (usage == kHomeUsage ||
+                  usage == kBackUsage))) {
+      Button button(int(buttons.Length()), element, IOHIDElementGetLogicalMin(element), IOHIDElementGetLogicalMax(element));
+      buttons.AppendElement(button);
+    } else {
+      //TODO: handle other usage pages
+    }
+  }
+
+  AxisComparator comparator;
+  axes.Sort(comparator);
+  for (unsigned i = 0; i < axes.Length(); i++) {
+    axes[i].id = i;
+  }
+}
+
+class DarwinGamepadService {
+ private:
+  IOHIDManagerRef mManager;
+  vector<Gamepad> mGamepads;
+
+  //Workaround to support running in background thread
+  CFRunLoopRef mMonitorRunLoop;
+  nsCOMPtr<nsIThread> mMonitorThread;
+
+  static void DeviceAddedCallback(void* data, IOReturn result,
+                                  void* sender, IOHIDDeviceRef device);
+  static void DeviceRemovedCallback(void* data, IOReturn result,
+                                    void* sender, IOHIDDeviceRef device);
+  static void InputValueChangedCallback(void* data, IOReturn result,
+                                        void* sender, IOHIDValueRef newValue);
+
+  void DeviceAdded(IOHIDDeviceRef device);
+  void DeviceRemoved(IOHIDDeviceRef device);
+  void InputValueChanged(IOHIDValueRef value);
+  void StartupInternal();
+
+ public:
+  DarwinGamepadService();
+  ~DarwinGamepadService();
+  void Startup();
+  void Shutdown();
+  friend class DarwinGamepadServiceStartupRunnable;
+};
+
+class DarwinGamepadServiceStartupRunnable final : public Runnable
+{
+ private:
+  ~DarwinGamepadServiceStartupRunnable() {}
+  // This Runnable schedules startup of DarwinGamepadService
+  // in a new thread, pointer to DarwinGamepadService is only
+  // used by this Runnable within its thread.
+  DarwinGamepadService MOZ_NON_OWNING_REF *mService;
+ public:
+  explicit DarwinGamepadServiceStartupRunnable(DarwinGamepadService *service)
+             : mService(service) {}
+  NS_IMETHOD Run() override
+  {
+    MOZ_ASSERT(mService);
+    mService->StartupInternal();
+    return NS_OK;
+  }
+};
+
+void
+DarwinGamepadService::DeviceAdded(IOHIDDeviceRef device)
+{
+  RefPtr<GamepadPlatformService> service =
+    GamepadPlatformService::GetParentService();
+  if (!service) {
+    return;
+  }
+
+  size_t slot = size_t(-1);
+  for (size_t i = 0; i < mGamepads.size(); i++) {
+    if (mGamepads[i] == device)
+      return;
+    if (slot == size_t(-1) && mGamepads[i].empty())
+      slot = i;
+  }
+
+  if (slot == size_t(-1)) {
+    slot = mGamepads.size();
+    mGamepads.push_back(Gamepad());
+  }
+  mGamepads[slot].init(device);
+
+  // Gather some identifying information
+  CFNumberRef vendorIdRef =
+    (CFNumberRef)IOHIDDeviceGetProperty(device, CFSTR(kIOHIDVendorIDKey));
+  CFNumberRef productIdRef =
+    (CFNumberRef)IOHIDDeviceGetProperty(device, CFSTR(kIOHIDProductIDKey));
+  CFStringRef productRef =
+    (CFStringRef)IOHIDDeviceGetProperty(device, CFSTR(kIOHIDProductKey));
+  int vendorId, productId;
+  CFNumberGetValue(vendorIdRef, kCFNumberIntType, &vendorId);
+  CFNumberGetValue(productIdRef, kCFNumberIntType, &productId);
+  char product_name[128];
+  CFStringGetCString(productRef, product_name,
+                     sizeof(product_name), kCFStringEncodingASCII);
+  char buffer[256];
+  sprintf(buffer, "%x-%x-%s", vendorId, productId, product_name);
+  uint32_t index = service->AddGamepad(buffer,
+                                       mozilla::dom::GamepadMappingType::_empty,
+                                       (int)mGamepads[slot].numButtons(),
+                                       (int)mGamepads[slot].numAxes());
+  mGamepads[slot].mSuperIndex = index;
+}
+
+void
+DarwinGamepadService::DeviceRemoved(IOHIDDeviceRef device)
+{
+  RefPtr<GamepadPlatformService> service =
+    GamepadPlatformService::GetParentService();
+  if (!service) {
+    return;
+  }
+  for (size_t i = 0; i < mGamepads.size(); i++) {
+    if (mGamepads[i] == device) {
+      service->RemoveGamepad(mGamepads[i].mSuperIndex);
+      mGamepads[i].clear();
+      return;
+    }
+  }
+}
+
+/*
+ * Given a value from a d-pad (POV hat in USB HID terminology),
+ * represent it as 4 buttons, one for each cardinal direction.
+ */
+static void
+UnpackDpad(int dpad_value, int min, int max, dpad_buttons& buttons)
+{
+  const unsigned kUp = 0;
+  const unsigned kDown = 1;
+  const unsigned kLeft = 2;
+  const unsigned kRight = 3;
+
+  // Different controllers have different ways of representing
+  // "nothing is pressed", but they're all outside the range of values.
+  if (dpad_value < min || dpad_value > max) {
+    // Nothing is pressed.
+    return;
+  }
+
+  // Normalize value to start at 0.
+  int value = dpad_value - min;
+
+  // Value will be in the range 0-7. The value represents the
+  // position of the d-pad around a circle, with 0 being straight up,
+  // 2 being right, 4 being straight down, and 6 being left.
+  if (value < 2 || value > 6) {
+    buttons[kUp] = true;
+  }
+  if (value > 2 && value < 6) {
+    buttons[kDown] = true;
+  }
+  if (value > 4) {
+    buttons[kLeft] = true;
+  }
+  if (value > 0 && value < 4) {
+    buttons[kRight] = true;
+  }
+}
+
+void
+DarwinGamepadService::InputValueChanged(IOHIDValueRef value)
+{
+  RefPtr<GamepadPlatformService> service =
+    GamepadPlatformService::GetParentService();
+  if (!service) {
+    return;
+  }
+
+  uint32_t value_length = IOHIDValueGetLength(value);
+  if (value_length > 4) {
+    // Workaround for bizarre issue with PS3 controllers that try to return
+    // massive (30+ byte) values and crash IOHIDValueGetIntegerValue
+    return;
+  }
+  IOHIDElementRef element = IOHIDValueGetElement(value);
+  IOHIDDeviceRef device = IOHIDElementGetDevice(element);
+
+  for (unsigned i = 0; i < mGamepads.size(); i++) {
+    Gamepad &gamepad = mGamepads[i];
+    if (gamepad == device) {
+      if (gamepad.isDpad(element)) {
+        const dpad_buttons& oldState = gamepad.getDpadState();
+        dpad_buttons newState = { false, false, false, false };
+        UnpackDpad(IOHIDValueGetIntegerValue(value),
+                   IOHIDElementGetLogicalMin(element),
+                   IOHIDElementGetLogicalMax(element),
+                   newState);
+        const int numButtons = gamepad.numButtons();
+        for (unsigned b = 0; b < ArrayLength(newState); b++) {
+          if (newState[b] != oldState[b]) {
+            service->NewButtonEvent(gamepad.mSuperIndex,
+                                    numButtons - 4 + b,
+                                    newState[b]);
+          }
+        }
+        gamepad.setDpadState(newState);
+      } else if (const Axis* axis = gamepad.lookupAxis(element)) {
+        double d = IOHIDValueGetIntegerValue(value);
+        double v = 2.0f * (d - axis->min) /
+          (double)(axis->max - axis->min) - 1.0f;
+        service->NewAxisMoveEvent(gamepad.mSuperIndex, axis->id, v);
+      } else if (const Button* button = gamepad.lookupButton(element)) {
+        int iv = IOHIDValueGetIntegerValue(value);
+        bool pressed = iv != 0;
+        double v = 0;
+        if (button->analog) {
+          double dv = iv;
+          v = (dv - button->min) / (double)(button->max - button->min);
+        } else {
+          v = pressed ? 1.0 : 0.0;
+        }
+        service->NewButtonEvent(gamepad.mSuperIndex, button->id, pressed, v);
+      }
+      return;
+    }
+  }
+}
+
+void
+DarwinGamepadService::DeviceAddedCallback(void* data, IOReturn result,
+                                         void* sender, IOHIDDeviceRef device)
+{
+  DarwinGamepadService* service = (DarwinGamepadService*)data;
+  service->DeviceAdded(device);
+}
+
+void
+DarwinGamepadService::DeviceRemovedCallback(void* data, IOReturn result,
+                                           void* sender, IOHIDDeviceRef device)
+{
+  DarwinGamepadService* service = (DarwinGamepadService*)data;
+  service->DeviceRemoved(device);
+}
+
+void
+DarwinGamepadService::InputValueChangedCallback(void* data,
+                                               IOReturn result,
+                                               void* sender,
+                                               IOHIDValueRef newValue)
+{
+  DarwinGamepadService* service = (DarwinGamepadService*)data;
+  service->InputValueChanged(newValue);
+}
+
+static CFMutableDictionaryRef
+MatchingDictionary(UInt32 inUsagePage, UInt32 inUsage)
+{
+  CFMutableDictionaryRef dict =
+    CFDictionaryCreateMutable(kCFAllocatorDefault,
+                              0,
+                              &kCFTypeDictionaryKeyCallBacks,
+                              &kCFTypeDictionaryValueCallBacks);
+  if (!dict)
+    return nullptr;
+  CFNumberRef number = CFNumberCreate(kCFAllocatorDefault,
+                                      kCFNumberIntType,
+                                      &inUsagePage);
+  if (!number) {
+    CFRelease(dict);
+    return nullptr;
+  }
+  CFDictionarySetValue(dict, CFSTR(kIOHIDDeviceUsagePageKey), number);
+  CFRelease(number);
+
+  number = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &inUsage);
+  if (!number) {
+    CFRelease(dict);
+    return nullptr;
+  }
+  CFDictionarySetValue(dict, CFSTR(kIOHIDDeviceUsageKey), number);
+  CFRelease(number);
+
+  return dict;
+}
+
+DarwinGamepadService::DarwinGamepadService() : mManager(nullptr) {}
+
+DarwinGamepadService::~DarwinGamepadService()
+{
+  if (mManager != nullptr)
+    CFRelease(mManager);
+}
+
+void
+DarwinGamepadService::StartupInternal()
+{
+  if (mManager != nullptr)
+    return;
+
+  IOHIDManagerRef manager = IOHIDManagerCreate(kCFAllocatorDefault,
+                                               kIOHIDOptionsTypeNone);
+
+  CFMutableDictionaryRef criteria_arr[2];
+  criteria_arr[0] = MatchingDictionary(kDesktopUsagePage,
+                                       kJoystickUsage);
+  if (!criteria_arr[0]) {
+    CFRelease(manager);
+    return;
+  }
+
+  criteria_arr[1] = MatchingDictionary(kDesktopUsagePage,
+                                       kGamepadUsage);
+  if (!criteria_arr[1]) {
+    CFRelease(criteria_arr[0]);
+    CFRelease(manager);
+    return;
+  }
+
+  CFArrayRef criteria =
+    CFArrayCreate(kCFAllocatorDefault, (const void**)criteria_arr, 2, nullptr);
+  if (!criteria) {
+    CFRelease(criteria_arr[1]);
+    CFRelease(criteria_arr[0]);
+    CFRelease(manager);
+    return;
+  }
+
+  IOHIDManagerSetDeviceMatchingMultiple(manager, criteria);
+  CFRelease(criteria);
+  CFRelease(criteria_arr[1]);
+  CFRelease(criteria_arr[0]);
+
+  IOHIDManagerRegisterDeviceMatchingCallback(manager,
+                                             DeviceAddedCallback,
+                                             this);
+  IOHIDManagerRegisterDeviceRemovalCallback(manager,
+                                            DeviceRemovedCallback,
+                                            this);
+  IOHIDManagerRegisterInputValueCallback(manager,
+                                         InputValueChangedCallback,
+                                         this);
+  IOHIDManagerScheduleWithRunLoop(manager,
+                                  CFRunLoopGetCurrent(),
+                                  kCFRunLoopDefaultMode);
+  IOReturn rv = IOHIDManagerOpen(manager, kIOHIDOptionsTypeNone);
+  if (rv != kIOReturnSuccess) {
+    CFRelease(manager);
+    return;
+  }
+
+  mManager = manager;
+
+  // We held the handle of the CFRunLoop to make sure we
+  // can shut it down explicitly by CFRunLoopStop in another
+  // thread.
+  mMonitorRunLoop = CFRunLoopGetCurrent();
+
+  // CFRunLoopRun() is a blocking message loop when it's called in
+  // non-main thread so this thread cannot receive any other runnables
+  // and nsITimer timeout events after it's called.
+  CFRunLoopRun();
+}
+
+void DarwinGamepadService::Startup()
+{
+  Unused << NS_NewThread(getter_AddRefs(mMonitorThread),
+                         new DarwinGamepadServiceStartupRunnable(this));
+}
+
+void DarwinGamepadService::Shutdown()
+{
+  IOHIDManagerRef manager = (IOHIDManagerRef)mManager;
+  CFRunLoopStop(mMonitorRunLoop);
+  if (manager) {
+    IOHIDManagerClose(manager, 0);
+    CFRelease(manager);
+    mManager = nullptr;
+  }
+  mMonitorThread->Shutdown();
+}
+
+} // namespace
+
+namespace mozilla {
+namespace dom {
+
+DarwinGamepadService* gService = nullptr;
+
+void StartGamepadMonitoring()
+{
+  if (gService) {
+    return;
+  }
+
+  gService = new DarwinGamepadService();
+  gService->Startup();
+}
+
+void StopGamepadMonitoring()
+{
+  if (!gService) {
+    return;
+  }
+
+  gService->Shutdown();
+  delete gService;
+  gService = nullptr;
+}
+
+} // namespace dom
+} // namespace mozilla

dom/gamepad/moz.build

@@ -48,6 +48,10 @@ if CONFIG['MOZ_GAMEPAD']:
         SOURCES += [
             'fallback/FallbackGamepad.cpp'
         ]
+    elif CONFIG['MOZ_GAMEPAD_BACKEND'] == 'cocoa':
+        SOURCES += [
+            'cocoa/CocoaGamepad.cpp'
+        ]
     elif CONFIG['MOZ_GAMEPAD_BACKEND'] == 'windows':
         SOURCES += [
             'windows/WindowsGamepad.cpp'

dom/geolocation/moz.build

@@ -39,3 +39,7 @@ elif CONFIG['MOZ_WIDGET_TOOLKIT'] in ('gtk2', 'gtk3'):
             '/dom/system/linux',
         ]
         DEFINES['MOZ_GPSD'] = True
+elif CONFIG['MOZ_WIDGET_TOOLKIT'] == 'cocoa':
+    LOCAL_INCLUDES += [
+        '/dom/system/mac',
+    ]

dom/html/HTMLButtonElement.cpp

@@ -156,7 +156,11 @@ HTMLButtonElement::IsHTMLFocusable(bool aWithMouse, bool *aIsFocusable, int32_t
     return true;
   }
 
-  *aIsFocusable = !IsDisabled();
+  *aIsFocusable = 
+#ifdef XP_MACOSX
+    (!aWithMouse || nsFocusManager::sMouseFocusesFormControl) &&
+#endif
+    !IsDisabled();
 
   return false;
 }

dom/html/HTMLImageElement.cpp

@@ -597,6 +597,9 @@ HTMLImageElement::IsHTMLFocusable(bool aWithMouse,
   }
 
   *aIsFocusable =
+#ifdef XP_MACOSX
+    (!aWithMouse || nsFocusManager::sMouseFocusesFormControl) &&
+#endif
     (tabIndex >= 0 || HasAttr(kNameSpaceID_None, nsGkAtoms::tabindex));
 
   return false;

dom/html/HTMLInputElement.cpp

@@ -3566,7 +3566,7 @@ HTMLInputElement::Focus(ErrorResult& aError)
   return;
 }
 
-#if !defined(ANDROID)
+#if !defined(ANDROID) && !defined(XP_MACOSX)
 bool
 HTMLInputElement::IsNodeApzAwareInternal() const
 {
@@ -4728,7 +4728,7 @@ HTMLInputElement::PostHandleEvent(EventChainPostVisitor& aVisitor)
           }
           break;
         }
-#if !defined(ANDROID)
+#if !defined(ANDROID) && !defined(XP_MACOSX)
         case eWheel: {
           // Handle wheel events as increasing / decreasing the input element's
           // value when it's focused and it's type is number or range.
@@ -6665,7 +6665,7 @@ FireEventForAccessibility(nsIDOMHTMLInputElement* aTarget,
 void
 HTMLInputElement::UpdateApzAwareFlag()
 {
-#if !defined(ANDROID)
+#if !defined(ANDROID) && !defined(XP_MACOSX)
   if ((mType == NS_FORM_INPUT_NUMBER) || (mType == NS_FORM_INPUT_RANGE)) {
     SetMayBeApzAware();
   }
@@ -7239,7 +7239,11 @@ HTMLInputElement::IsHTMLFocusable(bool aWithMouse, bool* aIsFocusable, int32_t*
     return false;
   }
 
+#ifdef XP_MACOSX
+  const bool defaultFocusable = !aWithMouse || nsFocusManager::sMouseFocusesFormControl;
+#else
   const bool defaultFocusable = true;
+#endif
 
   if (mType == NS_FORM_INPUT_FILE ||
       mType == NS_FORM_INPUT_NUMBER ||

dom/html/HTMLInputElement.h

@@ -137,7 +137,7 @@ public:
   virtual void Focus(ErrorResult& aError) override;
 
   // nsINode
-#if !defined(ANDROID)
+#if !defined(ANDROID) && !defined(XP_MACOSX)
   virtual bool IsNodeApzAwareInternal() const override;
 #endif
 

dom/html/HTMLObjectElement.cpp

@@ -18,6 +18,11 @@
 #include "nsNPAPIPluginInstance.h"
 #include "nsIWidget.h"
 #include "nsContentUtils.h"
+#ifdef XP_MACOSX
+#include "mozilla/EventDispatcher.h"
+#include "mozilla/dom/Event.h"
+#include "nsFocusManager.h"
+#endif
 
 namespace mozilla {
 namespace dom {
@@ -39,6 +44,9 @@ HTMLObjectElement::HTMLObjectElement(already_AddRefed<mozilla::dom::NodeInfo>& a
 
 HTMLObjectElement::~HTMLObjectElement()
 {
+#ifdef XP_MACOSX
+  OnFocusBlurPlugin(this, false);
+#endif
   UnregisterActivityObserver();
   DestroyImageLoadingContent();
 }
@@ -109,6 +117,131 @@ NS_IMPL_ELEMENT_CLONE(HTMLObjectElement)
 // nsIConstraintValidation
 NS_IMPL_NSICONSTRAINTVALIDATION(HTMLObjectElement)
 
+#ifdef XP_MACOSX
+
+static nsIWidget* GetWidget(Element* aElement)
+{
+  return nsContentUtils::WidgetForDocument(aElement->OwnerDoc());
+}
+
+Element* HTMLObjectElement::sLastFocused = nullptr; // Weak
+
+class PluginFocusSetter : public Runnable
+{
+public:
+  PluginFocusSetter(nsIWidget* aWidget, Element* aElement)
+  : mWidget(aWidget), mElement(aElement)
+  {
+  }
+
+  NS_IMETHOD Run() override
+  {
+    if (mElement) {
+      HTMLObjectElement::sLastFocused = mElement;
+      bool value = true;
+      mWidget->SetPluginFocused(value);
+    } else if (!HTMLObjectElement::sLastFocused) {
+      bool value = false;
+      mWidget->SetPluginFocused(value);
+    }
+
+    return NS_OK;
+  }
+
+private:
+  nsCOMPtr<nsIWidget> mWidget;
+  nsCOMPtr<Element> mElement;
+};
+
+void
+HTMLObjectElement::OnFocusBlurPlugin(Element* aElement, bool aFocus)
+{
+  // In general we don't want to call nsIWidget::SetPluginFocused() for any
+  // Element that doesn't have a plugin running.  But if SetPluginFocused(true)
+  // was just called for aElement while it had a plugin running, we want to
+  // make sure nsIWidget::SetPluginFocused(false) gets called for it now, even
+  // if aFocus is true.
+  if (aFocus) {
+    nsCOMPtr<nsIObjectLoadingContent> olc = do_QueryInterface(aElement);
+    bool hasRunningPlugin = false;
+    if (olc) {
+      // nsIObjectLoadingContent::GetHasRunningPlugin() fails when
+      // nsContentUtils::IsCallerChrome() returns false (which it can do even
+      // when we're processing a trusted focus event).  We work around this by
+      // calling nsObjectLoadingContent::HasRunningPlugin() directly.
+      hasRunningPlugin =
+        static_cast<nsObjectLoadingContent*>(olc.get())->HasRunningPlugin();
+    }
+    if (!hasRunningPlugin) {
+      aFocus = false;
+    }
+  }
+
+  if (aFocus || aElement == sLastFocused) {
+    if (!aFocus) {
+      sLastFocused = nullptr;
+    }
+    nsIWidget* widget = GetWidget(aElement);
+    if (widget) {
+      nsContentUtils::AddScriptRunner(
+        new PluginFocusSetter(widget, aFocus ? aElement : nullptr));
+    }
+  }
+}
+
+void
+HTMLObjectElement::HandlePluginCrashed(Element* aElement)
+{
+  OnFocusBlurPlugin(aElement, false);
+}
+
+void
+HTMLObjectElement::HandlePluginInstantiated(Element* aElement)
+{
+  // If aElement is already focused when a plugin is instantiated, we need
+  // to initiate a call to nsIWidget::SetPluginFocused(true).  Otherwise
+  // keyboard input won't work in a click-to-play plugin until aElement
+  // loses focus and regains it.
+  nsIContent* focusedContent = nullptr;
+  nsFocusManager *fm = nsFocusManager::GetFocusManager();
+  if (fm) {
+    focusedContent = fm->GetFocusedContent();
+  }
+  if (SameCOMIdentity(focusedContent, aElement)) {
+    OnFocusBlurPlugin(aElement, true);
+  }
+}
+
+void
+HTMLObjectElement::HandleFocusBlurPlugin(Element* aElement,
+                                         WidgetEvent* aEvent)
+{
+  if (!aEvent->IsTrusted()) {
+    return;
+  }
+  switch (aEvent->mMessage) {
+    case eFocus: {
+      OnFocusBlurPlugin(aElement, true);
+      break;
+    }
+    case eBlur: {
+      OnFocusBlurPlugin(aElement, false);
+      break;
+    }
+    default:
+      break;
+  }
+}
+
+NS_IMETHODIMP
+HTMLObjectElement::PostHandleEvent(EventChainPostVisitor& aVisitor)
+{
+  HandleFocusBlurPlugin(this, aVisitor.mEvent);
+  return NS_OK;
+}
+
+#endif // #ifdef XP_MACOSX
+
 NS_IMETHODIMP
 HTMLObjectElement::GetForm(nsIDOMHTMLFormElement **aForm)
 {
@@ -149,6 +282,14 @@ void
 HTMLObjectElement::UnbindFromTree(bool aDeep,
                                   bool aNullParent)
 {
+#ifdef XP_MACOSX
+  // When a page is reloaded (when an nsIDocument's content is removed), the
+  // focused element isn't necessarily sent an eBlur event. See
+  // nsFocusManager::ContentRemoved(). This means that a widget may think it
+  // still contains a focused plugin when it doesn't -- which in turn can
+  // disable text input in the browser window. See bug 1137229.
+  OnFocusBlurPlugin(this, false);
+#endif
   nsObjectLoadingContent::UnbindFromTree(aDeep, aNullParent);
   nsGenericHTMLFormElement::UnbindFromTree(aDeep, aNullParent);
 }

dom/html/HTMLObjectElement.h

@@ -32,6 +32,18 @@ public:
   NS_IMPL_FROMCONTENT_HTML_WITH_TAG(HTMLObjectElement, object)
   virtual int32_t TabIndexDefault() override;
 
+#ifdef XP_MACOSX
+  // nsIDOMEventTarget
+  NS_IMETHOD PostHandleEvent(EventChainPostVisitor& aVisitor) override;
+  // Helper methods
+  static void OnFocusBlurPlugin(Element* aElement, bool aFocus);
+  static void HandleFocusBlurPlugin(Element* aElement, WidgetEvent* aEvent);
+  static void HandlePluginCrashed(Element* aElement);
+  static void HandlePluginInstantiated(Element* aElement);
+  // Weak pointer. Null if last action was blur.
+  static Element* sLastFocused;
+#endif
+
   // Element
   virtual bool IsInteractiveHTMLContent(bool aIgnoreTabindex) const override;
 

dom/html/HTMLSharedObjectElement.cpp

@@ -16,6 +16,10 @@
 #include "nsIScriptError.h"
 #include "nsIWidget.h"
 #include "nsContentUtils.h"
+#ifdef XP_MACOSX
+#include "mozilla/EventDispatcher.h"
+#include "mozilla/dom/Event.h"
+#endif
 #include "mozilla/dom/HTMLObjectElement.h"
 
 
@@ -38,6 +42,9 @@ HTMLSharedObjectElement::HTMLSharedObjectElement(already_AddRefed<mozilla::dom::
 
 HTMLSharedObjectElement::~HTMLSharedObjectElement()
 {
+#ifdef XP_MACOSX
+  HTMLObjectElement::OnFocusBlurPlugin(this, false);
+#endif
   UnregisterActivityObserver();
   DestroyImageLoadingContent();
 }
@@ -89,6 +96,17 @@ NS_INTERFACE_MAP_END_INHERITING(nsGenericHTMLElement)
 
 NS_IMPL_ELEMENT_CLONE(HTMLSharedObjectElement)
 
+#ifdef XP_MACOSX
+
+NS_IMETHODIMP
+HTMLSharedObjectElement::PostHandleEvent(EventChainPostVisitor& aVisitor)
+{
+  HTMLObjectElement::HandleFocusBlurPlugin(this, aVisitor.mEvent);
+  return NS_OK;
+}
+
+#endif // #ifdef XP_MACOSX
+
 void
 HTMLSharedObjectElement::AsyncEventRunning(AsyncEventDispatcher* aEvent)
 {
@@ -130,6 +148,14 @@ void
 HTMLSharedObjectElement::UnbindFromTree(bool aDeep,
                                         bool aNullParent)
 {
+#ifdef XP_MACOSX
+  // When a page is reloaded (when an nsIDocument's content is removed), the
+  // focused element isn't necessarily sent an eBlur event. See
+  // nsFocusManager::ContentRemoved(). This means that a widget may think it
+  // still contains a focused plugin when it doesn't -- which in turn can
+  // disable text input in the browser window. See bug 1137229.
+  HTMLObjectElement::OnFocusBlurPlugin(this, false);
+#endif
   nsObjectLoadingContent::UnbindFromTree(aDeep, aNullParent);
   nsGenericHTMLElement::UnbindFromTree(aDeep, aNullParent);
 }

dom/html/HTMLSharedObjectElement.h

@@ -31,6 +31,11 @@ public:
 
   virtual int32_t TabIndexDefault() override;
 
+#ifdef XP_MACOSX
+  // nsIDOMEventTarget
+  NS_IMETHOD PostHandleEvent(EventChainPostVisitor& aVisitor) override;
+#endif
+
   // nsIDOMHTMLAppletElement
   NS_DECL_NSIDOMHTMLAPPLETELEMENT
 

dom/html/HTMLSummaryElement.cpp

@@ -116,8 +116,15 @@ HTMLSummaryElement::IsHTMLFocusable(bool aWithMouse, bool* aIsFocusable,
     return disallowOverridingFocusability;
   }
 
-  // The main summary element is focusable on all supported platforms.
+#ifdef XP_MACOSX
+  // The parent does not have strong opinion about the focusability of this main
+  // summary element, but we'd like to override it when mouse clicking on Mac OS
+  // like other form elements.
+  *aIsFocusable = !aWithMouse || nsFocusManager::sMouseFocusesFormControl;
+#else
+  // The main summary element is focusable on other platforms.
   *aIsFocusable = true;
+#endif
 
   // Give a chance to allow the subclass to override aIsFocusable.
   return false;

dom/html/nsGenericHTMLElement.cpp

@@ -2170,6 +2170,10 @@ nsGenericHTMLFormElement::IsHTMLFocusable(bool aWithMouse,
     return true;
   }
 
+#ifdef XP_MACOSX
+  *aIsFocusable =
+    (!aWithMouse || nsFocusManager::sMouseFocusesFormControl) && *aIsFocusable;
+#endif
   return false;
 }
 

dom/media/GraphDriver.cpp

@@ -14,6 +14,10 @@
 #include "webrtc/MediaEngineWebRTC.h"
 #endif
 
+#ifdef XP_MACOSX
+#include <sys/sysctl.h>
+#endif
+
 extern mozilla::LazyLogModule gMediaStreamGraphLog;
 #define STREAM_LOG(type, msg) MOZ_LOG(gMediaStreamGraphLog, type, msg)
 
@@ -582,6 +586,32 @@ AudioCallbackDriver::~AudioCallbackDriver()
   MOZ_ASSERT(mPromisesForOperation.IsEmpty());
 }
 
+bool IsMacbookOrMacbookAir()
+{
+#ifdef XP_MACOSX
+  size_t len = 0;
+  sysctlbyname("hw.model", NULL, &len, NULL, 0);
+  if (len) {
+    UniquePtr<char[]> model(new char[len]);
+    // This string can be
+    // MacBook%d,%d for a normal MacBook
+    // MacBookPro%d,%d for a MacBook Pro
+    // MacBookAir%d,%d for a Macbook Air
+    sysctlbyname("hw.model", model.get(), &len, NULL, 0);
+    char* substring = strstr(model.get(), "MacBook");
+    if (substring) {
+      const size_t offset = strlen("MacBook");
+      if (strncmp(model.get() + offset, "Air", len - offset) ||
+          isdigit(model[offset + 1])) {
+        return true;
+      }
+    }
+    return false;
+  }
+#endif
+  return false;
+}
+
 void
 AudioCallbackDriver::Init()
 {
@@ -618,6 +648,13 @@ AudioCallbackDriver::Init()
     }
   }
 
+  // Macbook and MacBook air don't have enough CPU to run very low latency
+  // MediaStreamGraphs, cap the minimal latency to 512 frames int this case.
+  if (IsMacbookOrMacbookAir()) {
+    latency_frames = std::max((uint32_t) 512, latency_frames);
+  }
+
+
   input = output;
   input.channels = mInputChannels; // change to support optional stereo capture
 
@@ -1031,6 +1068,44 @@ AudioCallbackDriver::MixerCallback(AudioDataValue* aMixedBuffer,
   NS_WARNING_ASSERTION(written == aFrames - toWrite, "Dropping frames.");
 };
 
+void AudioCallbackDriver::PanOutputIfNeeded(bool aMicrophoneActive)
+{
+#ifdef XP_MACOSX
+  cubeb_device* out;
+  int rv;
+  char name[128];
+  size_t length = sizeof(name);
+
+  rv = sysctlbyname("hw.model", name, &length, NULL, 0);
+  if (rv) {
+    return;
+  }
+
+  if (!strncmp(name, "MacBookPro", 10)) {
+    if (cubeb_stream_get_current_device(mAudioStream, &out) == CUBEB_OK) {
+      // Check if we are currently outputing sound on external speakers.
+      if (!strcmp(out->output_name, "ispk")) {
+        // Pan everything to the right speaker.
+        if (aMicrophoneActive) {
+          if (cubeb_stream_set_panning(mAudioStream, 1.0) != CUBEB_OK) {
+            NS_WARNING("Could not pan audio output to the right.");
+          }
+        } else {
+          if (cubeb_stream_set_panning(mAudioStream, 0.0) != CUBEB_OK) {
+            NS_WARNING("Could not pan audio output to the center.");
+          }
+        }
+      } else {
+        if (cubeb_stream_set_panning(mAudioStream, 0.0) != CUBEB_OK) {
+          NS_WARNING("Could not pan audio output to the center.");
+        }
+      }
+      cubeb_stream_device_destroy(mAudioStream, out);
+    }
+  }
+#endif
+}
+
 void
 AudioCallbackDriver::DeviceChangedCallback() {
   // Tell the audio engine the device has changed, it might want to reset some
@@ -1039,6 +1114,9 @@ AudioCallbackDriver::DeviceChangedCallback() {
   if (mAudioInput) {
     mAudioInput->DeviceChanged();
   }
+#ifdef XP_MACOSX
+  PanOutputIfNeeded(mMicrophoneActive);
+#endif
 }
 
 void
@@ -1047,6 +1125,10 @@ AudioCallbackDriver::SetMicrophoneActive(bool aActive)
   MonitorAutoLock mon(mGraphImpl->GetMonitor());
 
   mMicrophoneActive = aActive;
+
+#ifdef XP_MACOSX
+  PanOutputIfNeeded(mMicrophoneActive);
+#endif
 }
 
 uint32_t

dom/media/GraphDriver.h

@@ -456,6 +456,11 @@ public:
 
   void CompleteAudioContextOperations(AsyncCubebOperation aOperation);
 private:
+  /**
+   * On certain MacBookPro, the microphone is located near the left speaker.
+   * We need to pan the sound output to the right speaker if we are using the
+   * mic and the built-in speaker, or we will have terrible echo.  */
+  void PanOutputIfNeeded(bool aMicrophoneActive);
   /**
    * This is called when the output device used by the cubeb stream changes. */
   void DeviceChangedCallback();

dom/media/eme/MediaKeySystemAccessManager.cpp

@@ -14,6 +14,9 @@
 #ifdef XP_WIN
 #include "mozilla/WindowsVersion.h"
 #endif
+#ifdef XP_MACOSX
+#include "nsCocoaFeatures.h"
+#endif
 #include "nsPrintfCString.h"
 
 namespace mozilla {

dom/media/gmp/GMPChild.cpp

@@ -112,12 +112,14 @@ GetPluginFile(const nsAString& aPluginPath,
   nsAutoString baseName;
   GetFileBase(aPluginPath, aLibDirectory, aLibFile, baseName);
 
-#if defined(OS_POSIX)
+#if defined(XP_MACOSX)
+  nsAutoString binaryName = NS_LITERAL_STRING("lib") + baseName + NS_LITERAL_STRING(".dylib");
+#elif defined(OS_POSIX)
   nsAutoString binaryName = NS_LITERAL_STRING("lib") + baseName + NS_LITERAL_STRING(".so");
 #elif defined(XP_WIN)
   nsAutoString binaryName =                            baseName + NS_LITERAL_STRING(".dll");
 #else
-#error Unsupported O.S.
+#error not defined
 #endif
   aLibFile->AppendRelativePath(binaryName);
   return true;

dom/media/gmp/rlz/GMPDeviceBinding.cpp

@@ -32,6 +32,14 @@
 #include "windows.h"
 #endif
 
+#ifdef XP_MACOSX
+#include <assert.h>
+#ifdef HASH_NODE_ID_WITH_DEVICE_ID
+#include <unistd.h>
+#include <mach/mach.h>
+#include <mach/mach_vm.h>
+#endif
+#endif
 
 #endif // HASH_NODE_ID_WITH_DEVICE_ID
 
@@ -75,6 +83,46 @@ GetStackAfterCurrentFrame(uint8_t** aOutTop, uint8_t** aOutBottom)
 }
 #endif
 
+#if defined(XP_MACOSX) && defined(HASH_NODE_ID_WITH_DEVICE_ID)
+static mach_vm_address_t
+RegionContainingAddress(mach_vm_address_t aAddress)
+{
+  mach_port_t task;
+  kern_return_t kr = task_for_pid(mach_task_self(), getpid(), &task);
+  if (kr != KERN_SUCCESS) {
+    return 0;
+  }
+
+  mach_vm_address_t address = aAddress;
+  mach_vm_size_t size;
+  vm_region_basic_info_data_64_t info;
+  mach_msg_type_number_t count = VM_REGION_BASIC_INFO_COUNT_64;
+  mach_port_t object_name;
+  kr = mach_vm_region(task, &address, &size, VM_REGION_BASIC_INFO_64,
+                      reinterpret_cast<vm_region_info_t>(&info), &count,
+                      &object_name);
+  if (kr != KERN_SUCCESS || size == 0
+      || address > aAddress || address + size <= aAddress) {
+    // mach_vm_region failed, or couldn't find region at given address.
+    return 0;
+  }
+
+  return address;
+}
+
+MOZ_NEVER_INLINE
+static bool
+GetStackAfterCurrentFrame(uint8_t** aOutTop, uint8_t** aOutBottom)
+{
+  mach_vm_address_t stackFrame =
+    reinterpret_cast<mach_vm_address_t>(__builtin_frame_address(0));
+  *aOutTop = reinterpret_cast<uint8_t*>(stackFrame);
+  // Kernel code shows that stack is always a single region.
+  *aOutBottom = reinterpret_cast<uint8_t*>(RegionContainingAddress(stackFrame));
+  return *aOutBottom && (*aOutBottom < *aOutTop);
+}
+#endif
+
 #ifdef HASH_NODE_ID_WITH_DEVICE_ID
 static void SecureMemset(void* start, uint8_t value, size_t size)
 {

dom/media/platforms/ffmpeg/FFmpegRuntimeLinker.cpp

@@ -26,6 +26,14 @@ public:
 static FFmpegLibWrapper sLibAV;
 
 static const char* sLibs[] = {
+#if defined(XP_DARWIN)
+  "libavcodec.58.dylib",
+  "libavcodec.57.dylib",
+  "libavcodec.56.dylib",
+  "libavcodec.55.dylib",
+  "libavcodec.54.dylib",
+  "libavcodec.53.dylib",
+#else
   "libavcodec.so.58",
   "libavcodec-ffmpeg.so.58",
   "libavcodec-ffmpeg.so.57",
@@ -35,6 +43,7 @@ static const char* sLibs[] = {
   "libavcodec.so.55",
   "libavcodec.so.54",
   "libavcodec.so.53",
+#endif
 };
 
 /* static */ bool

dom/media/standalone/moz.build

@@ -13,6 +13,9 @@ SOURCES += [
     '../VideoSegment.cpp',
 ]
 
+if CONFIG['MOZ_WIDGET_TOOLKIT'] == 'cocoa':
+    UNIFIED_SOURCES += ['../systemservices/OSXRunLoopSingleton.cpp']
+
 LOCAL_INCLUDES += [
     '/caps',
     '/dom/base',

dom/media/systemservices/LoadMonitor.cpp

@@ -31,6 +31,12 @@
 #include <unistd.h>
 #endif
 
+#ifdef XP_MACOSX
+#include <mach/mach_host.h>
+#include <mach/mach_init.h>
+#include <mach/host_info.h>
+#endif
+
 #if defined(__DragonFly__) || defined(__FreeBSD__) \
  || defined(__NetBSD__) || defined(__OpenBSD__)
 #include <sys/sysctl.h>
@@ -404,6 +410,27 @@ nsresult RTCLoadInfo::UpdateSystemLoad()
   const uint64_t cpu_times = nice + system + user;
   const uint64_t total_times = cpu_times + idle;
 
+  UpdateCpuLoad(mTicksPerInterval,
+                total_times,
+                cpu_times,
+                &mSystemLoad);
+  return NS_OK;
+#elif defined(XP_MACOSX)
+  mach_msg_type_number_t info_cnt = HOST_CPU_LOAD_INFO_COUNT;
+  host_cpu_load_info_data_t load_info;
+  kern_return_t rv = host_statistics(mach_host_self(), HOST_CPU_LOAD_INFO,
+                                     (host_info_t)(&load_info), &info_cnt);
+
+  if (rv != KERN_SUCCESS || info_cnt != HOST_CPU_LOAD_INFO_COUNT) {
+    LOG(("Error from mach/host_statistics call"));
+    return NS_ERROR_FAILURE;
+  }
+
+  const uint64_t cpu_times = load_info.cpu_ticks[CPU_STATE_NICE]
+                           + load_info.cpu_ticks[CPU_STATE_SYSTEM]
+                           + load_info.cpu_ticks[CPU_STATE_USER];
+  const uint64_t total_times = cpu_times + load_info.cpu_ticks[CPU_STATE_IDLE];
+
   UpdateCpuLoad(mTicksPerInterval,
                 total_times,
                 cpu_times,

dom/media/systemservices/OSXRunLoopSingleton.cpp

@@ -0,0 +1,44 @@
+/* -*- 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 "OSXRunLoopSingleton.h"
+#include <mozilla/StaticMutex.h>
+
+#include <AudioUnit/AudioUnit.h>
+#include <CoreAudio/AudioHardware.h>
+#include <CoreAudio/HostTime.h>
+#include <CoreFoundation/CoreFoundation.h>
+
+static bool gRunLoopSet = false;
+static mozilla::StaticMutex gMutex;
+
+void mozilla_set_coreaudio_notification_runloop_if_needed()
+{
+  mozilla::StaticMutexAutoLock lock(gMutex);
+  if (gRunLoopSet) {
+    return;
+  }
+
+  /* This is needed so that AudioUnit listeners get called on this thread, and
+   * not the main thread. If we don't do that, they are not called, or a crash
+   * occur, depending on the OSX version. */
+  AudioObjectPropertyAddress runloop_address = {
+    kAudioHardwarePropertyRunLoop,
+    kAudioObjectPropertyScopeGlobal,
+    kAudioObjectPropertyElementMaster
+  };
+
+  CFRunLoopRef run_loop = nullptr;
+
+  OSStatus r;
+  r = AudioObjectSetPropertyData(kAudioObjectSystemObject,
+                                 &runloop_address,
+                                 0, NULL, sizeof(CFRunLoopRef), &run_loop);
+  if (r != noErr) {
+    NS_WARNING("Could not make global CoreAudio notifications use their own thread.");
+  }
+
+  gRunLoopSet = true;
+}

dom/media/systemservices/OSXRunLoopSingleton.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 OSXRUNLOOPSINGLETON_H_
+#define OSXRUNLOOPSINGLETON_H_
+
+#include <mozilla/Types.h>
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+/* This function tells CoreAudio to use its own thread for device change
+ * notifications, and can be called from any thread without external
+ * synchronization. */
+void MOZ_EXPORT
+mozilla_set_coreaudio_notification_runloop_if_needed();
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif // OSXRUNLOOPSINGLETON_H_