accessible/xpcom/xpcAccessibleMacInterface.mm

   1 /* clang-format off */
   2 /* -*- Mode: Objective-C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   3 /* clang-format on */
   4 /* vim: set ts=2 et sw=2 tw=80: */
   5 /* This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
   7  * You can obtain one at http://mozilla.org/MPL/2.0/. */
   8
   9 #include "xpcAccessibleMacInterface.h"
  10
  11 #include "nsCocoaUtils.h"
  12 #include "nsContentUtils.h"
  13 #include "nsIObserverService.h"
  14 #include "nsISimpleEnumerator.h"
  15 #include "nsIXPConnect.h"
  16 #include "mozilla/dom/ToJSValue.h"
  17 #include "mozilla/Services.h"
  18 #include "nsString.h"
  19 #include "js/PropertyAndElement.h"  // JS_Enumerate, JS_GetElement, JS_GetProperty, JS_GetPropertyById, JS_HasOwnProperty, JS_SetUCProperty
  20
  21 #import "mozAccessible.h"
  22
  23 using namespace mozilla::a11y;
  24
  25 // xpcAccessibleMacNSObjectWrapper
  26
  27 NS_IMPL_ISUPPORTS(xpcAccessibleMacNSObjectWrapper, nsIAccessibleMacNSObjectWrapper)
  28
  29 xpcAccessibleMacNSObjectWrapper::xpcAccessibleMacNSObjectWrapper(id aNativeObj)
  30     : mNativeObject(aNativeObj) {
  31   [mNativeObject retain];
  32 }
  33
  34 xpcAccessibleMacNSObjectWrapper::~xpcAccessibleMacNSObjectWrapper() { [mNativeObject release]; }
  35
  36 id xpcAccessibleMacNSObjectWrapper::GetNativeObject() { return mNativeObject; }
  37
  38 // xpcAccessibleMacInterface
  39
  40 NS_IMPL_ISUPPORTS_INHERITED(xpcAccessibleMacInterface, xpcAccessibleMacNSObjectWrapper,
  41                             nsIAccessibleMacInterface)
  42
  43 xpcAccessibleMacInterface::xpcAccessibleMacInterface(Accessible* aObj)
  44     : xpcAccessibleMacNSObjectWrapper(GetNativeFromGeckoAccessible(aObj)) {}
  45
  46 NS_IMETHODIMP
  47 xpcAccessibleMacInterface::GetAttributeNames(nsTArray<nsString>& aAttributeNames) {
  48   NS_OBJC_BEGIN_TRY_BLOCK_RETURN
  49
  50   if (!mNativeObject || [mNativeObject isExpired]) {
  51     return NS_ERROR_NOT_AVAILABLE;
  52   }
  53
  54   for (NSString* name in [mNativeObject accessibilityAttributeNames]) {
  55     nsAutoString attribName;
  56     nsCocoaUtils::GetStringForNSString(name, attribName);
  57     aAttributeNames.AppendElement(attribName);
  58   }
  59
  60   return NS_OK;
  61
  62   NS_OBJC_END_TRY_BLOCK_RETURN(NS_ERROR_FAILURE)
  63 }
  64
  65 NS_IMETHODIMP
  66 xpcAccessibleMacInterface::GetParameterizedAttributeNames(nsTArray<nsString>& aAttributeNames) {
  67   NS_OBJC_BEGIN_TRY_BLOCK_RETURN
  68
  69   if (!mNativeObject || [mNativeObject isExpired]) {
  70     return NS_ERROR_NOT_AVAILABLE;
  71   }
  72
  73   for (NSString* name in [mNativeObject accessibilityParameterizedAttributeNames]) {
  74     nsAutoString attribName;
  75     nsCocoaUtils::GetStringForNSString(name, attribName);
  76     aAttributeNames.AppendElement(attribName);
  77   }
  78
  79   return NS_OK;
  80
  81   NS_OBJC_END_TRY_BLOCK_RETURN(NS_ERROR_FAILURE)
  82 }
  83
  84 NS_IMETHODIMP
  85 xpcAccessibleMacInterface::GetActionNames(nsTArray<nsString>& aActionNames) {
  86   NS_OBJC_BEGIN_TRY_BLOCK_RETURN
  87
  88   if (!mNativeObject || [mNativeObject isExpired]) {
  89     return NS_ERROR_NOT_AVAILABLE;
  90   }
  91
  92   for (NSString* name in [mNativeObject accessibilityActionNames]) {
  93     nsAutoString actionName;
  94     nsCocoaUtils::GetStringForNSString(name, actionName);
  95     aActionNames.AppendElement(actionName);
  96   }
  97
  98   return NS_OK;
  99
 100   NS_OBJC_END_TRY_BLOCK_RETURN(NS_ERROR_FAILURE)
 101 }
 102
 103 NS_IMETHODIMP
 104 xpcAccessibleMacInterface::PerformAction(const nsAString& aActionName) {
 105   NS_OBJC_BEGIN_TRY_BLOCK_RETURN
 106
 107   if (!mNativeObject || [mNativeObject isExpired]) {
 108     return NS_ERROR_NOT_AVAILABLE;
 109   }
 110
 111   NSString* actionName = nsCocoaUtils::ToNSString(aActionName);
 112   [mNativeObject accessibilityPerformAction:actionName];
 113
 114   return NS_OK;
 115
 116   NS_OBJC_END_TRY_BLOCK_RETURN(NS_ERROR_FAILURE)
 117 }
 118
 119 NS_IMETHODIMP
 120 xpcAccessibleMacInterface::GetAttributeValue(const nsAString& aAttributeName, JSContext* aCx,
 121                                              JS::MutableHandleValue aResult) {
 122   NS_OBJC_BEGIN_TRY_BLOCK_RETURN
 123
 124   if (!mNativeObject || [mNativeObject isExpired]) {
 125     return NS_ERROR_NOT_AVAILABLE;
 126   }
 127
 128   NSString* attribName = nsCocoaUtils::ToNSString(aAttributeName);
 129   return NSObjectToJsValue([mNativeObject accessibilityAttributeValue:attribName], aCx, aResult);
 130
 131   NS_OBJC_END_TRY_BLOCK_RETURN(NS_ERROR_FAILURE)
 132 }
 133
 134 NS_IMETHODIMP
 135 xpcAccessibleMacInterface::IsAttributeSettable(const nsAString& aAttributeName, bool* aIsSettable) {
 136   NS_ENSURE_ARG_POINTER(aIsSettable);
 137
 138   NSString* attribName = nsCocoaUtils::ToNSString(aAttributeName);
 139   if ([mNativeObject respondsToSelector:@selector(accessibilityIsAttributeSettable:)]) {
 140     *aIsSettable = [mNativeObject accessibilityIsAttributeSettable:attribName];
 141     return NS_OK;
 142   }
 143
 144   return NS_ERROR_NOT_IMPLEMENTED;
 145 }
 146
 147 NS_IMETHODIMP
 148 xpcAccessibleMacInterface::SetAttributeValue(const nsAString& aAttributeName,
 149                                              JS::HandleValue aAttributeValue, JSContext* aCx) {
 150   nsresult rv = NS_OK;
 151   id obj = JsValueToNSObject(aAttributeValue, aCx, &rv);
 152   NS_ENSURE_SUCCESS(rv, rv);
 153
 154   NSString* attribName = nsCocoaUtils::ToNSString(aAttributeName);
 155   if ([mNativeObject respondsToSelector:@selector(accessibilitySetValue:forAttribute:)]) {
 156     // The NSObject has an attribute setter, call that.
 157     [mNativeObject accessibilitySetValue:obj forAttribute:attribName];
 158     return NS_OK;
 159   }
 160
 161   return NS_ERROR_NOT_IMPLEMENTED;
 162 }
 163
 164 NS_IMETHODIMP
 165 xpcAccessibleMacInterface::GetParameterizedAttributeValue(const nsAString& aAttributeName,
 166                                                           JS::HandleValue aParameter,
 167                                                           JSContext* aCx,
 168                                                           JS::MutableHandleValue aResult) {
 169   nsresult rv = NS_OK;
 170   id paramObj = JsValueToNSObject(aParameter, aCx, &rv);
 171   NS_ENSURE_SUCCESS(rv, rv);
 172
 173   NSString* attribName = nsCocoaUtils::ToNSString(aAttributeName);
 174   return NSObjectToJsValue(
 175       [mNativeObject accessibilityAttributeValue:attribName forParameter:paramObj], aCx, aResult);
 176 }
 177
 178 bool xpcAccessibleMacInterface::SupportsSelector(SEL aSelector) {
 179   // return true if we have this selector, and if isAccessibilitySelectorAllowed
 180   // is implemented too whether it is "allowed".
 181   return [mNativeObject respondsToSelector:aSelector] &&
 182          (![mNativeObject respondsToSelector:@selector(isAccessibilitySelectorAllowed:selector:)] ||
 183           [mNativeObject isAccessibilitySelectorAllowed:aSelector]);
 184 }
 185
 186 nsresult xpcAccessibleMacInterface::NSObjectToJsValue(id aObj, JSContext* aCx,
 187                                                       JS::MutableHandleValue aResult) {
 188   if (!aObj) {
 189     aResult.set(JS::NullValue());
 190   } else if ([aObj isKindOfClass:[NSString class]]) {
 191     nsAutoString strVal;
 192     nsCocoaUtils::GetStringForNSString((NSString*)aObj, strVal);
 193     if (!mozilla::dom::ToJSValue(aCx, strVal, aResult)) {
 194       return NS_ERROR_FAILURE;
 195     }
 196   } else if ([aObj isKindOfClass:[NSNumber class]]) {
 197     // If the type being held by the NSNumber is a BOOL set js value
 198     // to boolean. Otherwise use a double value.
 199     if (strcmp([(NSNumber*)aObj objCType], @encode(BOOL)) == 0) {
 200       if (!mozilla::dom::ToJSValue(aCx, [(NSNumber*)aObj boolValue], aResult)) {
 201         return NS_ERROR_FAILURE;
 202       }
 203     } else {
 204       if (!mozilla::dom::ToJSValue(aCx, [(NSNumber*)aObj doubleValue], aResult)) {
 205         return NS_ERROR_FAILURE;
 206       }
 207     }
 208   } else if ([aObj isKindOfClass:[NSValue class]] &&
 209              strcmp([(NSValue*)aObj objCType], @encode(NSPoint)) == 0) {
 210     NSPoint point = [(NSValue*)aObj pointValue];
 211     return NSObjectToJsValue(
 212         @[ [NSNumber numberWithDouble:point.x], [NSNumber numberWithDouble:point.y] ], aCx,
 213         aResult);
 214   } else if ([aObj isKindOfClass:[NSValue class]] &&
 215              strcmp([(NSValue*)aObj objCType], @encode(NSSize)) == 0) {
 216     NSSize size = [(NSValue*)aObj sizeValue];
 217     return NSObjectToJsValue(
 218         @[ [NSNumber numberWithDouble:size.width], [NSNumber numberWithDouble:size.height] ], aCx,
 219         aResult);
 220   } else if ([aObj isKindOfClass:[NSValue class]] &&
 221              strcmp([(NSValue*)aObj objCType], @encode(NSRange)) == 0) {
 222     NSRange range = [(NSValue*)aObj rangeValue];
 223     return NSObjectToJsValue(@[ @(range.location), @(range.length) ], aCx, aResult);
 224   } else if ([aObj isKindOfClass:[NSValue class]] &&
 225              strcmp([(NSValue*)aObj objCType], @encode(NSRect)) == 0) {
 226     NSRect rect = [(NSValue*)aObj rectValue];
 227     return NSObjectToJsValue(@{
 228       @"origin" : [NSValue valueWithPoint:rect.origin],
 229       @"size" : [NSValue valueWithSize:rect.size]
 230     },
 231                              aCx, aResult);
 232   } else if ([aObj isKindOfClass:[NSArray class]]) {
 233     NSArray* objArr = (NSArray*)aObj;
 234
 235     JS::RootedVector<JS::Value> v(aCx);
 236     if (!v.resize([objArr count])) {
 237       return NS_ERROR_FAILURE;
 238     }
 239     for (size_t i = 0; i < [objArr count]; ++i) {
 240       nsresult rv = NSObjectToJsValue(objArr[i], aCx, v[i]);
 241       NS_ENSURE_SUCCESS(rv, rv);
 242     }
 243
 244     JSObject* arrayObj = JS::NewArrayObject(aCx, v);
 245     if (!arrayObj) {
 246       return NS_ERROR_FAILURE;
 247     }
 248     aResult.setObject(*arrayObj);
 249   } else if ([aObj isKindOfClass:[NSDictionary class]]) {
 250     JS::RootedObject obj(aCx, JS_NewPlainObject(aCx));
 251     for (NSString* key in aObj) {
 252       nsAutoString strKey;
 253       nsCocoaUtils::GetStringForNSString(key, strKey);
 254       JS::RootedValue value(aCx);
 255       nsresult rv = NSObjectToJsValue(aObj[key], aCx, &value);
 256       NS_ENSURE_SUCCESS(rv, rv);
 257       JS_SetUCProperty(aCx, obj, strKey.get(), strKey.Length(), value);
 258     }
 259     aResult.setObject(*obj);
 260   } else if ([aObj isKindOfClass:[NSAttributedString class]]) {
 261     NSAttributedString* attrStr = (NSAttributedString*)aObj;
 262     __block NSMutableArray* attrRunArray = [[NSMutableArray alloc] init];
 263
 264     [attrStr
 265         enumerateAttributesInRange:NSMakeRange(0, [attrStr length])
 266                            options:NSAttributedStringEnumerationLongestEffectiveRangeNotRequired
 267                         usingBlock:^(NSDictionary* attributes, NSRange range, BOOL* stop) {
 268                           NSString* str = [[attrStr string] substringWithRange:range];
 269                           if (!str || !attributes) {
 270                             return;
 271                           }
 272
 273                           NSMutableDictionary* attrRun = [attributes mutableCopy];
 274                           attrRun[@"string"] = str;
 275
 276                           [attrRunArray addObject:attrRun];
 277                         }];
 278
 279     // The attributed string is represented in js as an array of objects.
 280     // Each object represents a run of text where the "string" property is the
 281     // string value and all the AX* properties are the attributes.
 282     return NSObjectToJsValue(attrRunArray, aCx, aResult);
 283   } else if (CFGetTypeID(aObj) == CGColorGetTypeID()) {
 284     const CGFloat* components = CGColorGetComponents((CGColorRef)aObj);
 285     NSString* hexString =
 286         [NSString stringWithFormat:@"#%02x%02x%02x", (int)(components[0] * 0xff),
 287                                    (int)(components[1] * 0xff), (int)(components[2] * 0xff)];
 288     return NSObjectToJsValue(hexString, aCx, aResult);
 289   } else if ([aObj respondsToSelector:@selector(isAccessibilityElement)]) {
 290     // We expect all of our accessibility objects to implement isAccessibilityElement
 291     // at the very least. If it is implemented we will assume its an accessibility object.
 292     nsCOMPtr<nsIAccessibleMacInterface> obj = new xpcAccessibleMacInterface(aObj);
 293     return nsContentUtils::WrapNative(aCx, obj, &NS_GET_IID(nsIAccessibleMacInterface), aResult);
 294   } else {
 295     // If this is any other kind of NSObject, just wrap it and return it.
 296     // It will be opaque and immutable on the JS side, but it can be
 297     // brought back to us in an argument.
 298     nsCOMPtr<nsIAccessibleMacNSObjectWrapper> obj = new xpcAccessibleMacNSObjectWrapper(aObj);
 299     return nsContentUtils::WrapNative(aCx, obj, &NS_GET_IID(nsIAccessibleMacNSObjectWrapper),
 300                                       aResult);
 301   }
 302
 303   return NS_OK;
 304 }
 305
 306 id xpcAccessibleMacInterface::JsValueToNSObject(JS::HandleValue aValue, JSContext* aCx,
 307                                                 nsresult* aResult) {
 308   *aResult = NS_OK;
 309   if (aValue.isInt32()) {
 310     return [NSNumber numberWithInteger:aValue.toInt32()];
 311   } else if (aValue.isBoolean()) {
 312     return [NSNumber numberWithBool:aValue.toBoolean()];
 313   } else if (aValue.isString()) {
 314     nsAutoJSString temp;
 315     if (!temp.init(aCx, aValue)) {
 316       NS_WARNING("cannot init string with given value");
 317       *aResult = NS_ERROR_FAILURE;
 318       return nil;
 319     }
 320     return nsCocoaUtils::ToNSString(temp);
 321   } else if (aValue.isObject()) {
 322     JS::Rooted<JSObject*> obj(aCx, aValue.toObjectOrNull());
 323
 324     bool isArray;
 325     JS::IsArrayObject(aCx, obj, &isArray);
 326     if (isArray) {
 327       // If this is an array, we construct an NSArray and insert the js
 328       // array's elements by recursively calling this function.
 329       uint32_t len;
 330       JS::GetArrayLength(aCx, obj, &len);
 331       NSMutableArray* array = [NSMutableArray arrayWithCapacity:len];
 332       for (uint32_t i = 0; i < len; i++) {
 333         JS::RootedValue v(aCx);
 334         JS_GetElement(aCx, obj, i, &v);
 335         [array addObject:JsValueToNSObject(v, aCx, aResult)];
 336         NS_ENSURE_SUCCESS(*aResult, nil);
 337       }
 338       return array;
 339     }
 340
 341     bool hasValueType;
 342     bool hasValue;
 343     JS_HasOwnProperty(aCx, obj, "valueType", &hasValueType);
 344     JS_HasOwnProperty(aCx, obj, "value", &hasValue);
 345     if (hasValueType && hasValue) {
 346       // A js object representin an NSValue looks like this:
 347       // { valueType: "NSRange", value: [1, 3] }
 348       return JsValueToNSValue(obj, aCx, aResult);
 349     }
 350
 351     bool hasObjectType;
 352     bool hasObject;
 353     JS_HasOwnProperty(aCx, obj, "objectType", &hasObjectType);
 354     JS_HasOwnProperty(aCx, obj, "object", &hasObject);
 355     if (hasObjectType && hasObject) {
 356       // A js object representing an NSDictionary looks like this:
 357       // { objectType: "NSDictionary", value: {k: v, k: v, ...} }
 358       return JsValueToSpecifiedNSObject(obj, aCx, aResult);
 359     }
 360
 361     // This may be another nsIAccessibleMacInterface instance.
 362     // If so, return the wrapped NSObject.
 363     nsCOMPtr<nsIXPConnect> xpc = nsIXPConnect::XPConnect();
 364
 365     nsCOMPtr<nsIXPConnectWrappedNative> wrappedObj;
 366     nsresult rv = xpc->GetWrappedNativeOfJSObject(aCx, obj, getter_AddRefs(wrappedObj));
 367     NS_ENSURE_SUCCESS(rv, nil);
 368     nsCOMPtr<nsIAccessibleMacNSObjectWrapper> macObjIface = do_QueryInterface(wrappedObj->Native());
 369     return macObjIface->GetNativeObject();
 370   }
 371
 372   *aResult = NS_ERROR_FAILURE;
 373   return nil;
 374 }
 375
 376 id xpcAccessibleMacInterface::JsValueToNSValue(JS::HandleObject aObject, JSContext* aCx,
 377                                                nsresult* aResult) {
 378   *aResult = NS_ERROR_FAILURE;
 379   JS::RootedValue valueTypeValue(aCx);
 380   if (!JS_GetProperty(aCx, aObject, "valueType", &valueTypeValue)) {
 381     NS_WARNING("Could not get valueType");
 382     return nil;
 383   }
 384
 385   JS::RootedValue valueValue(aCx);
 386   if (!JS_GetProperty(aCx, aObject, "value", &valueValue)) {
 387     NS_WARNING("Could not get value");
 388     return nil;
 389   }
 390
 391   nsAutoJSString valueType;
 392   if (!valueTypeValue.isString() || !valueType.init(aCx, valueTypeValue)) {
 393     NS_WARNING("valueType is not a string");
 394     return nil;
 395   }
 396
 397   bool isArray;
 398   JS::IsArrayObject(aCx, valueValue, &isArray);
 399   if (!isArray) {
 400     NS_WARNING("value is not an array");
 401     return nil;
 402   }
 403
 404   JS::Rooted<JSObject*> value(aCx, valueValue.toObjectOrNull());
 405
 406   if (valueType.EqualsLiteral("NSRange")) {
 407     uint32_t len;
 408     JS::GetArrayLength(aCx, value, &len);
 409     if (len != 2) {
 410       NS_WARNING("Expected a 2 member array");
 411       return nil;
 412     }
 413
 414     JS::RootedValue locationValue(aCx);
 415     JS_GetElement(aCx, value, 0, &locationValue);
 416     JS::RootedValue lengthValue(aCx);
 417     JS_GetElement(aCx, value, 1, &lengthValue);
 418     if (!locationValue.isInt32() || !lengthValue.isInt32()) {
 419       NS_WARNING("Expected an array of integers");
 420       return nil;
 421     }
 422
 423     *aResult = NS_OK;
 424     return [NSValue valueWithRange:NSMakeRange(locationValue.toInt32(), lengthValue.toInt32())];
 425   }
 426
 427   return nil;
 428 }
 429
 430 id xpcAccessibleMacInterface::JsValueToSpecifiedNSObject(JS::HandleObject aObject, JSContext* aCx,
 431                                                          nsresult* aResult) {
 432   *aResult = NS_ERROR_FAILURE;
 433   JS::RootedValue objectTypeValue(aCx);
 434   if (!JS_GetProperty(aCx, aObject, "objectType", &objectTypeValue)) {
 435     NS_WARNING("Could not get objectType");
 436     return nil;
 437   }
 438
 439   JS::RootedValue objectValue(aCx);
 440   if (!JS_GetProperty(aCx, aObject, "object", &objectValue)) {
 441     NS_WARNING("Could not get object");
 442     return nil;
 443   }
 444
 445   nsAutoJSString objectType;
 446   if (!objectTypeValue.isString()) {
 447     NS_WARNING("objectType is not a string");
 448     return nil;
 449   }
 450
 451   if (!objectType.init(aCx, objectTypeValue)) {
 452     NS_WARNING("cannot init string with object type");
 453     return nil;
 454   }
 455
 456   bool isObject = objectValue.isObjectOrNull();
 457   if (!isObject) {
 458     NS_WARNING("object is not a JSON object");
 459     return nil;
 460   }
 461
 462   JS::Rooted<JSObject*> object(aCx, objectValue.toObjectOrNull());
 463
 464   if (objectType.EqualsLiteral("NSDictionary")) {
 465     JS::Rooted<JS::IdVector> ids(aCx, JS::IdVector(aCx));
 466     if (!JS_Enumerate(aCx, object, &ids)) {
 467       NS_WARNING("Unable to get keys from dictionary object");
 468       return nil;
 469     }
 470
 471     NSMutableDictionary* dict = [[NSMutableDictionary alloc] init];
 472
 473     for (size_t i = 0, n = ids.length(); i < n; i++) {
 474       nsresult rv = NS_OK;
 475       // get current key
 476       JS::RootedValue currentKey(aCx);
 477       JS_IdToValue(aCx, ids[i], &currentKey);
 478       id unwrappedKey = JsValueToNSObject(currentKey, aCx, &rv);
 479       NS_ENSURE_SUCCESS(rv, nil);
 480       MOZ_ASSERT([unwrappedKey isKindOfClass:[NSString class]]);
 481
 482       // get associated value for current key
 483       JS::RootedValue currentValue(aCx);
 484       JS_GetPropertyById(aCx, object, ids[i], &currentValue);
 485       id unwrappedValue = JsValueToNSObject(currentValue, aCx, &rv);
 486       NS_ENSURE_SUCCESS(rv, nil);
 487       dict[unwrappedKey] = unwrappedValue;
 488     }
 489
 490     *aResult = NS_OK;
 491     return dict;
 492   }
 493
 494   return nil;
 495 }
 496
 497 NS_IMPL_ISUPPORTS(xpcAccessibleMacEvent, nsIAccessibleMacEvent)
 498
 499 xpcAccessibleMacEvent::xpcAccessibleMacEvent(id aNativeObj, id aData)
 500     : mNativeObject(aNativeObj), mData(aData) {
 501   [mNativeObject retain];
 502   [mData retain];
 503 }
 504
 505 xpcAccessibleMacEvent::~xpcAccessibleMacEvent() {
 506   [mNativeObject release];
 507   [mData release];
 508 }
 509
 510 NS_IMETHODIMP
 511 xpcAccessibleMacEvent::GetMacIface(nsIAccessibleMacInterface** aMacIface) {
 512   RefPtr<xpcAccessibleMacInterface> macIface = new xpcAccessibleMacInterface(mNativeObject);
 513   macIface.forget(aMacIface);
 514   return NS_OK;
 515 }
 516
 517 NS_IMETHODIMP
 518 xpcAccessibleMacEvent::GetData(JSContext* aCx, JS::MutableHandleValue aData) {
 519   return xpcAccessibleMacInterface::NSObjectToJsValue(mData, aCx, aData);
 520 }
 521
 522 void xpcAccessibleMacEvent::FireEvent(id aNativeObj, id aNotification, id aUserInfo) {
 523   if (nsCOMPtr<nsIObserverService> obsService = services::GetObserverService()) {
 524     nsCOMPtr<nsISimpleEnumerator> observers;
 525     // Get all observers for the mac event topic.
 526     obsService->EnumerateObservers(NS_ACCESSIBLE_MAC_EVENT_TOPIC, getter_AddRefs(observers));
 527     if (observers) {
 528       bool hasObservers = false;
 529       observers->HasMoreElements(&hasObservers);
 530       // If we have observers, notify them.
 531       if (hasObservers) {
 532         nsCOMPtr<nsIAccessibleMacEvent> xpcIface = new xpcAccessibleMacEvent(aNativeObj, aUserInfo);
 533         nsAutoString notificationStr;
 534         nsCocoaUtils::GetStringForNSString(aNotification, notificationStr);
 535         obsService->NotifyObservers(xpcIface, NS_ACCESSIBLE_MAC_EVENT_TOPIC, notificationStr.get());
 536       }
 537     }
 538   }
 539 }